def scaleGeoms(self, scale):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature scaled",
self.entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
sizeFldName = None
if qad_layer.isTextLayer(layer):
# se l'altezza testo dipende da un solo campo
sizeFldNames = qad_label.get_labelSizeFieldNames(layer)
if len(sizeFldNames) == 1 and len(sizeFldNames[0]) > 0:
sizeFldName = sizeFldNames[0]
elif qad_layer.isSymbolLayer(layer):
# se la scala dipende da un campo
sizeFldName = qad_layer.get_symbolScaleFieldName(layer)
if len(sizeFldName) == 0:
sizeFldName = None
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
if self.scale(f, transformedBasePt, scale, sizeFldName,
layerEntitySet, entitySet) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def RotateGeoms(self, angle):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature rotated",
entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
if self.rotate(f, transformedBasePt, angle, rotFldName,
layerEntitySet, entitySet) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def scaleGeoms(self, scale):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature scaled", self.entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
sizeFldName = None
if qad_layer.isTextLayer(layer):
# se l'altezza testo dipende da un solo campo
sizeFldNames = qad_label.get_labelSizeFieldNames(layer)
if len(sizeFldNames) == 1 and len(sizeFldNames[0]) > 0:
sizeFldName = sizeFldNames[0]
elif qad_layer.isSymbolLayer(layer):
# se la scala dipende da un campo
sizeFldName = qad_layer.get_symbolScaleFieldName(layer)
if len(sizeFldName) == 0:
sizeFldName = None
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
if self.scale(f, transformedBasePt, scale, sizeFldName, layerEntitySet, entitySet) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def init_db_tab(self):
self.onInit = True
# layer linee
for index, layer in enumerate(self.plugIn.iface.legendInterface().layers()):
if (layer.type() == QgsMapLayer.VectorLayer) and layer.geometryType() == QGis.Line:
self.linearLayerName.addItem(layer.name(), index)
# seleziono un elemento della lista
if self.dimStyle.linearLayerName is not None:
index = self.linearLayerName.findText(self.dimStyle.linearLayerName)
self.linearLayerName.setCurrentIndex(index)
self.linearLayerNameChanged(index)
# layer simboli
for index, layer in enumerate(self.plugIn.iface.legendInterface().layers()):
if qad_layer.isSymbolLayer(layer):
self.symbolLayerName.addItem(layer.name(), index)
# seleziono un elemento della lista
if self.dimStyle.symbolLayerName is not None:
index = self.symbolLayerName.findText(self.dimStyle.symbolLayerName)
self.symbolLayerName.setCurrentIndex(index)
self.symbolLayerNameChanged(index)
# layer testi
for index, layer in enumerate(self.plugIn.iface.legendInterface().layers()):
if qad_layer.isTextLayer(layer):
self.textualLayerName.addItem(layer.name(), index)
# seleziono un elemento della lista
if self.dimStyle.textualLayerName is not None:
index = self.textualLayerName.findText(self.dimStyle.textualLayerName)
self.textualLayerName.setCurrentIndex(index)
self.textualLayerNameChanged(index)
self.onInit = False
def RotateGeoms(self, angle):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature rotated", entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
if self.rotate(f, transformedBasePt, angle, rotFldName, layerEntitySet, entitySet) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def init_db_tab(self):
self.onInit = True
# layer linee
for index, layer in enumerate(self.plugIn.iface.legendInterface().layers()):
if (layer.type() == QgsMapLayer.VectorLayer) and layer.geometryType() == QGis.Line:
self.linearLayerName.addItem(layer.name(), index)
# seleziono un elemento della lista
if self.dimStyle.linearLayerName is not None:
index = self.linearLayerName.findText(self.dimStyle.linearLayerName)
self.linearLayerName.setCurrentIndex(index)
self.linearLayerNameChanged(index)
# layer simboli
for index, layer in enumerate(self.plugIn.iface.legendInterface().layers()):
if qad_layer.isSymbolLayer(layer):
self.symbolLayerName.addItem(layer.name(), index)
# seleziono un elemento della lista
if self.dimStyle.symbolLayerName is not None:
index = self.symbolLayerName.findText(self.dimStyle.symbolLayerName)
self.symbolLayerName.setCurrentIndex(index)
self.symbolLayerNameChanged(index)
# layer testi
for index, layer in enumerate(self.plugIn.iface.legendInterface().layers()):
if qad_layer.isTextLayer(layer):
self.textualLayerName.addItem(layer.name(), index)
# seleziono un elemento della lista
if self.dimStyle.textualLayerName is not None:
index = self.textualLayerName.findText(self.dimStyle.textualLayerName)
self.textualLayerName.setCurrentIndex(index)
self.textualLayerNameChanged(index)
self.onInit = False
def mirrorGeoms(self):
entity = QadEntity()
self.plugIn.beginEditCommand("Feature mirrored",
self.entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
for layerEntitySet in self.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
transformedNewPt = self.mapToLayerCoordinates(
layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.mirror(entity, transformedBasePt, transformedNewPt,
rotFldName) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.mirror(dimEntity, transformedBasePt,
transformedNewPt, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
def mirrorGeoms(self):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature mirrored",
self.entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(
layer, self.firstMirrorPt)
transformedNewPt = self.mapToLayerCoordinates(
layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
entity = QadEntity()
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(entity)
if dimStyle is not None:
dimEntity = QadDimEntity()
if dimEntity.initByDimId(dimStyle, dimId) == False:
dimEntity = None
else:
dimEntity = None
if self.mirror(f, transformedBasePt, transformedNewPt,
rotFldName, layerEntitySet, entitySet,
dimEntity) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def scaleFeatures(self, scale):
entity = QadEntity()
self.plugIn.beginEditCommand("Feature scaled",
self.entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
for layerEntitySet in self.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
sizeFldName = ""
if qad_layer.isTextLayer(layer):
# se l'altezza testo dipende da un solo campo
sizeFldNames = qad_label.get_labelSizeFieldNames(layer)
if len(sizeFldNames) == 1 and len(sizeFldNames[0]) > 0:
sizeFldName = sizeFldNames[0]
elif qad_layer.isSymbolLayer(layer):
# se la scala dipende da un campo
sizeFldName = qad_layer.get_symbolScaleFieldName(layer)
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.scale(entity, transformedBasePt, scale,
sizeFldName) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.scale(dimEntity, transformedBasePt, scale,
sizeFldName) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
def mirrorGeoms(self):
entity = QadEntity()
self.plugIn.beginEditCommand("Feature mirrored", self.entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
for layerEntitySet in self.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
transformedNewPt = self.mapToLayerCoordinates(layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.mirror(entity, transformedBasePt, transformedNewPt, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.mirror(dimEntity, transformedBasePt, transformedNewPt, rotFldName) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
def scaleFeatures(self, scale):
entity = QadEntity()
self.plugIn.beginEditCommand("Feature scaled", self.entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
for layerEntitySet in self.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.basePt)
sizeFldName = ""
if qad_layer.isTextLayer(layer):
# se l'altezza testo dipende da un solo campo
sizeFldNames = qad_label.get_labelSizeFieldNames(layer)
if len(sizeFldNames) == 1 and len(sizeFldNames[0]) > 0:
sizeFldName = sizeFldNames[0]
elif qad_layer.isSymbolLayer(layer):
# se la scala dipende da un campo
sizeFldName = qad_layer.get_symbolScaleFieldName(layer)
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.scale(entity, transformedBasePt, scale, sizeFldName) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.scale(dimEntity, transformedBasePt, scale, sizeFldName) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
def mirrorGeoms(self):
# copio entitySet
entitySet = QadEntitySet(self.entitySet)
self.plugIn.beginEditCommand("Feature mirrored", self.entitySet.getLayerList())
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
transformedBasePt = self.mapToLayerCoordinates(layer, self.firstMirrorPt)
transformedNewPt = self.mapToLayerCoordinates(layer, self.secondMirrorPt)
rotFldName = ""
if qad_layer.isTextLayer(layer):
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(layer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
rotFldName = rotFldNames[0]
elif qad_layer.isSymbolLayer(layer):
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
while len(layerEntitySet.featureIds) > 0:
featureId = layerEntitySet.featureIds[0]
f = layerEntitySet.getFeature(featureId)
entity = QadEntity()
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(entity)
if dimStyle is not None:
dimEntity = QadDimEntity()
if dimEntity.initByDimId(dimStyle, dimId) == False:
dimEntity = None
else:
dimEntity = None
if self.mirror(f, transformedBasePt, transformedNewPt, rotFldName, layerEntitySet, entitySet, dimEntity) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapRenderer().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nIl sistema di riferimento del progetto deve essere un sistema di coordinate proiettate.\n"))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate("QAD", "\nIl layer corrente non é di tipo simbolo.")
errMsg = errMsg + QadMsg.translate("QAD", "\nUn layer simbolo é un layer vettoriale di tipo punto senza etichetta.\n")
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PUNTO DI INSERIMENTO
if self.step == 0: # inizio del comando
self.waitForPoint() # si appresta ad attendere un punto
self.step = self.step + 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO DI INSERIMENTO
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
pt = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
pt = msg
self.insPt = QgsPoint(pt)
self.plugIn.setLastPoint(self.insPt)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(currLayer)
if len(scaleFldName) > 0:
# si appresta ad attendere la scala
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la scala del simbolo <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.scale))
self.GetDistClass.dist = self.scale
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE | QadInputModeEnum.NOT_ZERO
self.GetDistClass.startPt = self.insPt
self.step = 2
self.GetDistClass.run(msgMapTool, msg)
return False
else:
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la rotazione del simbolo <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
#=========================================================================
# RISPOSTA ALLA RICHIESTA SCALA (da step = 1)
elif self.step == 2:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.scale = self.GetDistClass.dist
self.plugIn.setLastScale(self.scale)
del self.GetDistClass
self.GetDistClass = None
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la rotazione del simbolo <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE (da step = 1 o 2)
elif self.step == 3:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.addFeature(currLayer)
return True # fine comando
else:
return True
return False
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"
)
)
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate("QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate("QAD", "\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
if len(QadDimStyles.getDimListByLayer(currLayer)) > 0:
errMsg = QadMsg.translate("QAD", "\nThe current layer belongs to a dimension style.\n")
self.showErr(errMsg)
return True # fine comando
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
return False # continua
# =========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ENT:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
# se il layer di destinazione è di tipo simbolo
if qad_layer.isSymbolLayer(currLayer) == True:
# se il simbolo può essere ruotato
if len(qad_layer.get_symbolRotationFieldName(currLayer)) > 0:
self.waitForAlignmentObjs()
else:
self.waitForSegmentNumber()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine comando
return True
self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
# =========================================================================
# RISPOSTA ALLA RICHIESTA DI ALLINEARE GLI OGGETTI (da step = ASK_FOR_ENT)
elif (
self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT
): # dopo aver atteso una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
value = self.defaultValue
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
# la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("QAD", "Yes") or value == "Yes":
self.objectAlignment = True
else:
self.objectAlignment = False
self.waitForSegmentNumber()
return False
# =========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI SEGMENTI (da step = ASK_FOR_ALIGNMENT)
# =========================================================================
elif (
self.step == QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER
): # dopo aver atteso un numero intero si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
# il numero di segmenti arriva come parametro della funzione
self.nSegments = msg
self.doDivide(currLayer)
return True # fine comando
return False
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(
self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate(
"QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate(
"QAD",
"\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
if len(QadDimStyles.getDimListByLayer(currLayer)) > 0:
errMsg = QadMsg.translate(
"QAD", "\nThe current layer belongs to a dimension style.\n")
self.showErr(errMsg)
return True # fine comando
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ENT:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
# se il layer di destinazione è di tipo simbolo
if qad_layer.isSymbolLayer(currLayer) == True:
# se il simbolo può essere ruotato
if len(qad_layer.get_symbolRotationFieldName(
currLayer)) > 0:
self.waitForAlignmentObjs()
else:
self.waitForSegmentNumber()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine comando
return True
self.showMsg(
QadMsg.translate("QAD",
"No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI ALLINEARE GLI OGGETTI (da step = ASK_FOR_ENT)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT: # dopo aver atteso una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
value = self.defaultValue
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
else:
# la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("QAD", "Yes") or value == "Yes":
self.objectAlignment = True
else:
self.objectAlignment = False
self.waitForSegmentNumber()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI SEGMENTI (da step = ASK_FOR_ALIGNMENT)
#=========================================================================
elif self.step == QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER: # dopo aver atteso un numero intero si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
return False
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
else:
# il numero di segmenti arriva come parametro della funzione
self.nSegments = msg
self.doDivide(currLayer)
return True # fine comando
return False
def __initQadInfo(self):
# inizializza entityType, qadGeom, dimStyle, dimId
if self.isInitialized() == False:
return QadEntityGeomTypeEnum.NONE
self.dimStyle = None
self.dimId = None
g = self.getGeometry()
if g is None:
return QadEntityGeomTypeEnum.NONE
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
coordTransform = QgsCoordinateTransform(
self.layer.crs(),
iface.mapCanvas().mapRenderer().destinationCrs())
g.transform(coordTransform)
wkbType = g.wkbType()
if wkbType == QGis.WKBPoint:
from qad_dim import QadDimStyles # to avoid cyclic import
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(self)
if (dimStyle is not None) and (dimId is not None):
self.dimStyle = dimStyle # stile di quotatura di appartenenza
self.dimId = dimId # codice quotatura di appartenenza
if qad_layer.isTextLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.TEXT
elif qad_layer.isSymbolLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.SYMBOL
self.qadGeom = g.asPoint() # un punto
if wkbType == QGis.WKBMultiPoint:
if qad_layer.isTextLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.TEXT
elif qad_layer.isSymbolLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.SYMBOL
self.qadGeom = g.asMultiPoint() # lista di punti
elif wkbType == QGis.WKBLineString:
from qad_dim import QadDimStyles # to avoid cyclic import
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(self)
if (dimStyle is not None) and (dimId is not None):
self.entityType = QadEntityGeomTypeEnum.DIMENSION_COMPONENT
self.dimStyle = dimStyle # stile di quotatura di appartenenza
self.dimId = dimId # codice quotatura di appartenenza
self.entityType, self.qadGeom = self.__fromPoyline(g.asPolyline())
elif wkbType == QGis.WKBMultiLineString:
self.entityType = []
self.qadGeom = []
lineList = g.asMultiPolyline() # vettore di linee
for line in lineList:
entityType, qadGeom = self.__fromPoyline(g.asPolyline())
self.entityType.append(entityType)
self.qadGeom.append(qadGeom)
elif wkbType == QGis.WKBPolygon:
self.entityType = []
self.qadGeom = []
polygon = g.asPolygon() # vettore di linee
for line in polygon:
entityType, qadGeom = self.__fromPoyline(line)
self.entityType.append(entityType)
self.qadGeom.append(qadGeom)
elif wkbType == QGis.WKBMultiPolygon:
self.entityType = []
self.qadGeom = []
polygonList = g.asMultiPolygon() # vettore di poligoni
for polygon in polygonList:
partialEntityType = []
partialQadGeom = []
for line in polygon:
entityType, qadGeom = self.__fromPoyline(line)
partialEntityType.append(entityType)
partialQadGeom.append(qadGeom)
self.entityType.append(partialEntityType)
self.qadGeom.append(partialQadGeom)
def __initQadInfo(self):
# inizializza entityType, qadGeom, dimStyle, dimId
if self.isInitialized() == False:
return QadEntityGeomTypeEnum.NONE
self.dimStyle = None
self.dimId = None
g = self.getGeometry()
if g is None:
return QadEntityGeomTypeEnum.NONE
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
coordTransform = QgsCoordinateTransform(self.layer.crs(), iface.mapCanvas().mapRenderer().destinationCrs())
g.transform(coordTransform)
wkbType = g.wkbType()
if wkbType == QGis.WKBPoint:
from qad_dim import QadDimStyles # to avoid cyclic import
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(self)
if (dimStyle is not None) and (dimId is not None):
self.dimStyle = dimStyle # stile di quotatura di appartenenza
self.dimId = dimId # codice quotatura di appartenenza
if qad_layer.isTextLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.TEXT
elif qad_layer.isSymbolLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.SYMBOL
self.qadGeom = g.asPoint() # un punto
if wkbType == QGis.WKBMultiPoint:
if qad_layer.isTextLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.TEXT
elif qad_layer.isSymbolLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.SYMBOL
self.qadGeom = g.asMultiPoint() # lista di punti
elif wkbType == QGis.WKBLineString:
from qad_dim import QadDimStyles # to avoid cyclic import
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(self)
if (dimStyle is not None) and (dimId is not None):
self.entityType = QadEntityGeomTypeEnum.DIMENSION_COMPONENT
self.dimStyle = dimStyle # stile di quotatura di appartenenza
self.dimId = dimId # codice quotatura di appartenenza
self.entityType, self.qadGeom = self.__fromPoyline(g.asPolyline())
elif wkbType == QGis.WKBMultiLineString:
self.entityType = []
self.qadGeom = []
lineList = g.asMultiPolyline() # vettore di linee
for line in lineList:
entityType, qadGeom = self.__fromPoyline(g.asPolyline())
self.entityType.append(entityType)
self.qadGeom.append(qadGeom)
elif wkbType == QGis.WKBPolygon:
self.entityType = []
self.qadGeom = []
polygon = g.asPolygon() # vettore di linee
for line in polygon:
entityType, qadGeom = self.__fromPoyline(line)
self.entityType.append(entityType)
self.qadGeom.append(qadGeom)
elif wkbType == QGis.WKBMultiPolygon:
self.entityType = []
self.qadGeom = []
polygonList = g.asMultiPolygon() # vettore di poligoni
for polygon in polygonList:
partialEntityType = []
partialQadGeom = []
for line in polygon:
entityType, qadGeom = self.__fromPoyline(line)
partialEntityType.append(entityType)
partialQadGeom.append(qadGeom)
self.entityType.append(partialEntityType)
self.qadGeom.append(partialQadGeom)
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(
self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate(
"QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate(
"QAD",
"\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PUNTO DI INSERIMENTO
if self.step == 0: # inizio del comando
self.waitForPoint() # si appresta ad attendere un punto
self.step = self.step + 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO DI INSERIMENTO
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool(
).point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
pt = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
pt = msg
self.insPt = QgsPoint(pt)
self.plugIn.setLastPoint(self.insPt)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(currLayer)
if len(scaleFldName) > 0:
# si appresta ad attendere la scala
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT",
"Specify the symbol scale <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.scale))
self.GetDistClass.dist = self.scale
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE | QadInputModeEnum.NOT_ZERO
self.GetDistClass.startPt = self.insPt
self.step = 2
self.GetDistClass.run(msgMapTool, msg)
return False
else:
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate(
"Command_INSERT",
"Specify the symbol rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(
str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
#=========================================================================
# RISPOSTA ALLA RICHIESTA SCALA (da step = 1)
elif self.step == 2:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.scale = self.GetDistClass.dist
self.plugIn.setLastScale(self.scale)
del self.GetDistClass
self.GetDistClass = None
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(
currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate(
"Command_INSERT",
"Specify the symbol rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(
str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE (da step = 1 o 2)
elif self.step == 3:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.addFeature(currLayer)
return True # fine comando
else:
return True
return False
