def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.entSelClass = None
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "Select object whose layer will be the current layer: ")
self.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.entSelClass.run(msgMapTool, msg)
def waitForBoundary(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select boundary: ")
# scarto la selezione di punti e polilinee
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = False
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DISJOIN",
"Select object to disjoin: ")
# scarto la selezione di quote
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.deselectOnFinish = True
self.entSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ENT
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DIVIDE", "Select object to divide: ")
# scarto la selezione di punti
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = False
self.entSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_BREAK", "Select the object to break: ")
# scarto la selezione di punti e poligoni
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = False
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "Select object whose layer will be the current layer: ")
self.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.EntSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.step = 1
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate("Command_DIM", "Select arc or polyline arc segment: ")
# scarto la selezione di punti
self.EntSelClass.checkPointLayer = False
self.EntSelClass.checkLineLayer = True
self.EntSelClass.checkPolygonLayer = True
self.EntSelClass.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.EntSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DISJOIN", "Select object to disjoin: ")
# scarto la selezione di quote
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.deselectOnFinish = True
self.entSelClass.run(msgMapTool, msg)
def waitForBoundary(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select boundary: ")
# scarto la selezione di punti e polilinee
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = False
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.step = 1
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate("Command_BREAK", "Select the object to break: ")
# scarto la selezione di punti e poligoni
self.EntSelClass.checkPointLayer = False
self.EntSelClass.checkLineLayer = True
self.EntSelClass.checkPolygonLayer = False
self.EntSelClass.checkDimLayers = False
self.EntSelClass.onlyEditableLayers = True
self.EntSelClass.run(msgMapTool, msg)
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ENT
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DIVIDE", "Select object to divide: ")
# scarto la selezione di punti
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = False
self.entSelClass.run(msgMapTool, msg)
class QadBREAKCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadBREAKCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "BREAK")
def getEnglishName(self):
return "BREAK"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runBREAKCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/break.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_BREAK", "Breaks an object.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entSelClass = None
self.firstPt = None
self.secondPt = None
def __del__(self):
QadCommandClass.__del__(self)
if self.entSelClass is not None:
self.entSelClass.entity.deselectOnLayer()
del self.entSelClass
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getPointMapTool(drawMode)
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
else:
return self.contextualMenu
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_BREAK", "Select the object to break: ")
# scarto la selezione di punti e poligoni
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = False
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
#============================================================================
# breakFeatures
#============================================================================
def breakFeatures(self):
f = self.entSelClass.entity.getFeature()
if f is None:
return
layer = self.entSelClass.entity.layer
LineTempLayer = None
self.plugIn.beginEditCommand("Feature broken", layer)
tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
g = self.layerToMapCoordinates(layer, f.geometry())
result = qad_utils.breakQgsGeometry(g, self.firstPt, self.secondPt, \
tolerance2ApproxCurve)
if result is not None:
line1 = result[0]
line2 = result[1]
atSubGeom = result[2]
if layer.geometryType() == QGis.Line:
if line1 is not None:
updGeom = qad_utils.setSubGeom(g, line1, atSubGeom)
if updGeom is None:
self.plugIn.destroyEditCommand()
return
brokenFeature1 = QgsFeature(f)
# trasformo la geometria nel crs del layer
brokenFeature1.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, layer, brokenFeature1, False, False) == False:
self.plugIn.destroyEditCommand()
return
if line2 is not None:
brokenFeature2 = QgsFeature(f)
# trasformo la geometria nel crs del layer
brokenFeature2.setGeometry(self.mapToLayerCoordinates(layer, line2))
# plugIn, layer, feature, coordTransform, refresh, check_validity
if qad_layer.addFeatureToLayer(self.plugIn, layer, brokenFeature2, None, False, False) == False:
self.plugIn.destroyEditCommand()
return
else:
# aggiungo le linee nei layer temporanei di QAD
if LineTempLayer is None:
LineTempLayer = qad_layer.createQADTempLayer(self.plugIn, QGis.Line)
self.plugIn.addLayerToLastEditCommand("Feature broken", LineTempLayer)
lineGeoms = []
if line1 is not None:
lineGeoms.append(line1)
if line2 is not None:
lineGeoms.append(line2)
# trasformo la geometria in quella dei layer temporanei
# plugIn, pointGeoms, lineGeoms, polygonGeoms, coord, refresh
if qad_layer.addGeometriesToQADTempLayers(self.plugIn, None, lineGeoms, None, None, False) == False:
self.plugIn.destroyEditCommand()
return
updGeom = qad_utils.delSubGeom(g, atSubGeom)
if updGeom is None or updGeom.isGeosEmpty(): # da cancellare
# plugIn, layer, feature id, refresh
if qad_layer.deleteFeatureToLayer(self.plugIn, layer, f.id(), False) == False:
self.plugIn.destroyEditCommand()
return
else:
brokenFeature1 = QgsFeature(f)
# trasformo la geometria nel crs del layer
brokenFeature1.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, layer, brokenFeature1, False, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
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
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
layer = self.entSelClass.entity.layer
self.firstPt = self.entSelClass.point
self.plugIn.setLastPoint(self.firstPt)
keyWords = QadMsg.translate("Command_BREAK", "First point")
prompt = QadMsg.translate("Command_BREAK", "Specify second break point or [{0}]: ").format(keyWords)
self.step = 2
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di selezione entità
englishKeyWords = "First point"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
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 DEL SECONDO PUNTO DI INTERRUZIONE (da step = 1)
elif self.step == 2: # dopo aver atteso un punto o una parola chiave 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
pass # opzione di default "secondo punto"
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None or type(value) == unicode or type(value) == str:
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_BREAK", "Specify first break point: "))
self.step = 3
elif type(value) == QgsPoint: # se é stato inserito il secondo punto
self.secondPt = value
self.plugIn.setLastPoint(self.secondPt)
self.breakFeatures()
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DI INTERRUZIONE (da step = 2)
elif self.step == 3: # 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
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.firstPt = value
self.plugIn.setLastPoint(self.firstPt)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_BREAK", "Specify second break point: "))
self.step = 4
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DI INTERRUZIONE (da step = 3)
elif self.step == 4: # 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
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.secondPt = value
self.plugIn.setLastPoint(self.secondPt)
self.breakFeatures()
return True
class QadBREAKCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadBREAKCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "BREAK")
def getEnglishName(self):
return "BREAK"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runBREAKCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/break.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_BREAK", "Breaks an object.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.EntSelClass = None
self.firstPt = None
self.secondPt = None
def __del__(self):
QadCommandClass.__del__(self)
if self.EntSelClass is not None:
self.EntSelClass.entity.deselectOnLayer()
del self.EntSelClass
def getPointMapTool(self, drawMode=QadGetPointDrawModeEnum.NONE):
if self.step == 1: # quando si é in fase di selezione entità
return self.EntSelClass.getPointMapTool(drawMode)
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.step = 1
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate("Command_BREAK", "Select the object to break: ")
# scarto la selezione di punti e poligoni
self.EntSelClass.checkPointLayer = False
self.EntSelClass.checkLineLayer = True
self.EntSelClass.checkPolygonLayer = False
self.EntSelClass.checkDimLayers = False
self.EntSelClass.onlyEditableLayers = True
self.EntSelClass.run(msgMapTool, msg)
# ============================================================================
# breakFeatures
# ============================================================================
def breakFeatures(self):
f = self.EntSelClass.entity.getFeature()
if f is None:
return
layer = self.EntSelClass.entity.layer
LineTempLayer = None
self.plugIn.beginEditCommand("Feature broken", layer)
tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
g = self.layerToMapCoordinates(layer, f.geometry())
result = qad_utils.breakQgsGeometry(g, self.firstPt, self.secondPt, tolerance2ApproxCurve)
if result is not None:
line1 = result[0]
line2 = result[1]
atSubGeom = result[2]
if layer.geometryType() == QGis.Line:
if line1 is not None:
updGeom = qad_utils.setSubGeom(g, line1, atSubGeom)
if updGeom is None:
self.plugIn.destroyEditCommand()
return
brokenFeature1 = QgsFeature(f)
# trasformo la geometria nel crs del layer
brokenFeature1.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, layer, brokenFeature1, False, False) == False:
self.plugIn.destroyEditCommand()
return
if line2 is not None:
brokenFeature2 = QgsFeature(f)
# trasformo la geometria nel crs del layer
brokenFeature2.setGeometry(self.mapToLayerCoordinates(layer, line2))
# plugIn, layer, feature, coordTransform, refresh, check_validity
if qad_layer.addFeatureToLayer(self.plugIn, layer, brokenFeature2, None, False, False) == False:
self.plugIn.destroyEditCommand()
return
else:
# aggiungo le linee nei layer temporanei di QAD
if LineTempLayer is None:
LineTempLayer = qad_layer.createQADTempLayer(self.plugIn, QGis.Line)
self.plugIn.addLayerToLastEditCommand("Feature broken", LineTempLayer)
lineGeoms = []
if line1 is not None:
lineGeoms.append(line1)
if line2 is not None:
lineGeoms.append(line2)
# trasformo la geometria in quella dei layer temporanei
# plugIn, pointGeoms, lineGeoms, polygonGeoms, coord, refresh
if qad_layer.addGeometriesToQADTempLayers(self.plugIn, None, lineGeoms, None, None, False) == False:
self.plugIn.destroyEditCommand()
return
updGeom = qad_utils.delSubGeom(g, atSubGeom)
if updGeom is None or updGeom.isGeosEmpty(): # da cancellare
# plugIn, layer, feature id, refresh
if qad_layer.deleteFeatureToLayer(self.plugIn, layer, f.id(), False) == False:
self.plugIn.destroyEditCommand()
return
else:
brokenFeature1 = QgsFeature(f)
# trasformo la geometria nel crs del layer
brokenFeature1.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, layer, brokenFeature1, False, False) == 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", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"
)
)
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 == 1:
if self.EntSelClass.run(msgMapTool, msg) == True:
if self.EntSelClass.entity.isInitialized():
layer = self.EntSelClass.entity.layer
self.firstPt = self.EntSelClass.point
self.plugIn.setLastPoint(self.firstPt)
keyWords = QadMsg.translate("Command_BREAK", "First point")
prompt = QadMsg.translate("Command_BREAK", "Specify second break point or [{0}]: ").format(keyWords)
self.step = 2
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di selezione entità
englishKeyWords = "First point"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(
prompt,
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS,
None,
keyWords,
QadInputModeEnum.NONE,
)
return False
else:
self.showMsg(QadMsg.translate("Command_BREAK", "Non ci sono geometrie in questa posizione."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
# =========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DI INTERRUZIONE (da step = 1)
elif self.step == 2: # dopo aver atteso un punto o una parola chiave 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
pass # opzione di default "secondo punto"
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None or type(value) == unicode:
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_BREAK", "Specify first break point: "))
self.step = 3
elif type(value) == QgsPoint: # se é stato inserito il secondo punto
self.secondPt = value
self.plugIn.setLastPoint(self.secondPt)
self.breakFeatures()
return True
return False
# =========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DI INTERRUZIONE (da step = 2)
elif self.step == 3: # 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
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.firstPt = value
self.plugIn.setLastPoint(self.firstPt)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_BREAK", "Specify second break point: "))
self.step = 4
return False
# =========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DI INTERRUZIONE (da step = 3)
elif self.step == 4: # 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
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.secondPt = value
self.plugIn.setLastPoint(self.secondPt)
self.breakFeatures()
return True
class QadSETCURRLAYERBYGRAPHCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadSETCURRLAYERBYGRAPHCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "SETCURRLAYERBYGRAPH")
def getEnglishName(self):
return "SETCURRLAYERBYGRAPH"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"),
self.plugIn.runSETCURRLAYERBYGRAPHCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/setcurrlayerbygraph.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate(
"Command_SETCURRLAYERBYGRAPH",
"Sets a layer of a graphical object as current.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.EntSelClass = None
def __del__(self):
QadCommandClass.__del__(self)
if self.EntSelClass is not None:
del self.EntSelClass
def getPointMapTool(self, drawMode=QadGetPointDrawModeEnum.NONE):
if self.step == 0 or self.step == 1: # quando si é in fase di selezione entità
return self.EntSelClass.getPointMapTool(drawMode)
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.EntSelClass = None
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate(
"Command_SETCURRLAYERBYGRAPH",
"Select object whose layer will be the current layer: ")
self.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.EntSelClass.run(msgMapTool, msg)
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapRenderer().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
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
self.step = 1
return False # continua
elif self.step == 1:
if self.EntSelClass.run(msgMapTool, msg) == True:
if self.EntSelClass.entity.isInitialized():
layer = self.EntSelClass.entity.layer
if self.plugIn.canvas.currentLayer() is None or \
self.plugIn.canvas.currentLayer() != layer:
self.plugIn.canvas.setCurrentLayer(layer)
self.plugIn.iface.setActiveLayer(
layer
) # lancia evento di deactivate e activate dei plugin
self.plugIn.iface.legendInterface(
).refreshLayerSymbology(layer)
msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH",
"\nThe current layer is {0}.")
self.showMsg(msg.format(layer.name()))
del self.EntSelClass
self.EntSelClass = None
return True
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
class QadMAPMPEDITCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadMAPMPEDITCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "MAPMPEDIT")
def getEnglishName(self):
return "MAPMPEDIT"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runMAPMPEDITCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/mapmpedit.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_MAPMPEDIT", "Modifies existing polygon.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.poligonEntity = QadEntity()
self.SSGetClass = QadSSGetClass(plugIn)
self.SSGetClass.onlyEditableLayers = False
self.SSGetClass.checkDimLayers = False # scarto le quote
self.entSelClass = None
self.currSubGeom = None
self.currAtSubGeom = None
self.nOperationsToUndo = 0
def __del__(self):
QadCommandClass.__del__(self)
del self.SSGetClass
self.poligonEntity.deselectOnLayer()
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 1 or self.step == 4: # quando si é in fase di selezione entità
return self.entSelClass.getPointMapTool(drawMode)
elif self.step == 3 or self.step == 5 or \
self.step == 6 or self.step == 7 or self.step == 8: # quando si é in fase di selezione gruppo entità
return self.SSGetClass.getPointMapTool()
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 1 or self.step == 4: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
elif self.step == 3 or self.step == 5 or \
self.step == 6 or self.step == 7 or self.step == 8: # quando si é in fase di selezione gruppo entità
return None # return self.SSGetClass.getCurrentContextualMenu()
else:
return self.contextualMenu
def reinitSSGetClass(self):
checkPointLayer = self.SSGetClass.checkPointLayer
del self.SSGetClass
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.onlyEditableLayers = False
self.SSGetClass.checkDimLayers = False # scarto le quote
self.SSGetClass.checkPointLayer = checkPointLayer
#============================================================================
# setCurrentSubGeom
#============================================================================
def setCurrentSubGeom(self, entSelClass):
"""
Setta la sottogeometria corrente
"""
self.currSubGeom = None
self.currAtSubGeom = None
# verifico che sia stata selezionata un'entità
if entSelClass.entity.isInitialized() == False:
self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
return False
# verifico che sia stata selezionata attraverso un punto
# (per capire quale sottogeometria è stata selezionata)
if entSelClass.point is None: return False
# verifico che sia stato selezionato lo stesso polygono che è da modificare
if self.poligonEntity != entSelClass.entity:
self.showMsg(QadMsg.translate("Command_MAPMPEDIT", "The boundary doesn't belong to the selected polygon."))
return False
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
geom = self.layerToMapCoordinates(entSelClass.entity.layer, entSelClass.entity.getGeometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(entSelClass.point, geom)
if dummy[2] is None:
return False
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
self.currSubGeom, self.currAtSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])
if self.currSubGeom is None or self.currAtSubGeom is None:
self.currSubGeom = None
self.currAtSubGeom = None
return False
return True
#============================================================================
# addEntitySetToPolygon
#============================================================================
def addEntitySetToPolygon(self, entitySet, removeOriginals = False):
"""
Aggiunge il set di entità al poligono da modificare
"""
geom = self.poligonEntity.getGeometry()
layerList = []
layerList.append(self.poligonEntity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Polygon and layer.geometryType() != QGis.Line:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(), self.poligonEntity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di polygonEntity è errore
if layer.id() == self.poligonEntity.layerId() and featureId == self.poligonEntity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# se il poligono è contenuto nella geometria da aggiungere
if geomToAdd.contains(geom):
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geom)
# deve essere un poligono senza ring
if len(simplifiedGeoms) != 1 or simplifiedGeoms[0].wkbType() != QGis.WKBLineString:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
points = simplifiedGeoms[0].asPolyline() # vettore di punti
# aggiungo un'isola
if geomToAdd.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
del geom
geom = QgsGeometry.fromPolygon(geomToAdd.asPolygon())
else: # se il poligono non è contenuto nella geometria da aggiungere
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
# se la geometria da aggiungere è contenuta nel poligono
if geom.contains(QgsGeometry.fromPolyline(points)):
# aggiungo un'isola
if geom.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
# aggiungo una parte
if geom.addPart(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.poligonEntity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# delCurrentSubGeomToPolygon
#============================================================================
def delCurrentSubGeomToPolygon(self):
"""
Cancella la sotto-geometria corrente dal poligono da modificare
"""
geom = self.poligonEntity.getGeometry()
# la posizione é espressa con una lista (<index ogg. princ> [<index ogg. sec.>])
part = self.currAtSubGeom[0]
if len(self.currAtSubGeom) == 2:
ring = self.currAtSubGeom[1]
if geom.deleteRing(ring + 1, part) == False: # cancello una isola (Ring 0 is outer ring and can't be deleted)
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
if geom.deletePart(part) == False: # cancello una parte
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", self.poligonEntity.layer)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
#============================================================================
# unionIntersSubtractEntitySetToPolygon
#============================================================================
def unionIntersSubtractEntitySetToPolygon(self, entitySet, opType, removeOriginals = False):
"""
Unisce o interseca i poligoni di entitySet al poligono corrente
"""
geom = self.poligonEntity.getGeometry()
layerList = []
layerList.append(self.poligonEntity.layer)
geomList = []
geomList.append(geom)
for layerEntitySet in entitySet.layerEntitySetList:
del geomList[:]
layer = layerEntitySet.layer
coordTransform = QgsCoordinateTransform(layer.crs(), self.poligonEntity.layer.crs())
if layer.geometryType() == QGis.Polygon:
for featureId in layerEntitySet.featureIds:
# se la feature è quella di polygonEntity è errore
if layer.id() == self.poligonEntity.layerId() and featureId == self.poligonEntity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
if opType == QadMAPMPEDITCommandOpTypeEnum.UNION: geom = geom.combine(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.INTERSECTION: geom = geom.intersection(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.DIFFERENCE: geom = geom.difference(geomToAdd)
if geom is None:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals and layer.id() != self.poligonEntity.layerId():
layerList.append(layer)
elif layer.geometryType() == QGis.Line:
for featureId in layerEntitySet.featureIds:
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
if simplifiedGeom.wkbType() != QGis.WKBLineString:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
points = simplifiedGeom.asPolyline() # vettore di punti
if len(points) < 4 or points[0] != points[-1]: # polilinea chiusa con almeno 4 punti (primo e ultimo uguali)
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
geomToAdd = QgsGeometry.fromPolygon([points])
if opType == QadMAPMPEDITCommandOpTypeEnum.UNION: geom = geom.combine(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.INTERSECTION: geom = geom.intersection(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.DIFFERENCE: geom = geom.difference(geomToAdd)
if geom is None or geom.type() != QGis.Polygon:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
else:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# convexHullEntitySetToPolygon
#============================================================================
def convexHullEntitySetToPolygon(self, entitySet, removeOriginals = False):
"""
modifica il poligono corrente in modo che includa tutti i punti delle geometrie di entitySet
"""
layerList = []
layerList.append(self.poligonEntity.layer)
pointsForConvexHull = []
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
coordTransform = QgsCoordinateTransform(layer.crs(), self.poligonEntity.layer.crs())
for featureId in layerEntitySet.featureIds:
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geom = f.geometry()
geom.transform(coordTransform)
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geom)
for simplifiedGeom in simplifiedGeoms:
if simplifiedGeom.wkbType() == QGis.WKBLineString:
pointsForConvexHull.extend(simplifiedGeom.asPolyline())
else:
pointsForConvexHull.append(simplifiedGeom.asPoint())
if removeOriginals and layer.id() != self.poligonEntity.layerId():
layerList.append(layer)
geom = QgsGeometry.fromMultiPoint(pointsForConvexHull)
geom = geom.convexHull()
if geom is None:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# dividePolygon
#============================================================================
def splitPolygon(self, splitLine, createNewEntities):
"""
divide il poligono corrente usando una polilinea con i vertci in <plineVertices> in modo da generare o meno nuove entità
"""
layerList = []
layerList.append(self.poligonEntity.layer)
splitLineTransformed = self.mapToLayerCoordinates(self.poligonEntity.layer, splitLine)
f = self.poligonEntity.getFeature()
geom = f.geometry()
result, newGeoms, topologyTestPts = geom.splitGeometry(splitLineTransformed, False)
if result <> 0 or len(newGeoms) == 0:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newfeatures =[]
if createNewEntities:
for newGeom in newGeoms:
newfeature = QgsFeature(f)
newfeature.setGeometry(newGeom)
newfeatures.append(newfeature)
else:
for newGeom in newGeoms:
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(newGeom)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
res = geom.addPart(points)
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if len(newfeatures) > 0:
# plugIn, layer, features, coordTransform, refresh, check_validity
if qad_layer.addFeaturesToLayer(self.plugIn, self.poligonEntity.layer, newfeatures, None, False, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select polygon: ")
# scarto la selezione di punti e polilinee
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = False
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
#============================================================================
# WaitForMainMenu
#============================================================================
def WaitForMainMenu(self):
self.poligonEntity.selectOnLayer(False)
keyWords = QadMsg.translate("Command_MAPMPEDIT", "Add") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Delete") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Union") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Substract") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Intersect") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "split Objects") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "split Parts") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "iNclude objs")
englishKeyWords = "Add" + "/" + "Delete" + "/" + "Union" + "/" + "Substract" + "/" + "Intersect" "/" + \
"split Objects" + "/" + "split Parts" + "/" + "iNclude objs"
if self.nOperationsToUndo > 0: # se c'è qualcosa che si può annullare
keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT", "Undo")
englishKeyWords = englishKeyWords + "/" + "Undo"
keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT", "eXit")
englishKeyWords = englishKeyWords + "/" + "eXit"
default = QadMsg.translate("Command_MAPMPEDIT", "eXit")
prompt = QadMsg.translate("Command_MAPMPEDIT", "Enter an option [{0}] <{1}>: ").format(keyWords, default)
self.step = 2
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.NONE)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
keyWords += "_" + englishKeyWords
# si appresta ad attendere enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
return False
#============================================================================
# waitForBoundary
#============================================================================
def waitForBoundary(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select boundary: ")
# scarto la selezione di punti e polilinee
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = False
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
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
if self.step == 0:
self.waitForEntsel(msgMapTool, msg) # seleziona il poligono da modificare
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE POLIGONO DA MODIFICARE
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
self.poligonEntity.set(self.entSelClass.entity.layer, self.entSelClass.entity.featureId)
layer = self.entSelClass.entity.layer
self.poligonEntity.deselectOnLayer()
self.WaitForMainMenu()
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 DEL MENU PRINCIPALE
elif self.step == 2: # dopo aver atteso una opzione 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
self.WaitForMainMenu()
return False
else: # l'opzione arriva come parametro della funzione
value = msg
self.poligonEntity.deselectOnLayer()
if value == QadMsg.translate("Command_MAPMPEDIT", "Add") or value == "Add":
self.SSGetClass.checkPointLayer = False # scarto i punto
self.SSGetClass.run(msgMapTool, msg)
self.step = 3
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Delete") or value == "Delete":
self.waitForBoundary(msgMapTool, msg)
self.step = 4
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Union") or value == "Union":
self.SSGetClass.checkPointLayer = False # scarto i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 5
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Substract") or value == "Substract":
self.SSGetClass.checkPointLayer = False # scarto i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 6
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Intersect") or value == "Intersect":
self.SSGetClass.checkPointLayer = False # scarto i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 7
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "split Objects") or value == "split Objects":
# Disegna una polilinea di divisione del poligono
self.PLINECommand = QadPLINECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare una linea
# che non verrà salvata su un layer
self.PLINECommand.virtualCmd = True
self.PLINECommand.run(msgMapTool, msg)
self.step = 9
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "split Parts") or value == "split Parts":
# Disegna una polilinea di divisione del poligono
self.PLINECommand = QadPLINECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare una linea
# che non verrà salvata su un layer
self.PLINECommand.virtualCmd = True
self.PLINECommand.run(msgMapTool, msg)
self.step = 10
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "iNclude objs") or value == "iNclude objs":
self.SSGetClass.checkPointLayer = True # includo i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 8
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Undo") or value == "Undo":
if self.nOperationsToUndo > 0:
self.nOperationsToUndo = self.nOperationsToUndo - 1
self.plugIn.undoEditCommand()
else:
self.showMsg(QadMsg.translate("QAD", "\nThe command has been canceled."))
elif value == QadMsg.translate("Command_MAPMPEDIT", "eXit") or value == "eXit":
return True # fine comando
else:
return True # fine comando
self.WaitForMainMenu()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI ADD (da step = 2)
elif self.step == 3:
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.addEntitySetToPolygon(self.SSGetClass.entitySet)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI DELETE (da step = 2)
elif self.step == 4:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.setCurrentSubGeom(self.entSelClass) == True:
self.delCurrentSubGeomToPolygon()
self.WaitForMainMenu()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine selezione entità
self.WaitForMainMenu()
else:
self.waitForBoundary(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI UNION (da step = 2)
elif self.step == 5: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.unionIntersSubtractEntitySetToPolygon(self.SSGetClass.entitySet, QadMAPMPEDITCommandOpTypeEnum.UNION)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI SUBTRACT (da step = 2)
elif self.step == 6: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.unionIntersSubtractEntitySetToPolygon(self.SSGetClass.entitySet, QadMAPMPEDITCommandOpTypeEnum.DIFFERENCE)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI INTERSECT (da step = 2)
elif self.step == 7: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.unionIntersSubtractEntitySetToPolygon(self.SSGetClass.entitySet, QadMAPMPEDITCommandOpTypeEnum.INTERSECTION)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI INCLUDE OBJS (da step = 2)
elif self.step == 8: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.convexHullEntitySetToPolygon(self.SSGetClass.entitySet)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA LINEA DI DIVISIONE (da step = 2)
elif self.step == 9: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.splitPolygon(self.PLINECommand.vertices, True)
del self.PLINECommand
self.PLINECommand = None
self.WaitForMainMenu()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA LINEA DI DIVISIONE (da step = 2)
elif self.step == 10: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.splitPolygon(self.PLINECommand.vertices, False)
del self.PLINECommand
self.PLINECommand = None
self.WaitForMainMenu()
return False
class QadDISJOINCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadDISJOINCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "DISJOIN")
def getEnglishName(self):
return "DISJOIN"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"),
self.plugIn.runDISJOINCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/disjoin.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_DISJOIN",
"Disjoin existing geometries.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entity = QadEntity()
self.SSGetClass = QadSSGetClass(plugIn)
self.SSGetClass.onlyEditableLayers = False
self.SSGetClass.checkDimLayers = False # scarto le quote
self.entSelClass = None
self.currSubGeom = None
self.currAtSubGeom = None
def __del__(self):
QadCommandClass.__del__(self)
del self.SSGetClass
def getPointMapTool(self, drawMode=QadGetPointDrawModeEnum.NONE):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getPointMapTool(drawMode)
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
else:
return self.contextualMenu
#============================================================================
# setCurrentSubGeom
#============================================================================
def setCurrentSubGeom(self, entSelClass):
"""
Setta la sottogeometria corrente
"""
self.currSubGeom = None
self.currAtSubGeom = None
# verifico che sia stata selezionata un'entità
if entSelClass.entity.isInitialized() == False:
self.showMsg(
QadMsg.translate("QAD", "No geometries in this position."))
return False
# verifico che sia stata selezionata attraverso un punto
# (per capire quale sottogeometria è stata selezionata)
if entSelClass.point is None: return False
self.entity.set(entSelClass.entity)
geom = self.layerToMapCoordinates(entSelClass.entity.layer,
entSelClass.entity.getGeometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(entSelClass.point, geom)
if dummy[2] is None:
return False
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
self.currSubGeom, self.currAtSubGeom = qad_utils.getSubGeomAtVertex(
geom, dummy[2])
if self.currSubGeom is None or self.currAtSubGeom is None:
self.currSubGeom = None
self.currAtSubGeom = None
return False
return True
#============================================================================
# disjoinCurrentSubGeomToPolygon
#============================================================================
def disjoinCurrentSubGeomToPolygon(self):
"""
Sconnette la sotto-geometria corrente del poligono da modificare creando una nuova entità
"""
layer = self.entity.layer
# la posizione é espressa con una lista (<index ogg. princ> [<index ogg. sec.>])
part = self.currAtSubGeom[0]
ring = self.currAtSubGeom[1] if len(self.currAtSubGeom) == 2 else None
geom = self.entity.getGeometry()
wkbType = geom.wkbType()
if wkbType == QGis.WKBMultiPoint or wkbType == QGis.WKBMultiLineString:
if geom.deletePart(part) == False: # disgrego una parte
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newGeom = self.mapToLayerCoordinates(layer, self.currSubGeom)
elif wkbType == QGis.WKBPolygon or wkbType == QGis.WKBMultiPolygon:
if ring is not None: # disgrego un'isola
if geom.deleteRing(
ring + 1, part
) == False: # cancello una isola (Ring 0 is outer ring and can't be deleted)
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newGeom = QgsGeometry.fromPolygon([
self.mapToLayerCoordinates(layer,
self.currSubGeom).asPolyline()
])
else: # disgrego una parte
if wkbType == QGis.WKBPolygon:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newGeom = QgsGeometry.fromPolygon([
self.mapToLayerCoordinates(layer,
self.currSubGeom).asPolyline()
])
ring = 0
ringGeom = qad_utils.getSubGeomAt(geom, [part, ring])
# se la parte ha delle isole
while ringGeom is not None:
# aggiungo un'isola
points = ringGeom.asPolyline() # vettore di punti
if newGeom.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD",
"Invalid object."))
return False
ring = ring + 1
ringGeom = qad_utils.getSubGeomAt(geom, [part, ring])
if geom.deletePart(part) == False: # cancello una parte
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", self.entity.layer)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f,
False, False) == False:
self.plugIn.destroyEditCommand()
return False
# Aggiungo nuova feature
newF = QgsFeature(f)
newF.setGeometry(newGeom)
if qad_layer.addFeatureToLayer(self.plugIn, self.entity.layer, newF,
None, False, False) == False:
self.plugIn.destroyEditCommand()
return False
self.plugIn.endEditCommand()
return True
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DISJOIN",
"Select object to disjoin: ")
# scarto la selezione di quote
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.deselectOnFinish = True
self.entSelClass.run(msgMapTool, msg)
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
if self.step == 0:
self.waitForEntsel(msgMapTool,
msg) # seleziona l'oggetto da disgregare
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE ENTITA' DA MODIFICARE
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.setCurrentSubGeom(self.entSelClass) == True:
if self.disjoinCurrentSubGeomToPolygon() == True:
return True
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
class QadDISJOINCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadDISJOINCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "DISJOIN")
def getEnglishName(self):
return "DISJOIN"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runDISJOINCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/disjoin.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_DISJOIN", "Disjoin existing geometries.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entity = QadEntity()
self.SSGetClass = QadSSGetClass(plugIn)
self.SSGetClass.onlyEditableLayers = False
self.SSGetClass.checkDimLayers = False # scarto le quote
self.entSelClass = None
self.currSubGeom = None
self.currAtSubGeom = None
def __del__(self):
QadCommandClass.__del__(self)
del self.SSGetClass
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getPointMapTool(drawMode)
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
else:
return self.contextualMenu
#============================================================================
# setCurrentSubGeom
#============================================================================
def setCurrentSubGeom(self, entSelClass):
"""
Setta la sottogeometria corrente
"""
self.currSubGeom = None
self.currAtSubGeom = None
# verifico che sia stata selezionata un'entità
if entSelClass.entity.isInitialized() == False:
self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
return False
# verifico che sia stata selezionata attraverso un punto
# (per capire quale sottogeometria è stata selezionata)
if entSelClass.point is None: return False
self.entity.set(entSelClass.entity)
geom = self.layerToMapCoordinates(entSelClass.entity.layer, entSelClass.entity.getGeometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(entSelClass.point, geom)
if dummy[2] is None:
return False
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
self.currSubGeom, self.currAtSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])
if self.currSubGeom is None or self.currAtSubGeom is None:
self.currSubGeom = None
self.currAtSubGeom = None
return False
return True
#============================================================================
# disjoinCurrentSubGeomToPolygon
#============================================================================
def disjoinCurrentSubGeomToPolygon(self):
"""
Sconnette la sotto-geometria corrente del poligono da modificare creando una nuova entità
"""
layer = self.entity.layer
# la posizione é espressa con una lista (<index ogg. princ> [<index ogg. sec.>])
part = self.currAtSubGeom[0]
ring = self.currAtSubGeom[1] if len(self.currAtSubGeom) == 2 else None
geom = self.entity.getGeometry()
wkbType = geom.wkbType()
if wkbType == QGis.WKBMultiPoint or wkbType == QGis.WKBMultiLineString:
if geom.deletePart(part) == False: # disgrego una parte
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newGeom = self.mapToLayerCoordinates(layer, self.currSubGeom)
elif wkbType == QGis.WKBPolygon or wkbType == QGis.WKBMultiPolygon:
if ring is not None: # disgrego un'isola
if geom.deleteRing(ring + 1, part) == False: # cancello una isola (Ring 0 is outer ring and can't be deleted)
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newGeom = QgsGeometry.fromPolygon([self.mapToLayerCoordinates(layer, self.currSubGeom).asPolyline()])
else: # disgrego una parte
if wkbType == QGis.WKBPolygon:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newGeom = QgsGeometry.fromPolygon([self.mapToLayerCoordinates(layer, self.currSubGeom).asPolyline()])
ring = 0
ringGeom = qad_utils.getSubGeomAt(geom, [part, ring])
# se la parte ha delle isole
while ringGeom is not None:
# aggiungo un'isola
points = ringGeom.asPolyline() # vettore di punti
if newGeom.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
ring = ring + 1
ringGeom = qad_utils.getSubGeomAt(geom, [part, ring])
if geom.deletePart(part) == False: # cancello una parte
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", self.entity.layer)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
# Aggiungo nuova feature
newF = QgsFeature(f)
newF.setGeometry(newGeom)
if qad_layer.addFeatureToLayer(self.plugIn, self.entity.layer, newF, None, False, False) == False:
self.plugIn.destroyEditCommand()
return False
self.plugIn.endEditCommand()
return True
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DISJOIN", "Select object to disjoin: ")
# scarto la selezione di quote
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.deselectOnFinish = True
self.entSelClass.run(msgMapTool, msg)
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
if self.step == 0:
self.waitForEntsel(msgMapTool, msg) # seleziona l'oggetto da disgregare
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE ENTITA' DA MODIFICARE
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.setCurrentSubGeom(self.entSelClass) == True:
if self.disjoinCurrentSubGeomToPolygon() == True:
return True
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
class QadSETCURRLAYERBYGRAPHCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" Instantiates a new command of the same type """
return QadSETCURRLAYERBYGRAPHCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "SETCURRLAYERBYGRAPH")
def getEnglishName(self):
return "SETCURRLAYERBYGRAPH"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"),
self.plugIn.runSETCURRLAYERBYGRAPHCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/setcurrlayerbygraph.png")
def getNote(self):
# Set the explanatory notes to the command
return QadMsg.translate(
"Command_SETCURRLAYERBYGRAPH",
"Sets a layer of a graphical object as current.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entSelClass = None
def __del__(self):
QadCommandClass.__del__(self)
if self.entSelClass is not None:
del self.entSelClass
def getPointMapTool(self, drawMode=QadGetPointDrawModeEnum.NONE):
if self.step == 0 or self.step == 1: # When you are being selected
return self.entSelClass.getPointMapTool(drawMode)
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 0 or self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
else:
return self.contextualMenu
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.entSelClass = None
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate(
"Command_SETCURRLAYERBYGRAPH",
"Select object whose layer will be the current layer: ")
self.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.entSelClass.run(msgMapTool, msg)
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 # End command
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
self.step = 1
return False # go on
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
layer = self.entSelClass.entity.layer
if self.plugIn.canvas.currentLayer() is None or \
self.plugIn.canvas.currentLayer() != layer:
self.plugIn.canvas.setCurrentLayer(layer)
self.plugIn.iface.setActiveLayer(
layer
) # Launches event to deactivate and activate plugins
self.plugIn.iface.layerTreeView().setCurrentLayer(
layer)
self.plugIn.iface.layerTreeView(
).refreshLayerSymbology(layer.id())
msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH",
"\nThe current layer is {0}.")
self.showMsg(msg.format(layer.name()))
del self.entSelClass
self.entSelClass = None
return True
else:
if self.entSelClass.canceledByUsr == True: # End command
return True
self.showMsg(
QadMsg.translate("QAD",
"No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # go on
class QadDIMARCCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadDIMARCCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "DIMARC")
def getEnglishName(self):
return "DIMARC"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runDIMARCCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/dimArc.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_DIM", "Creates an arc length dimension.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.EntSelClass = None
self.GetAngleClass = None
self.dimPt1 = QgsPoint()
self.dimPt2 = QgsPoint()
self.dimArc = None # oggetto arco da quotare
self.measure = None # misura della quota (se None viene calcolato)
self.leader = False
# leggo lo stile di quotatura corrente
dimStyleName = QadVariables.get(QadMsg.translate("Environment variables", "DIMSTYLE"))
self.dimStyle = self.plugIn.dimStyles.findDimStyle(dimStyleName)
if self.dimStyle is not None:
self.dimStyle.dimType = QadDimTypeEnum.ALIGNED
def __del__(self):
QadCommandClass.__del__(self)
if self.EntSelClass is not None:
self.EntSelClass.entity.deselectOnLayer()
del self.EntSelClass
if self.GetAngleClass is not None:
del self.GetAngleClass
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 1: # quando si é in fase di selezione entità
return self.EntSelClass.getPointMapTool(drawMode)
# quando si é in fase di richiesta rotazione
elif self.step == 6:
return self.GetAngleClass.getPointMapTool()
else:
if (self.plugIn is not None):
if self.PointMapTool is None:
self.PointMapTool = Qad_dim_maptool(self.plugIn)
return self.PointMapTool
else:
return None
#============================================================================
# addDimToLayers
#============================================================================
def addDimToLayers(self, linePosPt):
return self.dimStyle.addAlignedDimToLayers(self.plugIn, self.dimPt1, self.dimPt2, \
linePosPt, self.measure)
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.step = 1
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate("Command_DIM", "Select arc or polyline arc segment: ")
# scarto la selezione di punti
self.EntSelClass.checkPointLayer = False
self.EntSelClass.checkLineLayer = True
self.EntSelClass.checkPolygonLayer = True
self.EntSelClass.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.EntSelClass.run(msgMapTool, msg)
#============================================================================
# waitForDimensionLinePos
#============================================================================
def waitForDimensionLinePos(self):
self.step = 4
# imposto il map tool
self.getPointMapTool().dimPt2 = self.dimPt2
if self.getPointMapTool().dimPt1 is None: # in caso di selezione oggetto dimPt1 non era stato inizializzato
self.getPointMapTool().dimPt1 = self.dimPt1
self.getPointMapTool().dimCircle = self.dimCircle
self.getPointMapTool().dimStyle = self.dimStyle
self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS)
# si appresta ad attendere un punto o una parola chiave
# si appresta ad attendere un punto o una parola chiave
keyWords = QadMsg.translate("Command_DIM", "Text") + "/" + \
QadMsg.translate("Command_DIM", "Angle") + "/" + \
QadMsg.translate("Command_DIM", "Partial") + "/"
englishKeyWords = "Text" + "/" + "2POints" + "/" + "Partial" + "/"
if self.leader:
keyWords = keyWords + QadMsg.translate("Command_DIM", "Leader")
englishKeyWords = englishKeyWords + "Leader"
else:
keyWords = keyWords + QadMsg.translate("Command_DIM", "No leader")
englishKeyWords = englishKeyWords + "No leader"
keyWords += "_" + englishKeyWordsAngle
prompt = QadMsg.translate("Command_DIM", "Specify dimension location or [{0}]: ").format(keyWords)
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, \
QadInputModeEnum.NONE)
#============================================================================
# run
#============================================================================
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapRenderer().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
if self.dimStyle is None:
self.showMsg(QadMsg.translate("QAD", "\nDimension style not valid.\nVerify the value of DIMSTYLE variable.\n"))
return True # fine comando
errMsg = self.dimStyle.getInValidErrMsg()
if errMsg is not None:
self.showMsg(errMsg)
return True # fine comando
errMsg = self.dimStyle.getNotGraphEditableErrMsg()
if errMsg is not None:
self.showMsg(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA SELEZIONE ARCO DA QUOTARE
if self.step == 0: # inizio del comando
self.waitForEntsel(msgMapTool, msg)
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == 1:
if self.EntSelClass.run(msgMapTool, msg) == True:
if self.EntSelClass.entity.isInitialized():
result = getStartEndPointClosestPartWithContext(self.EntSelClass.entity, \
self.EntSelClass.point, \
self.plugIn.canvas.mapRenderer().destinationCrs())
if result is not None:
if (type(result) != list and type(result) != tuple): # se non é una lista di 2 punti
objType = result.whatIs()
if objType == "ARC": # se é arco
self.dimArc = result
return False
self.showMsg(QadMsg.translate("Command_DIM", "Select an arc."))
self.waitForEntsel(msgMapTool, msg)
else:
self.showMsg(QadMsg.translate("Command_DIM", "No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA ORIGINE SECONDA LINEA DI ESTENSIONE (da step = 1)
elif self.step == 3: # dopo aver atteso un punto o un numero reale 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
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None:
return True
if type(value) == QgsPoint: # se é stato inserito il secondo punto
self.dimPt2.set(value.x(), value.y())
self.waitForDimensionLinePos()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA POSIZIONE DELLA LINEA DI QUOTA (da step = 2 e 3)
elif self.step == 4: # dopo aver atteso un punto o un numero reale 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
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_DIM", "Text") or value == "Text":
prompt = QadMsg.translate("Command_DIM", "Enter dimension text <{0}>: ")
dist = qad_utils.getDistance(self.dimPt1, self.dimPt2)
self.waitForString(prompt.format(str(dist)), dist)
self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.ASK_FOR_TEXT)
self.step = 5
elif value == QadMsg.translate("Command_DIM", "Angle") or value == "Angle":
# si appresta ad attendere l'angolo di rotazione del testo
if self.GetAngleClass is not None:
del self.GetAngleClass
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_DIM", "Specify angle of dimension text <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.dimStyle.textForcedRot)))
self.GetAngleClass.angle = self.dimStyle.textForcedRot
self.step = 6
self.GetAngleClass.run(msgMapTool, msg)
elif type(value) == QgsPoint: # se é stato inserito il punto di posizionamento linea quota
self.dimPt1 = self.getPointMapTool().dimPt1
self.dimPt2 = self.getPointMapTool().dimPt2
self.addDimToLayers(value)
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL TESTO (da step = 4)
elif self.step == 5: # dopo aver atteso una stringa si riavvia il comando
if type(msg) == unicode:
text = msg.strip()
if len(text) > 0:
self.measure = text
self.getPointMapTool().measure = self.measure
self.waitForDimensionLinePos()
return False
class QadDIVIDECommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadDIVIDECommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "DIVIDE")
def getEnglishName(self):
return "DIVIDE"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runDIVIDECommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/divide.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate(
"Command_DIVIDE", "Creates evenly spaced punctual objects along the length or perimeter of an object."
)
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entSelClass = None
self.objectAlignment = True
self.nSegments = 1
def __del__(self):
QadCommandClass.__del__(self)
if self.entSelClass is not None:
self.entSelClass.entity.deselectOnLayer()
del self.entSelClass
# ============================================================================
# waitForEntsel
# ============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ENT
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DIVIDE", "Select object to divide: ")
# scarto la selezione di punti
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = False
self.entSelClass.run(msgMapTool, msg)
# ============================================================================
# waitForAlignmentObjs
# ============================================================================
def waitForAlignmentObjs(self):
self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT
keyWords = QadMsg.translate("QAD", "Yes") + "/" + QadMsg.translate("QAD", "No")
self.defaultValue = QadMsg.translate("QAD", "Yes")
prompt = QadMsg.translate("Command_DIVIDE", "Align with object ? [{0}] <{1}>: ").format(
keyWords, self.defaultValue
)
englishKeyWords = "Yes" + "/" + "No"
keyWords += "_" + englishKeyWords
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, QadInputTypeEnum.KEYWORDS, self.defaultValue, keyWords, QadInputModeEnum.NONE)
# ============================================================================
# waitForSegmentNumber
# ============================================================================
def waitForSegmentNumber(self):
self.step = QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER
# si appresta ad attendere un numero intero
msg = QadMsg.translate("Command_DIVIDE", "Enter the number of segments: ")
# msg, inputType, default, keyWords, valori positivi
self.waitFor(msg, QadInputTypeEnum.INT, None, "", QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
# ============================================================================
# addFeature
# ============================================================================
def addFeature(self, layer, insPt, rot):
transformedPoint = self.mapToLayerCoordinates(layer, insPt)
g = QgsGeometry.fromPoint(transformedPoint)
f = QgsFeature()
f.setGeometry(g)
# Add attribute fields to feature.
fields = layer.pendingFields()
f.setFields(fields)
# assegno i valori di default
provider = layer.dataProvider()
for field in fields.toList():
i = fields.indexFromName(field.name())
f[field.name()] = provider.defaultValue(i)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(layer)
if len(scaleFldName) > 0:
f.setAttribute(scaleFldName, 1.0)
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
if len(rotFldName) > 0:
f.setAttribute(rotFldName, qad_utils.toDegrees(rot))
return qad_layer.addFeatureToLayer(self.plugIn, layer, f)
# ============================================================================
# doDivide
# ============================================================================
def doDivide(self, dstLayer):
f = self.entSelClass.entity.getFeature()
if f is None:
return
layer = self.entSelClass.entity.layer
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
geom = self.layerToMapCoordinates(layer, f.geometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(self.entSelClass.point, geom)
if dummy[2] is None:
return False
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])
pathLinearObjectList = qad_utils.QadLinearObjectList()
geomType = subGeom.type()
pathLinearObjectList.fromPolyline(subGeom.asPolyline())
distance = pathLinearObjectList.length() / self.nSegments
self.plugIn.beginEditCommand("Feature divided", dstLayer)
i = 1
distanceFromStart = distance
while i < self.nSegments:
pt, rot = pathLinearObjectList.getPointFromStart(distanceFromStart)
if self.addFeature(dstLayer, pt, rot if self.objectAlignment else 0) == False:
self.plugIn.destroyEditCommand()
return False
i = i + 1
distanceFromStart = distanceFromStart + distance
self.plugIn.endEditCommand()
return True
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
class QadDIVIDECommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadDIVIDECommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "DIVIDE")
def getEnglishName(self):
return "DIVIDE"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"),
self.plugIn.runDIVIDECommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/divide.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate(
"Command_DIVIDE",
"Creates evenly spaced punctual objects along the length or perimeter of an object."
)
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entSelClass = None
self.objectAlignment = True
self.nSegments = 1
def __del__(self):
QadCommandClass.__del__(self)
if self.entSelClass is not None:
self.entSelClass.entity.deselectOnLayer()
del self.entSelClass
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ENT
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DIVIDE",
"Select object to divide: ")
# scarto la selezione di punti
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = False
self.entSelClass.run(msgMapTool, msg)
#============================================================================
# waitForAlignmentObjs
#============================================================================
def waitForAlignmentObjs(self):
self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT
keyWords = QadMsg.translate("QAD", "Yes") + "/" + QadMsg.translate(
"QAD", "No")
self.defaultValue = QadMsg.translate("QAD", "Yes")
prompt = QadMsg.translate("Command_DIVIDE",
"Align with object ? [{0}] <{1}>: ").format(
keyWords, self.defaultValue)
englishKeyWords = "Yes" + "/" + "No"
keyWords += "_" + englishKeyWords
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.KEYWORDS, \
self.defaultValue, \
keyWords, QadInputModeEnum.NONE)
#============================================================================
# waitForSegmentNumber
#============================================================================
def waitForSegmentNumber(self):
self.step = QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER
# si appresta ad attendere un numero intero
msg = QadMsg.translate("Command_DIVIDE",
"Enter the number of segments: ")
# msg, inputType, default, keyWords, valori positivi
self.waitFor(msg, \
QadInputTypeEnum.INT, \
None, \
"", \
QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
#============================================================================
# addFeature
#============================================================================
def addFeature(self, layer, insPt, rot):
transformedPoint = self.mapToLayerCoordinates(layer, insPt)
g = QgsGeometry.fromPoint(transformedPoint)
f = QgsFeature()
f.setGeometry(g)
# Add attribute fields to feature.
fields = layer.pendingFields()
f.setFields(fields)
# assegno i valori di default
provider = layer.dataProvider()
for field in fields.toList():
i = fields.indexFromName(field.name())
f[field.name()] = provider.defaultValue(i)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(layer)
if len(scaleFldName) > 0:
f.setAttribute(scaleFldName, 1.0)
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(layer)
if len(rotFldName) > 0:
f.setAttribute(rotFldName, qad_utils.toDegrees(rot))
return qad_layer.addFeatureToLayer(self.plugIn, layer, f)
#============================================================================
# doDivide
#============================================================================
def doDivide(self, dstLayer):
f = self.entSelClass.entity.getFeature()
if f is None:
return
layer = self.entSelClass.entity.layer
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
geom = self.layerToMapCoordinates(layer, f.geometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(self.entSelClass.point,
geom)
if dummy[2] is None:
return False
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])
pathLinearObjectList = qad_utils.QadLinearObjectList()
geomType = subGeom.type()
pathLinearObjectList.fromPolyline(subGeom.asPolyline())
distance = pathLinearObjectList.length() / self.nSegments
self.plugIn.beginEditCommand("Feature divided", dstLayer)
i = 1
distanceFromStart = distance
while i < self.nSegments:
pt, rot = pathLinearObjectList.getPointFromStart(distanceFromStart)
if self.addFeature(dstLayer, pt,
rot if self.objectAlignment else 0) == False:
self.plugIn.destroyEditCommand()
return False
i = i + 1
distanceFromStart = distanceFromStart + distance
self.plugIn.endEditCommand()
return True
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
class QadSETCURRLAYERBYGRAPHCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadSETCURRLAYERBYGRAPHCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "SETCURRLAYERBYGRAPH")
def getEnglishName(self):
return "SETCURRLAYERBYGRAPH"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runSETCURRLAYERBYGRAPHCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/setcurrlayerbygraph.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "Sets a layer of a graphical object as current.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.EntSelClass = None
def __del__(self):
QadCommandClass.__del__(self)
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 0 or self.step == 1: # quando si é in fase di selezione entità
return self.EntSelClass.getPointMapTool(drawMode)
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "Select object whose layer will be the current layer: ")
self.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.EntSelClass.run(msgMapTool, msg)
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapRenderer().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
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
self.step = 1
return False # continua
elif self.step == 1:
if self.EntSelClass.run(msgMapTool, msg) == True:
if self.EntSelClass.entity.isInitialized():
layer = self.EntSelClass.entity.layer
if self.plugIn.canvas.currentLayer() is None or \
self.plugIn.canvas.currentLayer() != layer:
self.plugIn.canvas.setCurrentLayer(layer)
self.plugIn.iface.setActiveLayer(layer) # lancia evento di deactivate e activate dei plugin
self.plugIn.iface.legendInterface().refreshLayerSymbology(layer)
msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "\nThe current layer is {0}.")
self.showMsg(msg.format(layer.name()))
del self.EntSelClass
return True
else:
self.showMsg(QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
class QadJOINCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadJOINCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "JOIN")
def getEnglishName(self):
return "JOIN"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"),
self.plugIn.runJOINCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/join.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_JOIN", "Join existing geometries.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entity = QadEntity()
self.SSGetClass = None
self.entSelClass = None
def __del__(self):
QadCommandClass.__del__(self)
if self.SSGetClass is not None: del self.SSGetClass
def getPointMapTool(self, drawMode=QadGetPointDrawModeEnum.NONE):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getPointMapTool(drawMode)
elif self.step == 2: # quando si é in fase di selezione gruppo entità
return self.SSGetClass.getPointMapTool()
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
elif self.step == 2: # quando si é in fase di selezione gruppo entità
return self.SSGetClass.getCurrentContextualMenu()()
else:
return self.contextualMenu
def reinitSSGetClass(self):
if self.SSGetClass is not None: del self.SSGetClass
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.onlyEditableLayers = True
self.SSGetClass.checkDimLayers = False # scarto le quote
geometryType = self.entity.layer.geometryType()
if geometryType == QGis.Point:
self.SSGetClass.checkPointLayer = True
self.SSGetClass.checkLineLayer = False
self.SSGetClass.checkPolygonLayer = False
elif geometryType == QGis.Line:
self.SSGetClass.checkPointLayer = False
self.SSGetClass.checkLineLayer = True
self.SSGetClass.checkPolygonLayer = True
elif geometryType == QGis.Polygon:
self.SSGetClass.checkPointLayer = False
self.SSGetClass.checkLineLayer = True
self.SSGetClass.checkPolygonLayer = True
#============================================================================
# addEntitySetToPoint
#============================================================================
def addEntitySetToPoint(self, entitySet, removeOriginals=True):
"""
Aggiunge il set di entità al punto da modificare
"""
geom = self.entity.getGeometry()
layerList = []
layerList.append(self.entity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Point:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(),
self.entity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di entity è errore
if layer.id() == self.entity.layerId(
) and featureId == self.entity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer dell'entità da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
point = simplifiedGeom.asPoint()
# aggiungo una parte
if geom.addPart([point]) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD",
"Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.entity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f,
False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn,
layerEntitySet.layer,
layerEntitySet.featureIds,
False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
return True
#============================================================================
# addEntitySetToPolyline
#============================================================================
def addEntitySetToPolyline(self, entitySet, removeOriginals=True):
"""
Aggiunge il set di entità alla polilinea da modificare
"""
geom = self.entity.getGeometry()
layerList = []
layerList.append(self.entity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Polygon and layer.geometryType(
) != QGis.Line:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(),
self.entity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di entity è errore
if layer.id() == self.entity.layerId(
) and featureId == self.entity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer dell'entità da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
# aggiungo una parte
if geom.addPart(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD",
"Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.entity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f,
False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn,
layerEntitySet.layer,
layerEntitySet.featureIds,
False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
return True
#============================================================================
# addEntitySetToPolygon
#============================================================================
def addEntitySetToPolygon(self, entitySet, removeOriginals=True):
"""
Aggiunge il set di entità al poligono da modificare
"""
geom = self.entity.getGeometry()
layerList = []
layerList.append(self.entity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Polygon and layer.geometryType(
) != QGis.Line:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(),
self.entity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di entity è errore
if layer.id() == self.entity.layerId(
) and featureId == self.entity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# se il poligono è contenuto nella geometria da aggiungere
if geomToAdd.contains(geom):
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geom)
# deve essere un poligono senza ring
if len(simplifiedGeoms) != 1 or simplifiedGeoms[0].wkbType(
) != QGis.WKBLineString:
self.showMsg(QadMsg.translate("QAD",
"Invalid object."))
return False
points = simplifiedGeoms[0].asPolyline(
) # vettore di punti
# aggiungo un'isola
if geomToAdd.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD",
"Invalid object."))
return False
del geom
geom = QgsGeometry.fromPolygon(geomToAdd.asPolygon())
else: # se il poligono non è contenuto nella geometria da aggiungere
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline(
) # vettore di punti
# se la geometria da aggiungere è contenuta nel poligono
if geom.contains(QgsGeometry.fromPolyline(points)):
# aggiungo un'isola
if geom.addRing(
points) != 0: # 0 in case of success
self.showMsg(
QadMsg.translate("QAD", "Invalid object."))
return False
else:
# aggiungo una parte
if geom.addPart(
points) != 0: # 0 in case of success
self.showMsg(
QadMsg.translate("QAD", "Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.entity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f,
False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn,
layerEntitySet.layer,
layerEntitySet.featureIds,
False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
return True
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_JOIN",
"Select object to join to: ")
# scarto la selezione di quote
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.deselectOnFinish = True
self.entSelClass.run(msgMapTool, msg)
#============================================================================
# waitForSSsel
#============================================================================
def waitForSSsel(self, msgMapTool, msg):
self.reinitSSGetClass()
self.step = 2
self.showMsg(
QadMsg.translate("Command_JOIN", "\nSelect objects to join: "))
self.SSGetClass.run(msgMapTool, msg)
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
if self.step == 0:
self.waitForEntsel(msgMapTool,
msg) # seleziona l'oggetto a cui aggregarsi
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE ENTITA' DA MODIFICARE
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
self.entity.set(self.entSelClass.entity)
self.waitForSSsel(msgMapTool, msg)
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 DEL GRUPPO DI SELEZIONE (da step = 1)
elif self.step == 2:
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
geometryType = self.entity.layer.geometryType()
if geometryType == QGis.Point:
self.addEntitySetToPoint(self.SSGetClass.entitySet)
elif geometryType == QGis.Line:
self.addEntitySetToPolyline(self.SSGetClass.entitySet)
elif geometryType == QGis.Polygon:
self.addEntitySetToPolygon(self.SSGetClass.entitySet)
return True
self.waitForSSsel(msgMapTool, msg)
return False
class QadJOINCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadJOINCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "JOIN")
def getEnglishName(self):
return "JOIN"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runJOINCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/join.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_JOIN", "Join existing geometries.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entity = QadEntity()
self.SSGetClass = None
self.entSelClass = None
def __del__(self):
QadCommandClass.__del__(self)
if self.SSGetClass is not None: del self.SSGetClass
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getPointMapTool(drawMode)
elif self.step == 2: # quando si é in fase di selezione gruppo entità
return self.SSGetClass.getPointMapTool()
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 1: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
elif self.step == 2: # quando si é in fase di selezione gruppo entità
return self.SSGetClass.getCurrentContextualMenu()()
else:
return self.contextualMenu
def reinitSSGetClass(self):
if self.SSGetClass is not None: del self.SSGetClass
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.onlyEditableLayers = True
self.SSGetClass.checkDimLayers = False # scarto le quote
geometryType = self.entity.layer.geometryType()
if geometryType == QGis.Point:
self.SSGetClass.checkPointLayer = True
self.SSGetClass.checkLineLayer = False
self.SSGetClass.checkPolygonLayer = False
elif geometryType == QGis.Line:
self.SSGetClass.checkPointLayer = False
self.SSGetClass.checkLineLayer = True
self.SSGetClass.checkPolygonLayer = True
elif geometryType == QGis.Polygon:
self.SSGetClass.checkPointLayer = False
self.SSGetClass.checkLineLayer = True
self.SSGetClass.checkPolygonLayer = True
#============================================================================
# addEntitySetToPoint
#============================================================================
def addEntitySetToPoint(self, entitySet, removeOriginals = True):
"""
Aggiunge il set di entità al punto da modificare
"""
geom = self.entity.getGeometry()
layerList = []
layerList.append(self.entity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Point:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(), self.entity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di entity è errore
if layer.id() == self.entity.layerId() and featureId == self.entity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer dell'entità da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
point = simplifiedGeom.asPoint()
# aggiungo una parte
if geom.addPart([point]) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.entity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
return True
#============================================================================
# addEntitySetToPolyline
#============================================================================
def addEntitySetToPolyline(self, entitySet, removeOriginals = True):
"""
Aggiunge il set di entità alla polilinea da modificare
"""
geom = self.entity.getGeometry()
layerList = []
layerList.append(self.entity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Polygon and layer.geometryType() != QGis.Line:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(), self.entity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di entity è errore
if layer.id() == self.entity.layerId() and featureId == self.entity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer dell'entità da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
# aggiungo una parte
if geom.addPart(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.entity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
return True
#============================================================================
# addEntitySetToPolygon
#============================================================================
def addEntitySetToPolygon(self, entitySet, removeOriginals = True):
"""
Aggiunge il set di entità al poligono da modificare
"""
geom = self.entity.getGeometry()
layerList = []
layerList.append(self.entity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Polygon and layer.geometryType() != QGis.Line:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(), self.entity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di entity è errore
if layer.id() == self.entity.layerId() and featureId == self.entity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# se il poligono è contenuto nella geometria da aggiungere
if geomToAdd.contains(geom):
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geom)
# deve essere un poligono senza ring
if len(simplifiedGeoms) != 1 or simplifiedGeoms[0].wkbType() != QGis.WKBLineString:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
points = simplifiedGeoms[0].asPolyline() # vettore di punti
# aggiungo un'isola
if geomToAdd.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
del geom
geom = QgsGeometry.fromPolygon(geomToAdd.asPolygon())
else: # se il poligono non è contenuto nella geometria da aggiungere
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
# se la geometria da aggiungere è contenuta nel poligono
if geom.contains(QgsGeometry.fromPolyline(points)):
# aggiungo un'isola
if geom.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
# aggiungo una parte
if geom.addPart(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.entity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
return True
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_JOIN", "Select object to join to: ")
# scarto la selezione di quote
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.deselectOnFinish = True
self.entSelClass.run(msgMapTool, msg)
#============================================================================
# waitForSSsel
#============================================================================
def waitForSSsel(self, msgMapTool, msg):
self.reinitSSGetClass()
self.step = 2
self.showMsg(QadMsg.translate("Command_JOIN", "\nSelect objects to join: "))
self.SSGetClass.run(msgMapTool, msg)
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
if self.step == 0:
self.waitForEntsel(msgMapTool, msg) # seleziona l'oggetto a cui aggregarsi
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE ENTITA' DA MODIFICARE
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
self.entity.set(self.entSelClass.entity)
self.waitForSSsel(msgMapTool, msg)
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 DEL GRUPPO DI SELEZIONE (da step = 1)
elif self.step == 2:
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
geometryType = self.entity.layer.geometryType()
if geometryType == QGis.Point:
self.addEntitySetToPoint(self.SSGetClass.entitySet)
elif geometryType == QGis.Line:
self.addEntitySetToPolyline(self.SSGetClass.entitySet)
elif geometryType == QGis.Polygon:
self.addEntitySetToPolygon(self.SSGetClass.entitySet)
return True
self.waitForSSsel(msgMapTool, msg)
return False
class QadDIMLINEARCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadDIMLINEARCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "DIMLINEARE")
def getEnglishName(self):
return "DIMLINEAR"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runDIMLINEARCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/dimLinear.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_DIM", "Crea una quota lineare orizzontale o verticale.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.EntSelClass = None
self.GetAngleClass = None
self.dimPt1 = QgsPoint() # primo punto di quotatura esplicito
self.dimPt2 = QgsPoint() # secondo punto di quotatura esplicito
self.dimCircle = None # oggetto cerchio da quotare
self.measure = None # misura della quota (se None viene calcolato)
self.preferredAlignment = QadDimStyleAlignmentEnum.HORIZONTAL # allineamento della linea di quota
# leggo lo stile di quotatura corrente
dimStyleName = QadVariables.get(QadMsg.translate("Environment variables", "DIMSTYLE"))
self.forcedDimLineAlignment = None # allineamento della linea di quota forzato
self.forcedDimLineRot = 0.0 # rotazione della linea di quota forzato
_dimStyle = self.plugIn.dimStyles.findDimStyle(dimStyleName)
if _dimStyle is not None:
self.dimStyle = QadDimStyle(_dimStyle) # ne faccio una copia perché può venire modificato dal comando
self.dimStyle.dimType = QadDimTypeEnum.LINEAR
else:
self.dimStyle = None
def __del__(self):
QadCommandClass.__del__(self)
if self.EntSelClass is not None:
self.EntSelClass.entity.deselectOnLayer()
del self.EntSelClass
if self.GetAngleClass is not None:
del self.GetAngleClass
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 2: # quando si é in fase di selezione entità
return self.EntSelClass.getPointMapTool(drawMode)
# quando si é in fase di richiesta rotazione
elif self.step == 6 or self.step == 7:
return self.GetAngleClass.getPointMapTool()
else:
if (self.plugIn is not None):
if self.PointMapTool is None:
self.PointMapTool = Qad_dim_maptool(self.plugIn)
return self.PointMapTool
else:
return None
#============================================================================
# addDimToLayers
#============================================================================
def addDimToLayers(self, linePosPt):
return self.dimStyle.addLinearDimToLayers(self.plugIn, self.dimPt1, self.dimPt2, \
linePosPt, self.measure, self.preferredAlignment, \
self.forcedDimLineRot)
#============================================================================
# waitForFirstPt
#============================================================================
def waitForFirstPt(self):
self.step = 1
# imposto il map tool
self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)
msg = QadMsg.translate("Command_DIM", "Specificare l'origine della prima linea di estensione o <seleziona oggetto>: ")
# si appresta ad attendere un punto o enter
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg, \
QadInputTypeEnum.POINT2D, \
None, \
"", QadInputModeEnum.NONE)
#============================================================================
# waitForSecondPt
#============================================================================
def waitForSecondPt(self):
self.step = 3
# imposto il map tool
self.getPointMapTool().dimPt1 = self.dimPt1
self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_DIM", "Specificare l'origine della seconda linea di estensione: "))
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.EntSelClass is not None:
del self.EntSelClass
self.step = 2
self.EntSelClass = QadEntSelClass(self.plugIn)
self.EntSelClass.msg = QadMsg.translate("Command_DIM", "Selezionare l'oggetto da quotare: ")
# scarto la selezione di punti
self.EntSelClass.checkPointLayer = False
self.EntSelClass.checkLineLayer = True
self.EntSelClass.checkPolygonLayer = True
self.EntSelClass.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
self.EntSelClass.run(msgMapTool, msg)
#============================================================================
# waitForDimensionLinePos
#============================================================================
def waitForDimensionLinePos(self):
self.step = 4
# imposto il map tool
self.getPointMapTool().dimPt2 = self.dimPt2
if self.getPointMapTool().dimPt1 is None: # in caso di selezione oggetto dimPt1 non era stato inizializzato
self.getPointMapTool().dimPt1 = self.dimPt1
self.getPointMapTool().dimCircle = self.dimCircle
self.getPointMapTool().preferredAlignment = self.preferredAlignment
self.getPointMapTool().forcedDimLineAlignment = self.forcedDimLineAlignment
self.getPointMapTool().forcedDimLineRot = self.forcedDimLineRot
self.getPointMapTool().dimStyle = self.dimStyle
self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS)
# si appresta ad attendere un punto o una parola chiave
keyWords = QadMsg.translate("Command_DIM", "Testo") + "/" + \
QadMsg.translate("Command_DIM", "Angolo") + "/" + \
QadMsg.translate("Command_DIM", "Orizzontale") + "/" + \
QadMsg.translate("Command_DIM", "Verticale") + "/" + \
QadMsg.translate("Command_DIM", "Ruotato")
prompt = QadMsg.translate("Command_DIM", "Specificare la posizione della linea di quota o [{0}]: ").format(keyWords)
englishKeyWords = "Text" + "/" + "Angle" + "/" + "Horizontal" + "/" + "Vertical" + "/" + "Rotated"
keyWords += "_" + englishKeyWords
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, \
QadInputModeEnum.NONE)
#============================================================================
# run
#============================================================================
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
if self.dimStyle is None:
self.showMsg(QadMsg.translate("QAD", "\nStile di quotatura corrente non valido.\nVerificare il valore della variabile DIMSTYLE.\n"))
return True # fine comando
errMsg = self.dimStyle.getInValidErrMsg()
if errMsg is not None:
self.showMsg(errMsg)
return True # fine comando
errMsg = self.dimStyle.getNotGraphEditableErrMsg()
if errMsg is not None:
self.showMsg(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA SELEZIONE ORIGINE PRIMA LINEA DI ESTENSIONE
if self.step == 0: # inizio del comando
self.waitForFirstPt()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ORIGINE PRIMA LINEA DI ESTENSIONE (da step = 0)
elif self.step == 1:
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
value = None # opzione di default None
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None:
self.waitForEntsel(msgMapTool, msg)
else:
self.dimPt1.set(value.x(), value.y())
self.waitForSecondPt()
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 1)
elif self.step == 2:
if self.EntSelClass.run(msgMapTool, msg) == True:
if self.EntSelClass.entity.isInitialized():
result = getStartEndPointClosestPartWithContext(self.EntSelClass.entity, \
self.EntSelClass.point, \
self.plugIn.canvas.mapRenderer().destinationCrs())
if result is not None:
if (type(result) == list or type(result) == tuple): # se é una lista di 2 punti
self.dimPt1 = result[0]
self.dimPt2 = result[1]
else:
objType = result.whatIs()
if objType == "ARC": # se é arco
self.dimPt1 = result.getStartPt()
self.dimPt2 = result.getEndPt()
elif objType == "CIRCLE": # se é cerchio
self.dimCircle = result
self.waitForDimensionLinePos()
return False
else:
self.showMsg(QadMsg.translate("Command_DIM", "Non ci sono geometrie in questa posizione."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA ORIGINE SECONDA LINEA DI ESTENSIONE (da step = 1)
elif self.step == 3: # dopo aver atteso un punto o un numero reale 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
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None:
return True
if type(value) == QgsPoint: # se é stato inserito il secondo punto
self.dimPt2.set(value.x(), value.y())
self.waitForDimensionLinePos()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA POSIZIONE DELLA LINEA DI QUOTA (da step = 2 e 3)
elif self.step == 4: # dopo aver atteso un punto o un numero reale 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
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_DIM", "Testo") or value == "Text":
prompt = QadMsg.translate("Command_DIM", "Digitare il testo di quota <{0}>: ")
dist = qad_utils.getDistance(self.dimPt1, self.dimPt2)
self.waitForString(prompt.format(str(dist)), dist)
self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.ASK_FOR_TEXT)
self.step = 5
elif value == QadMsg.translate("Command_DIM", "Angolo") or value == "Angle":
# si appresta ad attendere l'angolo di rotazione del testo
if self.GetAngleClass is not None:
del self.GetAngleClass
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_DIM", "Specificare l'angolo del testo di quota <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.dimStyle.textForcedRot)))
self.GetAngleClass.angle = self.dimStyle.textForcedRot
self.step = 6
self.GetAngleClass.run(msgMapTool, msg)
elif value == QadMsg.translate("Command_DIM", "Orizzontale") or value == "Horizontal":
# allineamento della linea di quota orizzontale
self.forcedDimLineAlignment = QadDimStyleAlignmentEnum.HORIZONTAL # allineamento della linea di quota forzato
self.forcedDimLineRot = 0.0
self.waitForDimensionLinePos()
elif value == QadMsg.translate("Command_DIM", "Verticale") or value == "Vertical":
# allineamento della linea di quota verticale
self.forcedDimLineAlignment = QadDimStyleAlignmentEnum.VERTICAL # allineamento della linea di quota forzato
self.forcedDimLineRot = 0.0
self.waitForDimensionLinePos()
elif value == QadMsg.translate("Command_DIM", "Ruotato") or value == "Rotated":
# si appresta ad attendere l'angolo di rotazionedella linea di quotatura
if self.GetAngleClass is not None:
del self.GetAngleClass
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_DIM", "Specificare l'angolo della linea di quota <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.forcedDimLineRot)))
self.GetAngleClass.angle = self.forcedDimLineRot
self.step = 7
self.GetAngleClass.run(msgMapTool, msg)
pass
elif type(value) == QgsPoint: # se é stato inserito il punto di posizionamento linea quota
self.preferredAlignment = self.getPointMapTool().preferredAlignment
self.dimPt1 = self.getPointMapTool().dimPt1
self.dimPt2 = self.getPointMapTool().dimPt2
self.addDimToLayers(value)
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL TESTO (da step = 4)
elif self.step == 5: # dopo aver atteso una stringa si riavvia il comando
if type(msg) == unicode:
text = msg.strip()
if len(text) > 0:
self.measure = text
self.getPointMapTool().measure = self.measure
self.waitForDimensionLinePos()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE DEL TESTO DI QUOTA (da step = 4)
elif self.step == 6:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.dimStyle.textRotMode = QadDimStyleTxtRotModeEnum.FORCED_ROTATION
self.dimStyle.textForcedRot = self.GetAngleClass.angle
self.waitForDimensionLinePos()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE DELLA LINEA DI QUOTA (da step = 4)
elif self.step == 7:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.forcedDimLineRot = self.GetAngleClass.angle
self.waitForDimensionLinePos()
return False
class QadMAPMPEDITCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadMAPMPEDITCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "MAPMPEDIT")
def getEnglishName(self):
return "MAPMPEDIT"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runMAPMPEDITCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/mapmpedit.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_MAPMPEDIT", "Modifies existing polygon.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.poligonEntity = QadEntity()
self.SSGetClass = QadSSGetClass(plugIn)
self.SSGetClass.onlyEditableLayers = False
self.SSGetClass.checkDimLayers = False # scarto le quote
self.entSelClass = None
self.currSubGeom = None
self.currAtSubGeom = None
self.nOperationsToUndo = 0
def __del__(self):
QadCommandClass.__del__(self)
del self.SSGetClass
self.poligonEntity.deselectOnLayer()
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 1 or self.step == 4: # quando si é in fase di selezione entità
return self.entSelClass.getPointMapTool(drawMode)
elif self.step == 3 or self.step == 5 or \
self.step == 6 or self.step == 7 or self.step == 8: # quando si é in fase di selezione gruppo entità
return self.SSGetClass.getPointMapTool()
else:
return QadCommandClass.getPointMapTool(self, drawMode)
def getCurrentContextualMenu(self):
if self.step == 1 or self.step == 4: # quando si é in fase di selezione entità
return self.entSelClass.getCurrentContextualMenu()
elif self.step == 3 or self.step == 5 or \
self.step == 6 or self.step == 7 or self.step == 8: # quando si é in fase di selezione gruppo entità
return self.SSGetClass.getCurrentContextualMenu()
else:
return self.contextualMenu
def reinitSSGetClass(self):
checkPointLayer = self.SSGetClass.checkPointLayer
del self.SSGetClass
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.onlyEditableLayers = False
self.SSGetClass.checkDimLayers = False # scarto le quote
self.SSGetClass.checkPointLayer = checkPointLayer
#============================================================================
# setCurrentSubGeom
#============================================================================
def setCurrentSubGeom(self, entSelClass):
"""
Setta la sottogeometria corrente
"""
self.currSubGeom = None
self.currAtSubGeom = None
# verifico che sia stata selezionata un'entità
if entSelClass.entity.isInitialized() == False:
self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
return False
# verifico che sia stata selezionata attraverso un punto
# (per capire quale sottogeometria è stata selezionata)
if entSelClass.point is None: return False
# verifico che sia stato selezionato lo stesso polygono che è da modificare
if self.poligonEntity != entSelClass.entity:
self.showMsg(QadMsg.translate("Command_MAPMPEDIT", "The boundary doesn't belong to the selected polygon."))
return False
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
geom = self.layerToMapCoordinates(entSelClass.entity.layer, entSelClass.entity.getGeometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(entSelClass.point, geom)
if dummy[2] is None:
return False
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
self.currSubGeom, self.currAtSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])
if self.currSubGeom is None or self.currAtSubGeom is None:
self.currSubGeom = None
self.currAtSubGeom = None
return False
return True
#============================================================================
# addEntitySetToPolygon
#============================================================================
def addEntitySetToPolygon(self, entitySet, removeOriginals = False):
"""
Aggiunge il set di entità al poligono da modificare
"""
geom = self.poligonEntity.getGeometry()
layerList = []
layerList.append(self.poligonEntity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Polygon and layer.geometryType() != QGis.Line:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(), self.poligonEntity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di polygonEntity è errore
if layer.id() == self.poligonEntity.layerId() and featureId == self.poligonEntity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# se il poligono è contenuto nella geometria da aggiungere
if geomToAdd.contains(geom):
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geom)
# deve essere un poligono senza ring
if len(simplifiedGeoms) != 1 or simplifiedGeoms[0].wkbType() != QGis.WKBLineString:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
points = simplifiedGeoms[0].asPolyline() # vettore di punti
# aggiungo un'isola
if geomToAdd.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
del geom
geom = QgsGeometry.fromPolygon(geomToAdd.asPolygon())
else: # se il poligono non è contenuto nella geometria da aggiungere
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
# se la geometria da aggiungere è contenuta nel poligono
if geom.contains(QgsGeometry.fromPolyline(points)):
# aggiungo un'isola
if geom.addRing(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
# aggiungo una parte
if geom.addPart(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.poligonEntity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# delCurrentSubGeomToPolygon
#============================================================================
def delCurrentSubGeomToPolygon(self):
"""
Cancella la sotto-geometria corrente dal poligono da modificare
"""
geom = self.poligonEntity.getGeometry()
# la posizione é espressa con una lista (<index ogg. princ> [<index ogg. sec.>])
part = self.currAtSubGeom[0]
if len(self.currAtSubGeom) == 2:
ring = self.currAtSubGeom[1]
if geom.deleteRing(ring + 1, part) == False: # cancello una isola (Ring 0 is outer ring and can't be deleted)
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
if geom.deletePart(part) == False: # cancello una parte
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", self.poligonEntity.layer)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
#============================================================================
# unionIntersSubtractEntitySetToPolygon
#============================================================================
def unionIntersSubtractEntitySetToPolygon(self, entitySet, opType, removeOriginals = False):
"""
Unisce o interseca i poligoni di entitySet al poligono corrente
"""
geom = self.poligonEntity.getGeometry()
layerList = []
layerList.append(self.poligonEntity.layer)
geomList = []
geomList.append(geom)
for layerEntitySet in entitySet.layerEntitySetList:
del geomList[:]
layer = layerEntitySet.layer
coordTransform = QgsCoordinateTransform(layer.crs(), self.poligonEntity.layer.crs())
if layer.geometryType() == QGis.Polygon:
for featureId in layerEntitySet.featureIds:
# se la feature è quella di polygonEntity è errore
if layer.id() == self.poligonEntity.layerId() and featureId == self.poligonEntity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
if opType == QadMAPMPEDITCommandOpTypeEnum.UNION: geom = geom.combine(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.INTERSECTION: geom = geom.intersection(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.DIFFERENCE: geom = geom.difference(geomToAdd)
if geom is None:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals and layer.id() != self.poligonEntity.layerId():
layerList.append(layer)
elif layer.geometryType() == QGis.Line:
for featureId in layerEntitySet.featureIds:
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
if simplifiedGeom.wkbType() != QGis.WKBLineString:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
points = simplifiedGeom.asPolyline() # vettore di punti
if len(points) < 4 or points[0] != points[-1]: # polilinea chiusa con almeno 4 punti (primo e ultimo uguali)
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
geomToAdd = QgsGeometry.fromPolygon([points])
if opType == QadMAPMPEDITCommandOpTypeEnum.UNION: geom = geom.combine(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.INTERSECTION: geom = geom.intersection(geomToAdd)
elif opType == QadMAPMPEDITCommandOpTypeEnum.DIFFERENCE: geom = geom.difference(geomToAdd)
if geom is None or geom.type() != QGis.Polygon:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
else:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# convexHullEntitySetToPolygon
#============================================================================
def convexHullEntitySetToPolygon(self, entitySet, removeOriginals = False):
"""
modifica il poligono corrente in modo che includa tutti i punti delle geometrie di entitySet
"""
layerList = []
layerList.append(self.poligonEntity.layer)
pointsForConvexHull = []
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
coordTransform = QgsCoordinateTransform(layer.crs(), self.poligonEntity.layer.crs())
for featureId in layerEntitySet.featureIds:
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer del poligono da modificare
geom = f.geometry()
geom.transform(coordTransform)
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geom)
for simplifiedGeom in simplifiedGeoms:
if simplifiedGeom.wkbType() == QGis.WKBLineString:
pointsForConvexHull.extend(simplifiedGeom.asPolyline())
else:
pointsForConvexHull.append(simplifiedGeom.asPoint())
if removeOriginals and layer.id() != self.poligonEntity.layerId():
layerList.append(layer)
geom = QgsGeometry.fromMultiPoint(pointsForConvexHull)
geom = geom.convexHull()
if geom is None:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# dividePolygon
#============================================================================
def splitPolygon(self, splitLine, createNewEntities):
"""
divide il poligono corrente usando una polilinea con i vertci in <plineVertices> in modo da generare o meno nuove entità
"""
layerList = []
layerList.append(self.poligonEntity.layer)
splitLineTransformed = self.mapToLayerCoordinates(self.poligonEntity.layer, splitLine)
f = self.poligonEntity.getFeature()
geom = f.geometry()
result, newGeoms, topologyTestPts = geom.splitGeometry(splitLineTransformed, False)
if result <> 0 or len(newGeoms) == 0:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
newfeatures =[]
if createNewEntities:
for newGeom in newGeoms:
newfeature = QgsFeature(f)
newfeature.setGeometry(newGeom)
newfeatures.append(newfeature)
else:
for newGeom in newGeoms:
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(newGeom)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
res = geom.addPart(points)
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if len(newfeatures) > 0:
# plugIn, layer, features, coordTransform, refresh, check_validity
if qad_layer.addFeaturesToLayer(self.plugIn, self.poligonEntity.layer, newfeatures, None, False, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
return True
#============================================================================
# waitForEntsel
#============================================================================
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select polygon: ")
# scarto la selezione di punti e polilinee
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = False
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
#============================================================================
# WaitForMainMenu
#============================================================================
def WaitForMainMenu(self):
self.poligonEntity.selectOnLayer(False)
keyWords = QadMsg.translate("Command_MAPMPEDIT", "Add") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Delete") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Union") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Substract") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Intersect") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "split Objects") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "split Parts") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "iNclude objs")
englishKeyWords = "Add" + "/" + "Delete" + "/" + "Union" + "/" + "Substract" + "/" + "Intersect" "/" + \
"split Objects" + "/" + "split Parts" + "/" + "iNclude objs"
if self.nOperationsToUndo > 0: # se c'è qualcosa che si può annullare
keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT", "Undo")
englishKeyWords = englishKeyWords + "/" + "Undo"
keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT", "eXit")
englishKeyWords = englishKeyWords + "/" + "eXit"
default = QadMsg.translate("Command_MAPMPEDIT", "eXit")
prompt = QadMsg.translate("Command_MAPMPEDIT", "Enter an option [{0}] <{1}>: ").format(keyWords, default)
self.step = 2
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.NONE)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
keyWords += "_" + englishKeyWords
# si appresta ad attendere enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
return False
#============================================================================
# waitForBoundary
#============================================================================
def waitForBoundary(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select boundary: ")
# scarto la selezione di punti e polilinee
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = False
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
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
if self.step == 0:
self.waitForEntsel(msgMapTool, msg) # seleziona il poligono da modificare
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE POLIGONO DA MODIFICARE
elif self.step == 1:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
self.poligonEntity.set(self.entSelClass.entity.layer, self.entSelClass.entity.featureId)
layer = self.entSelClass.entity.layer
self.poligonEntity.deselectOnLayer()
self.WaitForMainMenu()
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 DEL MENU PRINCIPALE
elif self.step == 2: # dopo aver atteso una opzione 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
self.WaitForMainMenu()
return False
else: # l'opzione arriva come parametro della funzione
value = msg
self.poligonEntity.deselectOnLayer()
if value == QadMsg.translate("Command_MAPMPEDIT", "Add") or value == "Add":
self.SSGetClass.checkPointLayer = False # scarto i punto
self.SSGetClass.run(msgMapTool, msg)
self.step = 3
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Delete") or value == "Delete":
self.waitForBoundary(msgMapTool, msg)
self.step = 4
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Union") or value == "Union":
self.SSGetClass.checkPointLayer = False # scarto i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 5
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Substract") or value == "Substract":
self.SSGetClass.checkPointLayer = False # scarto i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 6
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Intersect") or value == "Intersect":
self.SSGetClass.checkPointLayer = False # scarto i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 7
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "split Objects") or value == "split Objects":
# Disegna una polilinea di divisione del poligono
self.PLINECommand = QadPLINECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare una linea
# che non verrà salvata su un layer
self.PLINECommand.virtualCmd = True
self.PLINECommand.run(msgMapTool, msg)
self.step = 9
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "split Parts") or value == "split Parts":
# Disegna una polilinea di divisione del poligono
self.PLINECommand = QadPLINECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare una linea
# che non verrà salvata su un layer
self.PLINECommand.virtualCmd = True
self.PLINECommand.run(msgMapTool, msg)
self.step = 10
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "iNclude objs") or value == "iNclude objs":
self.SSGetClass.checkPointLayer = True # includo i layer puntuali
self.SSGetClass.run(msgMapTool, msg)
self.step = 8
return False
elif value == QadMsg.translate("Command_MAPMPEDIT", "Undo") or value == "Undo":
if self.nOperationsToUndo > 0:
self.nOperationsToUndo = self.nOperationsToUndo - 1
self.plugIn.undoEditCommand()
else:
self.showMsg(QadMsg.translate("QAD", "\nThe command has been canceled."))
elif value == QadMsg.translate("Command_MAPMPEDIT", "eXit") or value == "eXit":
return True # fine comando
else:
return True # fine comando
self.WaitForMainMenu()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI ADD (da step = 2)
elif self.step == 3:
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.addEntitySetToPolygon(self.SSGetClass.entitySet)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI DELETE (da step = 2)
elif self.step == 4:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.setCurrentSubGeom(self.entSelClass) == True:
self.delCurrentSubGeomToPolygon()
self.WaitForMainMenu()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine selezione entità
self.WaitForMainMenu()
else:
self.waitForBoundary(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI UNION (da step = 2)
elif self.step == 5: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.unionIntersSubtractEntitySetToPolygon(self.SSGetClass.entitySet, QadMAPMPEDITCommandOpTypeEnum.UNION)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI SUBTRACT (da step = 2)
elif self.step == 6: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.unionIntersSubtractEntitySetToPolygon(self.SSGetClass.entitySet, QadMAPMPEDITCommandOpTypeEnum.DIFFERENCE)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI INTERSECT (da step = 2)
elif self.step == 7: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.unionIntersSubtractEntitySetToPolygon(self.SSGetClass.entitySet, QadMAPMPEDITCommandOpTypeEnum.INTERSECTION)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' DI INCLUDE OBJS (da step = 2)
elif self.step == 8: # dopo aver atteso una entità si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
if self.SSGetClass.entitySet.count() > 0:
self.convexHullEntitySetToPolygon(self.SSGetClass.entitySet)
self.reinitSSGetClass()
self.WaitForMainMenu()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA LINEA DI DIVISIONE (da step = 2)
elif self.step == 9: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.splitPolygon(self.PLINECommand.vertices, True)
del self.PLINECommand
self.PLINECommand = None
self.WaitForMainMenu()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA LINEA DI DIVISIONE (da step = 2)
elif self.step == 10: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.splitPolygon(self.PLINECommand.vertices, False)
del self.PLINECommand
self.PLINECommand = None
self.WaitForMainMenu()
return False
