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
#=========================================================================
# RICHIESTA SELEZIONE OGGETTI
if self.step == 0: # inizio del comando
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE OGGETTI DA STIRARE
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
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 type(value) == unicode:
if value == QadMsg.translate("Command_STRETCH", "Polygon") or value == "Polygon":
# Seleziona tutti gli oggetti che sono interni al poligono
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 2
return False
elif value == QadMsg.translate("Command_SSGET", "Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
elif value == QadMsg.translate("Command_SSGET", "Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
elif type(value) == QgsPoint: # se é stato selezionato un punto
del self.points[:] # svuoto la lista
self.points.append(value)
# imposto il map tool
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_STRETCH", "Specify opposite corner: "))
self.step = 3
return False
else:
if self.SSGeomListIsEmpty():
return True
# si appresta ad attendere il punto base o lo spostamento
self.waitForBasePt()
return False
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' POLIGONO (da step = 1)
elif self.step == 2: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
if len(self.MPOLYGONCommand.vertices) > 1:
# cerco tutte le geometrie intersecanti il poligono
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("CP", self.getPointMapTool(), self.MPOLYGONCommand.vertices, \
None, True, True, True, \
True)
# se la selezione é avvenuta con shift premuto o se si deve rimuovere il gruppo selSet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
self.setEntitySetGeom(selSet, QgsGeometry.fromPolygon([self.MPOLYGONCommand.vertices]))
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di mpolygon
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' FINESTRA (da step = 1)
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
self.showMsg(QadMsg.translate("Command_STRETCH", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_STRETCH", "Specify opposite corner: "))
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.points.append(value)
# cerco tutte le geometrie intersecanti il rettangolo
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("C", self.getPointMapTool(), self.points, \
None, True, True, True, \
True)
# se si deve rimuovere il gruppo entitySet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
if shiftKey: # se la selezione é avvenuta con shift premuto
self.addEntitySetGeom(selSet, QgsGeometry.fromRect(QgsRectangle(self.points[0], self.points[1])))
else:
self.setEntitySetGeom(selSet, QgsGeometry.fromRect(QgsRectangle(self.points[0], self.points[1])))
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO BASE (da step = 1)
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
pass # opzione di default "spostamento"
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
# imposto il map tool
self.getPointMapTool().SSGeomList = self.SSGeomList
if value is None or type(value) == unicode:
self.basePt.set(0, 0)
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto
msg = QadMsg.translate("Command_STRETCH", "Specify the displacement from the origin point 0,0 <{0}, {1}>: ")
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg.format(str(self.plugIn.lastOffsetPt.x()), str(self.plugIn.lastOffsetPt.y())), \
QadInputTypeEnum.POINT2D, \
self.plugIn.lastOffsetPt, \
"", QadInputModeEnum.NONE)
self.step = 5
elif type(value) == QgsPoint: # se é stato inserito il punto base
self.basePt.set(value.x(), value.y())
# imposto il map tool
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_STRETCH", "Specify second point or [Array] <use first point as displacement from origin point 0,0>: "), \
QadInputTypeEnum.POINT2D, \
None, \
"", QadInputModeEnum.NONE)
self.step = 6
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PUNTO DI SPOSTAMENTO (da step = 2)
elif self.step == 5: # 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
self.plugIn.setLastOffsetPt(value)
self.stretchFeatures(value)
return True # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER SPOSTAMENTO (da step = 2)
elif self.step == 6: # 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 value is None:
newPt = QgsPoint(self.basePt.x() * 2, self.basePt.y() * 2)
self.stretchFeatures(newPt)
elif type(value) == QgsPoint: # se é stato inserito lo spostamento con un punto
self.stretchFeatures(value)
return True # fine comando
class QadSTRETCHCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadSTRETCHCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "STRETCH")
def getEnglishName(self):
return "STRETCH"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runSTRETCHCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/stretch.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_STRETCH", "Stretches objects.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.AddOnSelection = True # se = False significa remove
self.points = []
self.MPOLYGONCommand = None
self.SSGeomList = [] # lista di entità da stirare con geom di selezione
self.basePt = QgsPoint()
def __del__(self):
QadCommandClass.__del__(self)
if self.MPOLYGONCommand is not None:
del self.MPOLYGONCommand
for SSGeom in self.SSGeomList:
SSGeom[0].deselectOnLayer()
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 2: # quando si é in fase di disegno linea
return self.MPOLYGONCommand.getPointMapTool(drawMode)
else:
if (self.plugIn is not None):
if self.PointMapTool is None:
self.PointMapTool = Qad_stretch_maptool(self.plugIn)
return self.PointMapTool
else:
return None
def stretch(self, entity, containerGeom, offSetX, offSetY, tolerance2ApproxCurve):
# entity = entità da stirare
# ptList = lista dei punti da stirare
# offSetX, offSetY = spostamento da fare
# tolerance2ApproxCurve = tolleranza per ricreare le curve
# verifico se l'entità appartiene ad uno stile di quotatura
if entity.whatIs() == "ENTITY":
stretchedGeom = entity.getGeometry()
# controllo inserito perchè con le quote, questa viene cancellata e ricreata quindi alcuni oggetti potrebbero non esistere più
if stretchedGeom is None: # se non c'è lo salto senza errore
return True
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs())
stretchedGeom.transform(coordTransform)
# stiro la feature
stretchedGeom = qad_stretch_fun.stretchQgsGeometry(stretchedGeom, containerGeom, \
offSetX, offSetY, \
tolerance2ApproxCurve)
if stretchedGeom is not None:
# trasformo la geometria nel crs del layer
coordTransform = QgsCoordinateTransform(self.plugIn.canvas.mapRenderer().destinationCrs(), entity.layer.crs())
stretchedGeom.transform(coordTransform)
f = entity.getFeature()
f.setGeometry(stretchedGeom)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, entity.layer, f, False, False) == False:
return False
elif entity.whatIs() == "DIMENTITY":
# stiro la quota
if entity.deleteToLayers(self.plugIn) == False:
return False
entity.stretch(self.plugIn, containerGeom, offSetX, offSetY)
if entity.addToLayers(self.plugIn) == False:
return False
return True
#============================================================================
# stretchFeatures
#============================================================================
def stretchFeatures(self, newPt):
# mi ricavo un unico QadEntitySet con le entità selezionate
entitySet = QadEntitySet()
for SSGeom in self.SSGeomList:
entitySet.unite(SSGeom[0])
self.plugIn.beginEditCommand("Feature stretched", entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
offSetX = newPt.x() - self.basePt.x()
offSetY = newPt.y() - self.basePt.y()
entity = QadEntity()
for SSGeom in self.SSGeomList:
# copio entitySet
entitySet = QadEntitySet(SSGeom[0])
geomSel = SSGeom[1]
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.stretch(entity, geomSel, offSetX, offSetY, tolerance2ApproxCurve) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.stretch(dimEntity, geomSel, offSetX, offSetY, tolerance2ApproxCurve) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
#============================================================================
# setEntitySetGeom
#============================================================================
def setEntitySetGeom(self, entitySet, selGeom):
for SSGeom in self.SSGeomList:
SSGeom[0].deselectOnLayer()
del self.SSGeomList[:] # svuoto la lista
# aggiuge il gruppo di selezione con la geometria usata per la selezione
self.SSGeomList.append([entitySet, selGeom])
entitySet.selectOnLayer(False) # incremental = False
#============================================================================
# addEntitySetGeom
#============================================================================
def addEntitySetGeom(self, entitySet, selGeom):
# elimino dai gruppi precedenti gli oggetti presenti in entitySet
self.removeEntitySet(entitySet)
# aggiuge il gruppo di selezione con la geometria usata per la selezione
self.SSGeomList.append([entitySet, selGeom])
entitySet.selectOnLayer(True) # incremental = True
#============================================================================
# removeEntitySet
#============================================================================
def removeEntitySet(self, entitySet):
# elimino dai gruppi precedenti gli oggetti presenti in entitySet
for SSGeom in self.SSGeomList:
SSGeom[0].subtract(entitySet)
for SSGeom in self.SSGeomList:
SSGeom[0].selectOnLayer(False) # incremental = False
#============================================================================
# SSGeomListIsEmpty
#============================================================================
def SSGeomListIsEmpty(self):
if len(self.SSGeomList) == 0:
return True
for SSGeom in self.SSGeomList:
if SSGeom[0].isEmpty() == False:
return False
return True
#============================================================================
# waitForObjectSel
#============================================================================
def waitForObjectSel(self):
self.step = 1
# imposto il map tool
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.ASK_FOR_FIRST_PT_RECTANGLE)
keyWords = QadMsg.translate("Command_STRETCH", "Polygon") + "/" + \
QadMsg.translate("Command_STRETCH", "Add") + "/" + \
QadMsg.translate("Command_STRETCH", "Remove")
if self.AddOnSelection == True:
prompt = QadMsg.translate("Command_STRETCH", "Select vertices")
else:
prompt = QadMsg.translate("Command_STRETCH", "Remove vertices")
prompt = prompt + QadMsg.translate("Command_STRETCH", " to stretch crossed by a selection window or [{0}]: ").format(keyWords)
englishKeyWords = "Polygon" + "/" + "Add" + "/" + "Remove"
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)
#============================================================================
# waitForBasePt
#============================================================================
def waitForBasePt(self):
self.step = 4
# imposto il map tool
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT)
keyWords = QadMsg.translate("Command_STRETCH", "Displacement")
prompt = QadMsg.translate("Command_STRETCH", "Specify base point or [{0}] <{0}>: ").format(keyWords)
englishKeyWords = "Displacement"
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)
#============================================================================
# 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
#=========================================================================
# RICHIESTA SELEZIONE OGGETTI
if self.step == 0: # inizio del comando
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE OGGETTI DA STIRARE
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
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 type(value) == unicode:
if value == QadMsg.translate("Command_STRETCH", "Polygon") or value == "Polygon":
# Seleziona tutti gli oggetti che sono interni al poligono
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 2
return False
elif value == QadMsg.translate("Command_SSGET", "Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
elif value == QadMsg.translate("Command_SSGET", "Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
elif type(value) == QgsPoint: # se é stato selezionato un punto
del self.points[:] # svuoto la lista
self.points.append(value)
# imposto il map tool
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_STRETCH", "Specify opposite corner: "))
self.step = 3
return False
else:
if self.SSGeomListIsEmpty():
return True
# si appresta ad attendere il punto base o lo spostamento
self.waitForBasePt()
return False
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' POLIGONO (da step = 1)
elif self.step == 2: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
if len(self.MPOLYGONCommand.vertices) > 1:
# cerco tutte le geometrie intersecanti il poligono
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("CP", self.getPointMapTool(), self.MPOLYGONCommand.vertices, \
None, True, True, True, \
True)
# se la selezione é avvenuta con shift premuto o se si deve rimuovere il gruppo selSet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
self.setEntitySetGeom(selSet, QgsGeometry.fromPolygon([self.MPOLYGONCommand.vertices]))
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di mpolygon
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' FINESTRA (da step = 1)
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
self.showMsg(QadMsg.translate("Command_STRETCH", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_STRETCH", "Specify opposite corner: "))
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.points.append(value)
# cerco tutte le geometrie intersecanti il rettangolo
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("C", self.getPointMapTool(), self.points, \
None, True, True, True, \
True)
# se si deve rimuovere il gruppo entitySet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
if shiftKey: # se la selezione é avvenuta con shift premuto
self.addEntitySetGeom(selSet, QgsGeometry.fromRect(QgsRectangle(self.points[0], self.points[1])))
else:
self.setEntitySetGeom(selSet, QgsGeometry.fromRect(QgsRectangle(self.points[0], self.points[1])))
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO BASE (da step = 1)
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
pass # opzione di default "spostamento"
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
# imposto il map tool
self.getPointMapTool().SSGeomList = self.SSGeomList
if value is None or type(value) == unicode:
self.basePt.set(0, 0)
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto
msg = QadMsg.translate("Command_STRETCH", "Specify the displacement from the origin point 0,0 <{0}, {1}>: ")
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg.format(str(self.plugIn.lastOffsetPt.x()), str(self.plugIn.lastOffsetPt.y())), \
QadInputTypeEnum.POINT2D, \
self.plugIn.lastOffsetPt, \
"", QadInputModeEnum.NONE)
self.step = 5
elif type(value) == QgsPoint: # se é stato inserito il punto base
self.basePt.set(value.x(), value.y())
# imposto il map tool
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_STRETCH", "Specify second point or [Array] <use first point as displacement from origin point 0,0>: "), \
QadInputTypeEnum.POINT2D, \
None, \
"", QadInputModeEnum.NONE)
self.step = 6
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PUNTO DI SPOSTAMENTO (da step = 2)
elif self.step == 5: # 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
self.plugIn.setLastOffsetPt(value)
self.stretchFeatures(value)
return True # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER SPOSTAMENTO (da step = 2)
elif self.step == 6: # 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 value is None:
newPt = QgsPoint(self.basePt.x() * 2, self.basePt.y() * 2)
self.stretchFeatures(newPt)
elif type(value) == QgsPoint: # se é stato inserito lo spostamento con un punto
self.stretchFeatures(value)
return True # fine comando
def run(self, msgMapTool = False, msg = None):
# ritorna:
# True per selezione non terminata
# False per selezione terminata
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 # errore
#=========================================================================
# RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
if self.step == 0:
# if you can also select objects before you start a command
if QadVariables.get(QadMsg.translate("Environment variables", "PICKFIRST")) == 1:
if self.AddCurrentQgsSelectedFeatures() == True:
self.plugIn.setLastEntitySet(self.entitySet)
return True;
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
elif self.step == 1: # dopo aver atteso un punto o enter 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
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False # continua
shiftKey = self.getPointMapTool().shiftKey
# se é stata selezionata un'entità
if self.getPointMapTool().entity.isInitialized():
value = self.getPointMapTool().entity
else:
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if value is None:
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if type(value) == unicode:
self.currSelectionMode = value
if value == QadMsg.translate("Command_SSGET", "Window") or value == "Window" or \
value == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
# "Finestra" = Seleziona tutti gli oggetti che si trovano completamente all'interno di un rettangolo definito da due punti
# "Interseca" = Seleziona gli oggetti che intersecano o si trovano all'interno di un'area definita da due punti
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
if value == QadMsg.translate("Command_SSGET", "Last") or value == "Last":
# Seleziona l'ultima entità inserita
if self.plugIn.getLastEntity() is None:
self.showMsgOnAddRemove(0)
else:
self.AddRemoveEntity(self.plugIn.getLastEntity(), self.AddOnSelection)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Box") or value == "Box":
# Seleziona tutti gli oggetti che intersecano o si trovano all'interno di un rettangolo specificato da due punti.
# Se i punti del rettangolo sono specificati da destra a sinistra, Riquadro equivale ad Interseca,
# altrimenti é equivalente a Finestra
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
elif value == QadMsg.translate("Command_SSGET", "All") or value == "All":
# Seleziona tutti gli oggetti
selSet = qad_utils.getSelSet("X", self.getPointMapTool(), None, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Fence") or value == "Fence":
# Seleziona tutti gli oggetti che intersecano una polilinea
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 = 4
elif value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon" or \
value == QadMsg.translate("Command_SSGET", "CPolygon") or value == "CPolygon":
# "FPoligono" = Seleziona oggetti che si trovano completamente all'interno di un poligono definito da punti
# "IPoligono" = Seleziona gli oggetti che intersecano o si trovano all'interno di un poligono definito specificando dei punti
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon":
self.MPOLYGONCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MPOLYGONCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 7
elif value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle" or \
value == QadMsg.translate("Command_SSGET", "CCircle") or value == "CCircle":
# "FCerchio" = Seleziona oggetti che si trovano completamente all'interno di un cerchio
# "ICerchio" = Seleziona oggetti che intersecano o si trovano all'interno di un cerchio
self.CIRCLECommand = QadCIRCLECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.CIRCLECommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle":
self.CIRCLECommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.CIRCLECommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.CIRCLECommand.run(msgMapTool, msg)
self.step = 5
elif value == QadMsg.translate("Command_SSGET", "WObjects") or value == "WObjects" or \
value == QadMsg.translate("Command_SSGET", "CObjects") or value == "CObjects":
# "FOggetti" = Seleziona oggetti che si trovano completamente all'interno di oggetti da selezionare
# "IOggetti" = Seleziona oggetti che intersecano o si trovano all'interno di oggetti da selezionare
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.run(msgMapTool, msg)
self.step = 6
elif value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer" or \
value == QadMsg.translate("Command_SSGET", "CBuffer") or value == "CBuffer":
# ho dovuto spostare questo import perché qad_mbuffer_cmd fa l'import di qad_ssget_cmd
from qad_mbuffer_cmd import QadMBUFFERCommandClass
# "FBuffer" = Seleziona oggetti che si trovano completamente all'interno di buffer intorno ad oggetti da selezionare
# "IBuffer" = Seleziona oggetti che intersecano o si trovano all'interno di buffer intorno ad oggetti da selezionare
self.MBUFFERCommand = QadMBUFFERCommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.MBUFFERCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer":
self.MBUFFERCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MBUFFERCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MBUFFERCommand.run(msgMapTool, msg)
self.step = 8
elif value == QadMsg.translate("Command_SSGET", "Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Previous") or value == "Previous":
# Seleziona il gruppo di selezione più recente
if self.plugIn.lastEntitySet is None:
self.showMsgOnAddRemove(0)
else:
entitySet = QadEntitySet()
entitySet.set(self.plugIn.lastEntitySet)
# controllo sul layer
if self.onlyEditableLayers == True:
entitySet.removeNotEditable()
# controllo sul tipo
if self.checkPointLayer == False:
entitySet.removeGeomType(QGis.Point)
if self.checkLineLayer == False:
entitySet.removeGeomType(QGis.Line)
if self.checkPolygonLayer == False:
entitySet.removeGeomType(QGis.Polygon)
# controllo sulle quotature
if self.checkDimLayers == False:
QadDimStyles.removeAllDimLayersFromEntitySet(entitySet)
entitySet.removeNotExisting()
self.elaborateSelSet(entitySet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Undo") or value == "Undo":
# Annulla la selezione dell'oggetto aggiunto più recentemente al gruppo di selezione.
# Inverto il tipo di selezione
prevAddOnSelection = self.AddOnSelection
self.AddOnSelection = not self.AddOnSelection
self.elaborateSelSet(self.lastEntitySet, False)
# Ripristino il tipo di selezione
self.AddOnSelection = prevAddOnSelection
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "AUto") or value == "AUto":
# Passa alla selezione automatica: vengono selezionati gli oggetti sui quali si posiziona il puntatore.
# Facendo clic su un'area vuota all'interno o all'esterno di un oggetto,
# si crea il primo angolo di un rettangolo di selezione, come per il metodo Riquadro
self.SingleSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "SIngle") or value == "SIngle":
# Passa al metodo Singolo: viene selezionato il primo oggetto o gruppo di oggetti indicato,
# senza che vengano richieste altre selezioni.
self.SingleSelection = True
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Help") or value == "Help":
self.help = True
self.WaitForFirstPoint()
elif type(value) == QgsPoint: # se é stato inserito il punto iniziale del rettangolo
self.currSelectionMode = QadMsg.translate("Command_SSGET", "Box")
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else: # se é stata selezionata un'entità
self.elaborateEntity(value, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DEL RETTANGOLO DA OPZIONE
# FINESTRA, INTERSECA, RIQUADRO (da step = 1)
elif self.step == 2: # 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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False
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) == QgsPoint:
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
# cambio il colore impostato da setDrawMode
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or value == "Window":
self.getPointMapTool().rectangleCrossingSelectionColor = self.getPointMapTool().rectangleWindowSelectionColor
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
self.getPointMapTool().rectangleWindowSelectionColor = self.getPointMapTool().rectangleCrossingSelectionColor
self.rectangleCrossingSelectionColor = getColorForCrossingSelectionArea()
self.rectangleWindowSelectionColor = getColorForWindowSelectionArea()
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DEL RETTANGOLO (da step = 1)
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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.getPointMapTool().clear()
self.points.append(value)
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Box") or \
self.currSelectionMode == "Box":
if self.points[0].x() < value.x():
mode = "W"
else:
mode = "C"
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or \
self.currSelectionMode == "Window":
mode = "W"
else: # "Interseca"
mode = "C"
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), self.points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' INTERCETTA (da step = 1 o 4)
elif self.step == 4: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.AddRemoveSelSetByFence(self.PLINECommand.vertices)
del self.PLINECommand
self.PLINECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FCERCHIO e ICERCHIO (da step = 1 o 5)
elif self.step == 5: # dopo aver atteso un punto si riavvia il comando
if self.CIRCLECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if (self.CIRCLECommand.centerPt is not None) and \
(self.CIRCLECommand.radius is not None):
circle = QadCircle()
circle.set(self.CIRCLECommand.centerPt, self.CIRCLECommand.radius)
points = circle.asPolyline()
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WCircle") or \
self.currSelectionMode == "WCircle":
self.AddRemoveSelSetByPolygon("WP", points)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CCircle") or \
self.currSelectionMode == "CCircle":
self.AddRemoveSelSetByPolygon("CP", points)
del self.CIRCLECommand
self.CIRCLECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FOGGETTI e IOGGETTI (da step = 1 o 6)
elif self.step == 6: # dopo aver atteso un punto si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
self.showMsg("\n")
destCRS = self.SSGetClass.getPointMapTool().canvas.mapRenderer().destinationCrs()
geoms = self.SSGetClass.entitySet.getGeometryCollection(destCRS) # trasformo la geometria
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WObjects") or \
self.currSelectionMode == "WObjects":
self.AddRemoveSelSetByGeometry("WO", geoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CObjects") or \
self.currSelectionMode == "CObjects":
self.AddRemoveSelSetByGeometry("CO", geoms)
del self.SSGetClass
self.SSGetClass = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FPOLIGONO e IPOLIGONO (da step = 1 o 7)
elif self.step == 7: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WPolygon") or \
self.currSelectionMode == "WPolygon":
self.AddRemoveSelSetByPolygon("WP", self.MPOLYGONCommand.vertices)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CPolygon") or \
self.currSelectionMode == "CPolygon":
self.AddRemoveSelSetByPolygon("CP", self.MPOLYGONCommand.vertices)
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FBUFFER e IBUFFER (da step = 1 o 8)
elif self.step == 8: # dopo aver atteso un punto si riavvia il comando
if self.MBUFFERCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
bufferGeoms = []
for layerEntitySet in self.MBUFFERCommand.entitySet.layerEntitySetList:
geoms = layerEntitySet.getGeometryCollection()
width = qad_utils.distMapToLayerCoordinates(self.MBUFFERCommand.width, \
self.MBUFFERCommand.getPointMapTool().canvas,\
layerEntitySet.layer)
for geom in geoms:
bufferGeoms.append(geom.buffer(width, self.MBUFFERCommand.segments))
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WBuffer") or \
self.currSelectionMode == "WBuffer":
self.AddRemoveSelSetByGeometry("WO", bufferGeoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CBuffer") or \
self.currSelectionMode == "CBuffer":
self.AddRemoveSelSetByGeometry("CO", bufferGeoms)
del self.MBUFFERCommand
self.MBUFFERCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
class QadSSGetClass(QadCommandClass):
# Classe che gestisce la selezione di oggetti geometrici
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadSSGetClass(self.plugIn)
def __init__(self, plugIn):
self.init(plugIn)
def __del__(self):
QadCommandClass.__del__(self)
#self.entitySet.deselectOnLayer()
def init(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.AddOnSelection = True # se = False significa remove
self.entitySet = QadEntitySet()
self.points = []
self.currSelectionMode = ""
# opzioni per limitare gli oggetti da selezionare
self.onlyEditableLayers = False
self.checkPointLayer = True
self.checkLineLayer = True
self.checkPolygonLayer = True
self.checkDimLayers = True # include tutte le features che compongono le quotature selezionate
self.help = False
# se SingleSelection = True viene selezionato il primo oggetto o gruppo di oggetti indicato,
# senza che vengano richieste altre selezioni.
self.SingleSelection = False
self.pickAdd = QadVariables.get(QadMsg.translate("Environment variables", "PICKADD"))
# se exitAfterSelection = True il comando viene terminato dopo una qualunque selezione
# indipendentemente che sia stato selezionato o meno un oggetto o gruppo di oggetti.
# usato da QadVirtualSelCommandClass
self.exitAfterSelection = False
# selezione degli oggetti aggiunti più recentemente al gruppo di selezione (x opzione annulla)
self.lastEntitySet = QadEntitySet()
self.PLINECommand = None
self.CIRCLECommand = None
self.MPOLYGONCommand = None
self.MBUFFERCommand = None
self.SSGetClass = None
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 4: # quando si é in fase di disegno linea
return self.PLINECommand.getPointMapTool(drawMode)
elif self.step == 5: # quando si é in fase di disegno cerchio
return self.CIRCLECommand.getPointMapTool(drawMode)
elif self.step == 6: # quando si é in fase di selezione entità
return self.SSGetClass.getPointMapTool(drawMode)
elif self.step == 7: # quando si é in fase di disegno polygono
return self.MPOLYGONCommand.getPointMapTool(drawMode)
elif self.step == 8: # quando si é in fase di disegno buffer
return self.MBUFFERCommand.getPointMapTool(drawMode)
else:
ptMapTool = QadCommandClass.getPointMapTool(self, drawMode)
ptMapTool.setSnapType(QadSnapTypeEnum.DISABLE)
ptMapTool.setOrthoMode(0)
return ptMapTool
#============================================================================
# getLayersToCheck
#============================================================================
def getLayersToCheck(self):
layerList = []
for layer in self.plugIn.canvas.layers(): # Tutti i layer visibili visibili
# considero solo i layer vettoriali che sono filtrati per tipo
if (layer.type() == QgsMapLayer.VectorLayer) and \
((layer.geometryType() == QGis.Point and self.checkPointLayer == True) or \
(layer.geometryType() == QGis.Line and self.checkLineLayer == True) or \
(layer.geometryType() == QGis.Polygon and self.checkPolygonLayer == True)) and \
(self.onlyEditableLayers == False or layer.isEditable()):
# se devo includere i layers delle quotature
if self.checkDimLayers == True or \
len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
return layerList
#============================================================================
# showMsgOnAddRemove
#============================================================================
def showMsgOnAddRemove(self, found):
msg = QadMsg.translate("Command_SSGET", " found {0}, total {1}")
self.showMsg(msg.format(found, self.entitySet.count()), True) # ripete il prompt
#============================================================================
# elaborateEntity
#============================================================================
def elaborateEntity(self, entity, shiftKey):
if self.AddOnSelection == True: # aggiungi al gruppo di selezione
if shiftKey: # se la selezione é avvenuta con shift premuto
if self.pickAdd == 0: # The objects most recently selected become the selection set
if self.entitySet.containsEntity(entity): # se l'entità era già stata selezionata
self.AddRemoveEntity(entity, False) # rimuovo l'entità
else:
self.AddRemoveEntity(entity, True) # aggiungo l'entità
else:
self.AddRemoveEntity(entity, False) # rimuovo l'entità
else: # senza tasto shift
if self.pickAdd == 0: # The objects most recently selected become the selection set
self.SetEntity(entity)
else:
self.AddRemoveEntity(entity, True) # aggiungo l'entità
else: # se si deve rimuovere dal gruppo di selezione
self.AddRemoveEntity(entity, False) # rimuovo l'entità
#============================================================================
# SetEntity
#============================================================================
def SetEntity(self, entity):
# controllo sul layer
if self.onlyEditableLayers == True and entity.layer.isEditable() == False:
self.showMsgOnAddRemove(0)
return
# controllo sul tipo
if (self.checkPointLayer == False and entity.layer.geometryType() == QGis.Point) or \
(self.checkLineLayer == False and entity.layer.geometryType() == QGis.Line) or \
(self.checkPolygonLayer == False and entity.layer.geometryType() == QGis.Polygon):
self.showMsgOnAddRemove(0)
return
# controllo su layer delle quotature
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if self.checkDimLayers == False and dimEntity is not None:
self.showMsgOnAddRemove(0)
return
self.entitySet.deselectOnLayer()
self.entitySet.clear()
self.entitySet.addEntity(entity)
if self.checkDimLayers == True and dimEntity is not None:
# Aggiungo i componenenti della quotatura a set <entitySet>
self.entitySet.unite(dimEntity.getEntitySet())
self.showMsgOnAddRemove(self.entitySet.count())
self.entitySet.selectOnLayer(False) # incremental = False aaaaaaaaaaaaaaaaaaaaaaaaaa qui parte l'evento activate di qad_maptool
self.lastEntitySet.clear()
self.lastEntitySet.addEntity(entity)
#============================================================================
# AddRemoveEntity
#============================================================================
def AddRemoveEntity(self, entity, Add):
# controllo sul layer
if self.onlyEditableLayers == True and entity.layer.isEditable() == False:
self.showMsgOnAddRemove(0)
return
# controllo sul tipo
if (self.checkPointLayer == False and entity.layer.geometryType() == QGis.Point) or \
(self.checkLineLayer == False and entity.layer.geometryType() == QGis.Line) or \
(self.checkPolygonLayer == False and entity.layer.geometryType() == QGis.Polygon):
self.showMsgOnAddRemove(0)
return
# controllo su layer delle quotature
if self.checkDimLayers == False and len(QadDimStyles.getDimListByLayer(entity.layer)) > 0:
self.showMsgOnAddRemove(0)
return
self.entitySet.deselectOnLayer()
if Add == True: # aggiungi al gruppo di selezione
self.entitySet.addEntity(entity)
else: # rimuovi dal gruppo di selezione
self.entitySet.removeEntity(entity)
if self.checkDimLayers == True:
dimEntitySet = QadEntitySet()
dimEntitySet.addEntity(entity)
# La funzione verifica se le entità che fanno parte di un entitySet sono anche parte di quotatura e,
# in caso affermativo, aggiunge/rimuove tutti i componenti delle quotature all'entitySet.
QadDimStyles.addAllDimComponentsToEntitySet(dimEntitySet, self.onlyEditableLayers)
if Add == True: # aggiungi al gruppo di selezione
self.entitySet.unite(dimEntitySet)
else: # rimuovi dal gruppo di selezione
self.entitySet.subtract(dimEntitySet)
self.showMsgOnAddRemove(dimEntitySet.count())
else:
self.showMsgOnAddRemove(1)
self.entitySet.selectOnLayer(False) # incremental = False
self.lastEntitySet.clear()
self.lastEntitySet.addEntity(entity)
#============================================================================
# elaborateSelSet
#============================================================================
def elaborateSelSet(self, selSet, shiftKey):
if self.AddOnSelection == True: # aggiungi al gruppo di selezione
if shiftKey: # se la selezione é avvenuta con shift premuto
if self.pickAdd == 0: # The objects most recently selected become the selection set
# verifico se ci sono degli oggetti non ancora selezionati
intersectSS = QadEntitySet(selSet)
intersectSS.subtract(self.entitySet)
if intersectSS.isEmpty(): # tutti gli oggetti erano già selezionati
self.AddRemoveSelSet(selSet, False) # rimuovo il gruppo di selezione
else:
self.AddRemoveSelSet(selSet, True) # aggiungo il gruppo di selezione
else:
self.AddRemoveSelSet(selSet, False) # rimuovo il gruppo di selezione
else: # senza tasto shift
if self.pickAdd == 0: # The objects most recently selected become the selection set
self.SetSelSet(selSet)
else:
self.AddRemoveSelSet(selSet, True) # aggiungo il gruppo di selezione
else: # se si deve rimuovere dal gruppo di selezione
self.AddRemoveEntity(selSet, False) # rimuovo il gruppo di selezione
#============================================================================
# SetSelSet
#============================================================================
def SetSelSet(self, selSet):
for layerEntitySet in self.entitySet.layerEntitySetList:
# se il layer non é presente in selSet
if selSet.findLayerEntitySet(layerEntitySet) is None:
layerEntitySet.deselectOnLayer()
else:
layerEntitySet.deselectOnLayer()
self.entitySet.set(selSet)
if self.checkDimLayers == True:
dimEntitySet = QadEntitySet(selSet)
# La funzione verifica se le entità che fanno parte di un entitySet sono anche parte di quotatura e,
# in caso affermativo, aggiunge tutti i componenti delle quotature all'entitySet.
QadDimStyles.addAllDimComponentsToEntitySet(dimEntitySet, self.onlyEditableLayers)
self.entitySet.unite(dimEntitySet)
self.showMsgOnAddRemove(self.entitySet.count())
self.entitySet.selectOnLayer(False) # incremental = False
self.lastEntitySet.set(selSet)
#============================================================================
# AddCurrentQgsSelectedFeatures
#============================================================================
def AddCurrentQgsSelectedFeatures(self):
# verifico se ci sono entità correntemente selezionate
self.entitySet.initByCurrentQgsSelectedFeatures(self.getLayersToCheck())
found = self.entitySet.count()
if found > 0:
msg = QadMsg.translate("Command_SSGET", "\nfound {0}")
self.showMsg(msg.format(found), False) # non ripete il prompt
return True
else:
return False
#============================================================================
# AddRemoveSelSet
#============================================================================
def AddRemoveSelSet(self, selSet, Add):
self.entitySet.deselectOnLayer()
if Add == True: # aggiungi al gruppo di selezione
self.entitySet.unite(selSet)
else: # rimuovi dal gruppo di selezione
self.entitySet.subtract(selSet)
self.showMsgOnAddRemove(selSet.count())
self.entitySet.selectOnLayer(False) # incremental = False
self.lastEntitySet.set(selSet)
#============================================================================
# AddRemoveSelSetByFence
#============================================================================
def AddRemoveSelSetByFence(self, points):
if len(points) > 1:
selSet = qad_utils.getSelSet("F", self.getPointMapTool(), points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
#============================================================================
# AddRemoveSelSetByPolygon
#============================================================================
def AddRemoveSelSetByPolygon(self, mode, points):
if len(points) > 2:
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
#============================================================================
# AddRemoveSelSetByGeometry
#============================================================================
def AddRemoveSelSetByGeometry(self, mode, geom):
if type(geom) == QgsGeometry: # singola geometria
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), geom, \
self.getLayersToCheck())
else: # lista di geometrie
selSet = QadEntitySet()
for g in geom:
partial = qad_utils.getSelSet(mode, self.getPointMapTool(), g, \
self.getLayersToCheck())
selSet.unite(partial)
self.elaborateSelSet(selSet, False)
#============================================================================
# WaitForFirstPoint
#============================================================================
def WaitForFirstPoint(self):
self.step = 1
# "Finestra" "Ultimo" "Interseca"
# "Riquadro" "Tutto" "iNTercetta"
# "FPoligono" "IPoligono"
# "FCerchio" "ICerchio"
# "FOggetti" "IOggetti"
# "FBuffer" "IBuffer"
# "AGgiungi" "Elimina"
# "Precedente" "Annulla"
# "AUto" "SIngolo" "Help"
keyWords = QadMsg.translate("Command_SSGET", "Window") + "/" + \
QadMsg.translate("Command_SSGET", "Last") + "/" + \
QadMsg.translate("Command_SSGET", "Crossing") + "/" + \
QadMsg.translate("Command_SSGET", "Box") + "/" + \
QadMsg.translate("Command_SSGET", "All") + "/" + \
QadMsg.translate("Command_SSGET", "Fence") + "/" + \
QadMsg.translate("Command_SSGET", "WPolygon") + "/" + \
QadMsg.translate("Command_SSGET", "CPolygon") + "/" + \
QadMsg.translate("Command_SSGET", "WCircle") + "/" + \
QadMsg.translate("Command_SSGET", "CCircle") + "/" + \
QadMsg.translate("Command_SSGET", "WObjects") + "/" + \
QadMsg.translate("Command_SSGET", "CObjects") + "/" + \
QadMsg.translate("Command_SSGET", "WBuffer") + "/" + \
QadMsg.translate("Command_SSGET", "CBuffer") + "/" + \
QadMsg.translate("Command_SSGET", "Add") + "/" + \
QadMsg.translate("Command_SSGET", "Remove") + "/" + \
QadMsg.translate("Command_SSGET", "Previous") + "/" + \
QadMsg.translate("Command_SSGET", "Undo") + "/" + \
QadMsg.translate("Command_SSGET", "AUto") + "/" + \
QadMsg.translate("Command_SSGET", "SIngle") + "/" + \
QadMsg.translate("Command_SSGET", "Help")
englishKeyWords = "Window" + "/" + "Last" + "/" + "Crossing" + "/" + "Box" + "/" \
+ "All" + "/" + "Fence" + "/" + "WPolygon" + "/" + "CPolygon" + "/" \
+ "WCircle" + "/" + "CCircle" + "/" + "WObjects" + "/" + "CObjects" + "/" \
+ "WBuffer" + "/" + "CBuffer" + "/" + "Add" + "/" + "Remove" + "/" \
+ "Previous" + "/" + "Undo" + "/" + "AUto" + "/" + "SIngle" + "/" + "Help"
if self.AddOnSelection == True:
prompt = QadMsg.translate("Command_SSGET", "Select Objects")
else:
prompt = QadMsg.translate("Command_SSGET", "Remove objects")
if self.help == True:
prompt = prompt + QadMsg.translate("Command_SSGET", " or [{0}]").format(keyWords)
prompt = prompt + QadMsg.translate("Command_SSGET", ": ")
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# imposto i layer da controllare sul maptool
self.getPointMapTool().layersToCheck = self.getLayersToCheck()
self.points = []
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
def run(self, msgMapTool = False, msg = None):
# ritorna:
# True per selezione non terminata
# False per selezione terminata
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 # errore
#=========================================================================
# RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
if self.step == 0:
# if you can also select objects before you start a command
if QadVariables.get(QadMsg.translate("Environment variables", "PICKFIRST")) == 1:
if self.AddCurrentQgsSelectedFeatures() == True:
self.plugIn.setLastEntitySet(self.entitySet)
return True;
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
elif self.step == 1: # dopo aver atteso un punto o enter 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
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False # continua
shiftKey = self.getPointMapTool().shiftKey
# se é stata selezionata un'entità
if self.getPointMapTool().entity.isInitialized():
value = self.getPointMapTool().entity
else:
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if value is None:
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if type(value) == unicode:
self.currSelectionMode = value
if value == QadMsg.translate("Command_SSGET", "Window") or value == "Window" or \
value == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
# "Finestra" = Seleziona tutti gli oggetti che si trovano completamente all'interno di un rettangolo definito da due punti
# "Interseca" = Seleziona gli oggetti che intersecano o si trovano all'interno di un'area definita da due punti
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
if value == QadMsg.translate("Command_SSGET", "Last") or value == "Last":
# Seleziona l'ultima entità inserita
if self.plugIn.getLastEntity() is None:
self.showMsgOnAddRemove(0)
else:
self.AddRemoveEntity(self.plugIn.getLastEntity(), self.AddOnSelection)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Box") or value == "Box":
# Seleziona tutti gli oggetti che intersecano o si trovano all'interno di un rettangolo specificato da due punti.
# Se i punti del rettangolo sono specificati da destra a sinistra, Riquadro equivale ad Interseca,
# altrimenti é equivalente a Finestra
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
elif value == QadMsg.translate("Command_SSGET", "All") or value == "All":
# Seleziona tutti gli oggetti
selSet = qad_utils.getSelSet("X", self.getPointMapTool(), None, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Fence") or value == "Fence":
# Seleziona tutti gli oggetti che intersecano una polilinea
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 = 4
elif value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon" or \
value == QadMsg.translate("Command_SSGET", "CPolygon") or value == "CPolygon":
# "FPoligono" = Seleziona oggetti che si trovano completamente all'interno di un poligono definito da punti
# "IPoligono" = Seleziona gli oggetti che intersecano o si trovano all'interno di un poligono definito specificando dei punti
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon":
self.MPOLYGONCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MPOLYGONCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 7
elif value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle" or \
value == QadMsg.translate("Command_SSGET", "CCircle") or value == "CCircle":
# "FCerchio" = Seleziona oggetti che si trovano completamente all'interno di un cerchio
# "ICerchio" = Seleziona oggetti che intersecano o si trovano all'interno di un cerchio
self.CIRCLECommand = QadCIRCLECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.CIRCLECommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle":
self.CIRCLECommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.CIRCLECommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.CIRCLECommand.run(msgMapTool, msg)
self.step = 5
elif value == QadMsg.translate("Command_SSGET", "WObjects") or value == "WObjects" or \
value == QadMsg.translate("Command_SSGET", "CObjects") or value == "CObjects":
# "FOggetti" = Seleziona oggetti che si trovano completamente all'interno di oggetti da selezionare
# "IOggetti" = Seleziona oggetti che intersecano o si trovano all'interno di oggetti da selezionare
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.run(msgMapTool, msg)
self.step = 6
elif value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer" or \
value == QadMsg.translate("Command_SSGET", "CBuffer") or value == "CBuffer":
# ho dovuto spostare questo import perché qad_mbuffer_cmd fa l'import di qad_ssget_cmd
from qad_mbuffer_cmd import QadMBUFFERCommandClass
# "FBuffer" = Seleziona oggetti che si trovano completamente all'interno di buffer intorno ad oggetti da selezionare
# "IBuffer" = Seleziona oggetti che intersecano o si trovano all'interno di buffer intorno ad oggetti da selezionare
self.MBUFFERCommand = QadMBUFFERCommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.MBUFFERCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer":
self.MBUFFERCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MBUFFERCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MBUFFERCommand.run(msgMapTool, msg)
self.step = 8
elif value == QadMsg.translate("Command_SSGET", "Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Previous") or value == "Previous":
# Seleziona il gruppo di selezione più recente
if self.plugIn.lastEntitySet is None:
self.showMsgOnAddRemove(0)
else:
entitySet = QadEntitySet()
entitySet.set(self.plugIn.lastEntitySet)
# controllo sul layer
if self.onlyEditableLayers == True:
entitySet.removeNotEditable()
# controllo sul tipo
if self.checkPointLayer == False:
entitySet.removeGeomType(QGis.Point)
if self.checkLineLayer == False:
entitySet.removeGeomType(QGis.Line)
if self.checkPolygonLayer == False:
entitySet.removeGeomType(QGis.Polygon)
# controllo sulle quotature
if self.checkDimLayers == False:
QadDimStyles.removeAllDimLayersFromEntitySet(entitySet)
entitySet.removeNotExisting()
self.elaborateSelSet(entitySet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Undo") or value == "Undo":
# Annulla la selezione dell'oggetto aggiunto più recentemente al gruppo di selezione.
# Inverto il tipo di selezione
prevAddOnSelection = self.AddOnSelection
self.AddOnSelection = not self.AddOnSelection
self.elaborateSelSet(self.lastEntitySet, False)
# Ripristino il tipo di selezione
self.AddOnSelection = prevAddOnSelection
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "AUto") or value == "AUto":
# Passa alla selezione automatica: vengono selezionati gli oggetti sui quali si posiziona il puntatore.
# Facendo clic su un'area vuota all'interno o all'esterno di un oggetto,
# si crea il primo angolo di un rettangolo di selezione, come per il metodo Riquadro
self.SingleSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "SIngle") or value == "SIngle":
# Passa al metodo Singolo: viene selezionato il primo oggetto o gruppo di oggetti indicato,
# senza che vengano richieste altre selezioni.
self.SingleSelection = True
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Help") or value == "Help":
self.help = True
self.WaitForFirstPoint()
elif type(value) == QgsPoint: # se é stato inserito il punto iniziale del rettangolo
self.currSelectionMode = QadMsg.translate("Command_SSGET", "Box")
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else: # se é stata selezionata un'entità
self.elaborateEntity(value, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DEL RETTANGOLO DA OPZIONE
# FINESTRA, INTERSECA, RIQUADRO (da step = 1)
elif self.step == 2: # 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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False
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) == QgsPoint:
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
# cambio il colore impostato da setDrawMode
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or value == "Window":
self.getPointMapTool().rectangleCrossingSelectionColor = self.getPointMapTool().rectangleWindowSelectionColor
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
self.getPointMapTool().rectangleWindowSelectionColor = self.getPointMapTool().rectangleCrossingSelectionColor
self.rectangleCrossingSelectionColor = getColorForCrossingSelectionArea()
self.rectangleWindowSelectionColor = getColorForWindowSelectionArea()
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DEL RETTANGOLO (da step = 1)
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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.getPointMapTool().clear()
self.points.append(value)
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Box") or \
self.currSelectionMode == "Box":
if self.points[0].x() < value.x():
mode = "W"
else:
mode = "C"
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or \
self.currSelectionMode == "Window":
mode = "W"
else: # "Interseca"
mode = "C"
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), self.points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' INTERCETTA (da step = 1 o 4)
elif self.step == 4: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.AddRemoveSelSetByFence(self.PLINECommand.vertices)
del self.PLINECommand
self.PLINECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FCERCHIO e ICERCHIO (da step = 1 o 5)
elif self.step == 5: # dopo aver atteso un punto si riavvia il comando
if self.CIRCLECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if (self.CIRCLECommand.centerPt is not None) and \
(self.CIRCLECommand.radius is not None):
circle = QadCircle()
circle.set(self.CIRCLECommand.centerPt, self.CIRCLECommand.radius)
points = circle.asPolyline()
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WCircle") or \
self.currSelectionMode == "WCircle":
self.AddRemoveSelSetByPolygon("WP", points)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CCircle") or \
self.currSelectionMode == "CCircle":
self.AddRemoveSelSetByPolygon("CP", points)
del self.CIRCLECommand
self.CIRCLECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FOGGETTI e IOGGETTI (da step = 1 o 6)
elif self.step == 6: # dopo aver atteso un punto si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
self.showMsg("\n")
destCRS = self.SSGetClass.getPointMapTool().canvas.mapRenderer().destinationCrs()
geoms = self.SSGetClass.entitySet.getGeometryCollection(destCRS) # trasformo la geometria
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WObjects") or \
self.currSelectionMode == "WObjects":
self.AddRemoveSelSetByGeometry("WO", geoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CObjects") or \
self.currSelectionMode == "CObjects":
self.AddRemoveSelSetByGeometry("CO", geoms)
del self.SSGetClass
self.SSGetClass = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FPOLIGONO e IPOLIGONO (da step = 1 o 7)
elif self.step == 7: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WPolygon") or \
self.currSelectionMode == "WPolygon":
self.AddRemoveSelSetByPolygon("WP", self.MPOLYGONCommand.vertices)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CPolygon") or \
self.currSelectionMode == "CPolygon":
self.AddRemoveSelSetByPolygon("CP", self.MPOLYGONCommand.vertices)
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FBUFFER e IBUFFER (da step = 1 o 8)
elif self.step == 8: # dopo aver atteso un punto si riavvia il comando
if self.MBUFFERCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
bufferGeoms = []
for layerEntitySet in self.MBUFFERCommand.entitySet.layerEntitySetList:
geoms = layerEntitySet.getGeometryCollection()
width = qad_utils.distMapToLayerCoordinates(self.MBUFFERCommand.width, \
self.MBUFFERCommand.getPointMapTool().canvas,\
layerEntitySet.layer)
for geom in geoms:
bufferGeoms.append(geom.buffer(width, self.MBUFFERCommand.segments))
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WBuffer") or \
self.currSelectionMode == "WBuffer":
self.AddRemoveSelSetByGeometry("WO", bufferGeoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CBuffer") or \
self.currSelectionMode == "CBuffer":
self.AddRemoveSelSetByGeometry("CO", bufferGeoms)
del self.MBUFFERCommand
self.MBUFFERCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
class QadSSGetClass(QadCommandClass):
# Classe che gestisce la selezione di oggetti geometrici
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadSSGetClass(self.plugIn)
def __init__(self, plugIn):
self.init(plugIn)
def __del__(self):
QadCommandClass.__del__(self)
#self.entitySet.deselectOnLayer()
def init(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.AddOnSelection = True # se = False significa remove
self.entitySet = QadEntitySet()
self.points = []
self.currSelectionMode = ""
# opzioni per limitare gli oggetti da selezionare
self.onlyEditableLayers = False
self.checkPointLayer = True
self.checkLineLayer = True
self.checkPolygonLayer = True
self.checkDimLayers = True # include tutte le features che compongono le quotature selezionate
self.help = False
# se SingleSelection = True viene selezionato il primo oggetto o gruppo di oggetti indicato,
# senza che vengano richieste altre selezioni.
self.SingleSelection = False
self.pickAdd = QadVariables.get(QadMsg.translate("Environment variables", "PICKADD"))
# se exitAfterSelection = True il comando viene terminato dopo una qualunque selezione
# indipendentemente che sia stato selezionato o meno un oggetto o gruppo di oggetti.
# usato da QadVirtualSelCommandClass
self.exitAfterSelection = False
# selezione degli oggetti aggiunti più recentemente al gruppo di selezione (x opzione annulla)
self.lastEntitySet = QadEntitySet()
self.PLINECommand = None
self.CIRCLECommand = None
self.MPOLYGONCommand = None
self.MBUFFERCommand = None
self.SSGetClass = None
def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
if self.step == 4: # quando si é in fase di disegno linea
return self.PLINECommand.getPointMapTool(drawMode)
elif self.step == 5: # quando si é in fase di disegno cerchio
return self.CIRCLECommand.getPointMapTool(drawMode)
elif self.step == 6: # quando si é in fase di selezione entità
return self.SSGetClass.getPointMapTool(drawMode)
elif self.step == 7: # quando si é in fase di disegno polygono
return self.MPOLYGONCommand.getPointMapTool(drawMode)
elif self.step == 8: # quando si é in fase di disegno buffer
return self.MBUFFERCommand.getPointMapTool(drawMode)
else:
ptMapTool = QadCommandClass.getPointMapTool(self, drawMode)
ptMapTool.setSnapType(QadSnapTypeEnum.DISABLE)
ptMapTool.setOrthoMode(0)
return ptMapTool
#============================================================================
# getLayersToCheck
#============================================================================
def getLayersToCheck(self):
layerList = []
for layer in qad_utils.getVisibleVectorLayers(self.plugIn.canvas): # Tutti i layer vettoriali visibili
# considero solo i layer vettoriali che sono filtrati per tipo
if ((layer.geometryType() == QGis.Point and self.checkPointLayer == True) or \
(layer.geometryType() == QGis.Line and self.checkLineLayer == True) or \
(layer.geometryType() == QGis.Polygon and self.checkPolygonLayer == True)) and \
(self.onlyEditableLayers == False or layer.isEditable()):
# se devo includere i layers delle quotature
if self.checkDimLayers == True or \
len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
return layerList
#============================================================================
# showMsgOnAddRemove
#============================================================================
def showMsgOnAddRemove(self, found):
msg = QadMsg.translate("Command_SSGET", " found {0}, total {1}")
self.showMsg(msg.format(found, self.entitySet.count()), False) # non ripete il prompt 2016
#============================================================================
# elaborateEntity
#============================================================================
def elaborateEntity(self, entity, shiftKey):
if self.AddOnSelection == True: # aggiungi al gruppo di selezione
if shiftKey: # se la selezione é avvenuta con shift premuto
if self.pickAdd == 0: # The objects most recently selected become the selection set
if self.entitySet.containsEntity(entity): # se l'entità era già stata selezionata
self.AddRemoveEntity(entity, False) # rimuovo l'entità
else:
self.AddRemoveEntity(entity, True) # aggiungo l'entità
else:
self.AddRemoveEntity(entity, False) # rimuovo l'entità
else: # senza tasto shift
if self.pickAdd == 0: # The objects most recently selected become the selection set
self.SetEntity(entity)
else:
self.AddRemoveEntity(entity, True) # aggiungo l'entità
else: # se si deve rimuovere dal gruppo di selezione
self.AddRemoveEntity(entity, False) # rimuovo l'entità
#============================================================================
# SetEntity
#============================================================================
def SetEntity(self, entity):
# controllo sul layer
if self.onlyEditableLayers == True and entity.layer.isEditable() == False:
self.showMsgOnAddRemove(0)
return
# controllo sul tipo
if (self.checkPointLayer == False and entity.layer.geometryType() == QGis.Point) or \
(self.checkLineLayer == False and entity.layer.geometryType() == QGis.Line) or \
(self.checkPolygonLayer == False and entity.layer.geometryType() == QGis.Polygon):
self.showMsgOnAddRemove(0)
return
# controllo su layer delle quotature
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if self.checkDimLayers == False and dimEntity is not None:
self.showMsgOnAddRemove(0)
return
self.entitySet.deselectOnLayer()
self.entitySet.clear()
self.entitySet.addEntity(entity)
if self.checkDimLayers == True and dimEntity is not None:
# Aggiungo i componenenti della quotatura a set <entitySet>
self.entitySet.unite(dimEntity.getEntitySet())
self.showMsgOnAddRemove(self.entitySet.count())
self.entitySet.selectOnLayer(False) # incremental = False aaaaaaaaaaaaaaaaaaaaaaaaaa qui parte l'evento activate di qad_maptool (se il layer non è in modifica)
self.lastEntitySet.clear()
self.lastEntitySet.addEntity(entity)
#============================================================================
# AddRemoveEntity
#============================================================================
def AddRemoveEntity(self, entity, Add):
# controllo sul layer
if self.onlyEditableLayers == True and entity.layer.isEditable() == False:
self.showMsgOnAddRemove(0)
return
# controllo sul tipo
if (self.checkPointLayer == False and entity.layer.geometryType() == QGis.Point) or \
(self.checkLineLayer == False and entity.layer.geometryType() == QGis.Line) or \
(self.checkPolygonLayer == False and entity.layer.geometryType() == QGis.Polygon):
self.showMsgOnAddRemove(0)
return
# controllo su layer delle quotature
if self.checkDimLayers == False and len(QadDimStyles.getDimListByLayer(entity.layer)) > 0:
self.showMsgOnAddRemove(0)
return
self.entitySet.deselectOnLayer()
if Add == True: # aggiungi al gruppo di selezione
self.entitySet.addEntity(entity)
else: # rimuovi dal gruppo di selezione
self.entitySet.removeEntity(entity)
if self.checkDimLayers == True:
dimEntitySet = QadEntitySet()
dimEntitySet.addEntity(entity)
# La funzione verifica se le entità che fanno parte di un entitySet sono anche parte di quotatura e,
# in caso affermativo, aggiunge/rimuove tutti i componenti delle quotature all'entitySet.
QadDimStyles.addAllDimComponentsToEntitySet(dimEntitySet, self.onlyEditableLayers)
if Add == True: # aggiungi al gruppo di selezione
self.entitySet.unite(dimEntitySet)
else: # rimuovi dal gruppo di selezione
self.entitySet.subtract(dimEntitySet)
self.showMsgOnAddRemove(dimEntitySet.count())
else:
self.showMsgOnAddRemove(1)
self.entitySet.selectOnLayer(False) # incremental = False
self.lastEntitySet.clear()
self.lastEntitySet.addEntity(entity)
#============================================================================
# elaborateSelSet
#============================================================================
def elaborateSelSet(self, selSet, shiftKey):
if self.AddOnSelection == True: # aggiungi al gruppo di selezione
if shiftKey: # se la selezione é avvenuta con shift premuto
if self.pickAdd == 0: # The objects most recently selected become the selection set
# verifico se ci sono degli oggetti non ancora selezionati
intersectSS = QadEntitySet(selSet)
intersectSS.subtract(self.entitySet)
if intersectSS.isEmpty(): # tutti gli oggetti erano già selezionati
self.AddRemoveSelSet(selSet, False) # rimuovo il gruppo di selezione
else:
self.AddRemoveSelSet(selSet, True) # aggiungo il gruppo di selezione
else:
self.AddRemoveSelSet(selSet, False) # rimuovo il gruppo di selezione
else: # senza tasto shift
if self.pickAdd == 0: # The objects most recently selected become the selection set
self.SetSelSet(selSet)
else:
self.AddRemoveSelSet(selSet, True) # aggiungo il gruppo di selezione
else: # se si deve rimuovere dal gruppo di selezione
self.AddRemoveEntity(selSet, False) # rimuovo il gruppo di selezione
#============================================================================
# SetSelSet
#============================================================================
def SetSelSet(self, selSet):
for layerEntitySet in self.entitySet.layerEntitySetList:
# se il layer non é presente in selSet
if selSet.findLayerEntitySet(layerEntitySet) is None:
layerEntitySet.deselectOnLayer()
else:
layerEntitySet.deselectOnLayer()
self.entitySet.set(selSet)
if self.checkDimLayers == True:
dimEntitySet = QadEntitySet(selSet)
# La funzione verifica se le entità che fanno parte di un entitySet sono anche parte di quotatura e,
# in caso affermativo, aggiunge tutti i componenti delle quotature all'entitySet.
QadDimStyles.addAllDimComponentsToEntitySet(dimEntitySet, self.onlyEditableLayers)
self.entitySet.unite(dimEntitySet)
self.showMsgOnAddRemove(self.entitySet.count())
self.entitySet.selectOnLayer(False) # incremental = False
self.lastEntitySet.set(selSet)
#============================================================================
# AddCurrentQgsSelectedFeatures
#============================================================================
def AddCurrentQgsSelectedFeatures(self):
# verifico se ci sono entità correntemente selezionate
self.entitySet.initByCurrentQgsSelectedFeatures(self.getLayersToCheck())
found = self.entitySet.count()
if found > 0:
msg = QadMsg.translate("Command_SSGET", "\nfound {0}")
self.showMsg(msg.format(found), False) # non ripete il prompt
return True
else:
return False
#============================================================================
# AddRemoveSelSet
#============================================================================
def AddRemoveSelSet(self, selSet, Add):
self.entitySet.deselectOnLayer()
if Add == True: # aggiungi al gruppo di selezione
self.entitySet.unite(selSet)
else: # rimuovi dal gruppo di selezione
self.entitySet.subtract(selSet)
self.showMsgOnAddRemove(selSet.count())
self.entitySet.selectOnLayer(False) # incremental = False
self.lastEntitySet.set(selSet)
#============================================================================
# AddRemoveSelSetByFence
#============================================================================
def AddRemoveSelSetByFence(self, points):
if len(points) > 1:
selSet = qad_utils.getSelSet("F", self.getPointMapTool(), points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
#============================================================================
# AddRemoveSelSetByPolygon
#============================================================================
def AddRemoveSelSetByPolygon(self, mode, points):
if len(points) > 2:
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
#============================================================================
# AddRemoveSelSetByGeometry
#============================================================================
def AddRemoveSelSetByGeometry(self, mode, geom):
if type(geom) == QgsGeometry: # singola geometria
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), geom, \
self.getLayersToCheck())
else: # lista di geometrie
selSet = QadEntitySet()
for g in geom:
partial = qad_utils.getSelSet(mode, self.getPointMapTool(), g, \
self.getLayersToCheck())
selSet.unite(partial)
self.elaborateSelSet(selSet, False)
#============================================================================
# WaitForFirstPoint
#============================================================================
def WaitForFirstPoint(self):
self.step = 1
# "Finestra" "Ultimo" "Interseca"
# "Riquadro" "Tutto" "iNTercetta"
# "FPoligono" "IPoligono"
# "FCerchio" "ICerchio"
# "FOggetti" "IOggetti"
# "FBuffer" "IBuffer"
# "AGgiungi" "Elimina"
# "Precedente" "Annulla"
# "AUto" "SIngolo" "Help"
keyWords = QadMsg.translate("Command_SSGET", "Window") + "/" + \
QadMsg.translate("Command_SSGET", "Last") + "/" + \
QadMsg.translate("Command_SSGET", "Crossing") + "/" + \
QadMsg.translate("Command_SSGET", "Box") + "/" + \
QadMsg.translate("Command_SSGET", "All") + "/" + \
QadMsg.translate("Command_SSGET", "Fence") + "/" + \
QadMsg.translate("Command_SSGET", "WPolygon") + "/" + \
QadMsg.translate("Command_SSGET", "CPolygon") + "/" + \
QadMsg.translate("Command_SSGET", "WCircle") + "/" + \
QadMsg.translate("Command_SSGET", "CCircle") + "/" + \
QadMsg.translate("Command_SSGET", "WObjects") + "/" + \
QadMsg.translate("Command_SSGET", "CObjects") + "/" + \
QadMsg.translate("Command_SSGET", "WBuffer") + "/" + \
QadMsg.translate("Command_SSGET", "CBuffer") + "/" + \
QadMsg.translate("Command_SSGET", "Add") + "/" + \
QadMsg.translate("Command_SSGET", "Remove") + "/" + \
QadMsg.translate("Command_SSGET", "Previous") + "/" + \
QadMsg.translate("Command_SSGET", "Undo") + "/" + \
QadMsg.translate("Command_SSGET", "AUto") + "/" + \
QadMsg.translate("Command_SSGET", "SIngle") + "/" + \
QadMsg.translate("Command_SSGET", "Help")
englishKeyWords = "Window" + "/" + "Last" + "/" + "Crossing" + "/" + "Box" + "/" \
+ "All" + "/" + "Fence" + "/" + "WPolygon" + "/" + "CPolygon" + "/" \
+ "WCircle" + "/" + "CCircle" + "/" + "WObjects" + "/" + "CObjects" + "/" \
+ "WBuffer" + "/" + "CBuffer" + "/" + "Add" + "/" + "Remove" + "/" \
+ "Previous" + "/" + "Undo" + "/" + "AUto" + "/" + "SIngle" + "/" + "Help"
if self.AddOnSelection == True:
prompt = QadMsg.translate("Command_SSGET", "Select Objects")
else:
prompt = QadMsg.translate("Command_SSGET", "Remove objects")
if self.help == True:
prompt = prompt + QadMsg.translate("Command_SSGET", " or [{0}]").format(keyWords)
prompt = prompt + QadMsg.translate("Command_SSGET", ": ")
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# imposto i layer da controllare sul maptool
self.getPointMapTool().layersToCheck = self.getLayersToCheck()
self.points = []
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
def run(self, msgMapTool = False, msg = None):
# ritorna:
# True per selezione non terminata
# False per selezione terminata
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 # errore
#=========================================================================
# RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
if self.step == 0:
# if you can also select objects before you start a command
if QadVariables.get(QadMsg.translate("Environment variables", "PICKFIRST")) == 1:
if self.AddCurrentQgsSelectedFeatures() == True:
self.plugIn.setLastEntitySet(self.entitySet)
return True;
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
elif self.step == 1: # dopo aver atteso un punto o enter 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
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False # continua
shiftKey = self.getPointMapTool().shiftKey
# se é stata selezionata un'entità
if self.getPointMapTool().entity.isInitialized():
value = self.getPointMapTool().entity
else:
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if value is None:
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if type(value) == unicode:
self.currSelectionMode = value
if value == QadMsg.translate("Command_SSGET", "Window") or value == "Window" or \
value == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
# "Finestra" = Seleziona tutti gli oggetti che si trovano completamente all'interno di un rettangolo definito da due punti
# "Interseca" = Seleziona gli oggetti che intersecano o si trovano all'interno di un'area definita da due punti
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
if value == QadMsg.translate("Command_SSGET", "Last") or value == "Last":
# Seleziona l'ultima entità inserita
if self.plugIn.getLastEntity() is None:
self.showMsgOnAddRemove(0)
else:
self.AddRemoveEntity(self.plugIn.getLastEntity(), self.AddOnSelection)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Box") or value == "Box":
# Seleziona tutti gli oggetti che intersecano o si trovano all'interno di un rettangolo specificato da due punti.
# Se i punti del rettangolo sono specificati da destra a sinistra, Riquadro equivale ad Interseca,
# altrimenti é equivalente a Finestra
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
elif value == QadMsg.translate("Command_SSGET", "All") or value == "All":
# Seleziona tutti gli oggetti
selSet = qad_utils.getSelSet("X", self.getPointMapTool(), None, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Fence") or value == "Fence":
# Seleziona tutti gli oggetti che intersecano una polilinea
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 = 4
elif value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon" or \
value == QadMsg.translate("Command_SSGET", "CPolygon") or value == "CPolygon":
# "FPoligono" = Seleziona oggetti che si trovano completamente all'interno di un poligono definito da punti
# "IPoligono" = Seleziona gli oggetti che intersecano o si trovano all'interno di un poligono definito specificando dei punti
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon":
self.MPOLYGONCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MPOLYGONCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 7
elif value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle" or \
value == QadMsg.translate("Command_SSGET", "CCircle") or value == "CCircle":
# "FCerchio" = Seleziona oggetti che si trovano completamente all'interno di un cerchio
# "ICerchio" = Seleziona oggetti che intersecano o si trovano all'interno di un cerchio
self.CIRCLECommand = QadCIRCLECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.CIRCLECommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle":
self.CIRCLECommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.CIRCLECommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.CIRCLECommand.run(msgMapTool, msg)
self.step = 5
elif value == QadMsg.translate("Command_SSGET", "WObjects") or value == "WObjects" or \
value == QadMsg.translate("Command_SSGET", "CObjects") or value == "CObjects":
# "FOggetti" = Seleziona oggetti che si trovano completamente all'interno di oggetti da selezionare
# "IOggetti" = Seleziona oggetti che intersecano o si trovano all'interno di oggetti da selezionare
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.run(msgMapTool, msg)
self.step = 6
elif value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer" or \
value == QadMsg.translate("Command_SSGET", "CBuffer") or value == "CBuffer":
# ho dovuto spostare questo import perché qad_mbuffer_cmd fa l'import di qad_ssget_cmd
from qad_mbuffer_cmd import QadMBUFFERCommandClass
# "FBuffer" = Seleziona oggetti che si trovano completamente all'interno di buffer intorno ad oggetti da selezionare
# "IBuffer" = Seleziona oggetti che intersecano o si trovano all'interno di buffer intorno ad oggetti da selezionare
self.MBUFFERCommand = QadMBUFFERCommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.MBUFFERCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer":
self.MBUFFERCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MBUFFERCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MBUFFERCommand.run(msgMapTool, msg)
self.step = 8
elif value == QadMsg.translate("Command_SSGET", "Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Previous") or value == "Previous":
# Seleziona il gruppo di selezione più recente
if self.plugIn.lastEntitySet is None:
self.showMsgOnAddRemove(0)
else:
entitySet = QadEntitySet()
entitySet.set(self.plugIn.lastEntitySet)
# controllo sul layer
if self.onlyEditableLayers == True:
entitySet.removeNotEditable()
# controllo sul tipo
if self.checkPointLayer == False:
entitySet.removeGeomType(QGis.Point)
if self.checkLineLayer == False:
entitySet.removeGeomType(QGis.Line)
if self.checkPolygonLayer == False:
entitySet.removeGeomType(QGis.Polygon)
# controllo sulle quotature
if self.checkDimLayers == False:
QadDimStyles.removeAllDimLayersFromEntitySet(entitySet)
entitySet.removeNotExisting()
self.elaborateSelSet(entitySet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Undo") or value == "Undo":
# Annulla la selezione dell'oggetto aggiunto più recentemente al gruppo di selezione.
# Inverto il tipo di selezione
prevAddOnSelection = self.AddOnSelection
self.AddOnSelection = not self.AddOnSelection
self.elaborateSelSet(self.lastEntitySet, False)
# Ripristino il tipo di selezione
self.AddOnSelection = prevAddOnSelection
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "AUto") or value == "AUto":
# Passa alla selezione automatica: vengono selezionati gli oggetti sui quali si posiziona il puntatore.
# Facendo clic su un'area vuota all'interno o all'esterno di un oggetto,
# si crea il primo angolo di un rettangolo di selezione, come per il metodo Riquadro
self.SingleSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "SIngle") or value == "SIngle":
# Passa al metodo Singolo: viene selezionato il primo oggetto o gruppo di oggetti indicato,
# senza che vengano richieste altre selezioni.
self.SingleSelection = True
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Help") or value == "Help":
self.help = True
self.WaitForFirstPoint()
elif type(value) == QgsPoint: # se é stato inserito il punto iniziale del rettangolo
self.currSelectionMode = QadMsg.translate("Command_SSGET", "Box")
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else: # se é stata selezionata un'entità
self.elaborateEntity(value, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DEL RETTANGOLO DA OPZIONE
# FINESTRA, INTERSECA, RIQUADRO (da step = 1)
elif self.step == 2: # 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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False
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) == QgsPoint:
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
# cambio il colore impostato da setDrawMode
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or value == "Window":
self.getPointMapTool().rectangleCrossingSelectionColor = self.getPointMapTool().rectangleWindowSelectionColor
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
self.getPointMapTool().rectangleWindowSelectionColor = self.getPointMapTool().rectangleCrossingSelectionColor
self.rectangleCrossingSelectionColor = getColorForCrossingSelectionArea()
self.rectangleWindowSelectionColor = getColorForWindowSelectionArea()
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DEL RETTANGOLO (da step = 1)
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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.getPointMapTool().clear()
self.points.append(value)
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Box") or \
self.currSelectionMode == "Box":
if self.points[0].x() < value.x():
mode = "W"
else:
mode = "C"
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or \
self.currSelectionMode == "Window":
mode = "W"
else: # "Interseca"
mode = "C"
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), self.points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' INTERCETTA (da step = 1 o 4)
elif self.step == 4: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.AddRemoveSelSetByFence(self.PLINECommand.vertices)
del self.PLINECommand
self.PLINECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FCERCHIO e ICERCHIO (da step = 1 o 5)
elif self.step == 5: # dopo aver atteso un punto si riavvia il comando
if self.CIRCLECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if (self.CIRCLECommand.centerPt is not None) and \
(self.CIRCLECommand.radius is not None):
circle = QadCircle()
circle.set(self.CIRCLECommand.centerPt, self.CIRCLECommand.radius)
points = circle.asPolyline()
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WCircle") or \
self.currSelectionMode == "WCircle":
self.AddRemoveSelSetByPolygon("WP", points)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CCircle") or \
self.currSelectionMode == "CCircle":
self.AddRemoveSelSetByPolygon("CP", points)
del self.CIRCLECommand
self.CIRCLECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FOGGETTI e IOGGETTI (da step = 1 o 6)
elif self.step == 6: # dopo aver atteso un punto si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
self.showMsg("\n")
destCRS = self.SSGetClass.getPointMapTool().canvas.mapRenderer().destinationCrs()
geoms = self.SSGetClass.entitySet.getGeometryCollection(destCRS) # trasformo la geometria
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WObjects") or \
self.currSelectionMode == "WObjects":
self.AddRemoveSelSetByGeometry("WO", geoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CObjects") or \
self.currSelectionMode == "CObjects":
self.AddRemoveSelSetByGeometry("CO", geoms)
del self.SSGetClass
self.SSGetClass = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FPOLIGONO e IPOLIGONO (da step = 1 o 7)
elif self.step == 7: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WPolygon") or \
self.currSelectionMode == "WPolygon":
self.AddRemoveSelSetByPolygon("WP", self.MPOLYGONCommand.vertices)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CPolygon") or \
self.currSelectionMode == "CPolygon":
self.AddRemoveSelSetByPolygon("CP", self.MPOLYGONCommand.vertices)
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FBUFFER e IBUFFER (da step = 1 o 8)
elif self.step == 8: # dopo aver atteso un punto si riavvia il comando
if self.MBUFFERCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
bufferGeoms = []
for layerEntitySet in self.MBUFFERCommand.entitySet.layerEntitySetList:
geoms = layerEntitySet.getGeometryCollection()
width = qad_utils.distMapToLayerCoordinates(self.MBUFFERCommand.width, \
self.MBUFFERCommand.getPointMapTool().canvas,\
layerEntitySet.layer)
for geom in geoms:
bufferGeoms.append(geom.buffer(width, self.MBUFFERCommand.segments))
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WBuffer") or \
self.currSelectionMode == "WBuffer":
self.AddRemoveSelSetByGeometry("WO", bufferGeoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CBuffer") or \
self.currSelectionMode == "CBuffer":
self.AddRemoveSelSetByGeometry("CO", bufferGeoms)
del self.MBUFFERCommand
self.MBUFFERCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
def run(self, msgMapTool = False, msg = None):
# ritorna:
# True per selezione non terminata
# False per selezione terminata
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 # errore
#=========================================================================
# RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
if self.step == 0:
# if you can also select objects before you start a command
if QadVariables.get(QadMsg.translate("Environment variables", "PICKFIRST")) == 1:
if self.AddCurrentQgsSelectedFeatures() == True:
self.plugIn.setLastEntitySet(self.entitySet)
return True;
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
elif self.step == 1: # dopo aver atteso un punto o enter 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
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False # continua
shiftKey = self.getPointMapTool().shiftKey
# se é stata selezionata un'entità
if self.getPointMapTool().entity.isInitialized():
value = self.getPointMapTool().entity
else:
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if value is None:
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if type(value) == unicode:
self.currSelectionMode = value
if value == QadMsg.translate("Command_SSGET", "Window") or value == "Window" or \
value == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
# "Finestra" = Seleziona tutti gli oggetti che si trovano completamente all'interno di un rettangolo definito da due punti
# "Interseca" = Seleziona gli oggetti che intersecano o si trovano all'interno di un'area definita da due punti
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
if value == QadMsg.translate("Command_SSGET", "Last") or value == "Last":
# Seleziona l'ultima entità inserita
if self.plugIn.getLastEntity() is None:
self.showMsgOnAddRemove(0)
else:
self.AddRemoveEntity(self.plugIn.getLastEntity(), self.AddOnSelection)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Box") or value == "Box":
# Seleziona tutti gli oggetti che intersecano o si trovano all'interno di un rettangolo specificato da due punti.
# Se i punti del rettangolo sono specificati da destra a sinistra, Riquadro equivale ad Interseca,
# altrimenti é equivalente a Finestra
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "First corner: "))
self.step = 2
elif value == QadMsg.translate("Command_SSGET", "All") or value == "All":
# Seleziona tutti gli oggetti
selSet = qad_utils.getSelSet("X", self.getPointMapTool(), None, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Fence") or value == "Fence":
# Seleziona tutti gli oggetti che intersecano una polilinea
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 = 4
elif value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon" or \
value == QadMsg.translate("Command_SSGET", "CPolygon") or value == "CPolygon":
# "FPoligono" = Seleziona oggetti che si trovano completamente all'interno di un poligono definito da punti
# "IPoligono" = Seleziona gli oggetti che intersecano o si trovano all'interno di un poligono definito specificando dei punti
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WPolygon") or value == "WPolygon":
self.MPOLYGONCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MPOLYGONCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 7
elif value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle" or \
value == QadMsg.translate("Command_SSGET", "CCircle") or value == "CCircle":
# "FCerchio" = Seleziona oggetti che si trovano completamente all'interno di un cerchio
# "ICerchio" = Seleziona oggetti che intersecano o si trovano all'interno di un cerchio
self.CIRCLECommand = QadCIRCLECommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.CIRCLECommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WCircle") or value == "WCircle":
self.CIRCLECommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.CIRCLECommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.CIRCLECommand.run(msgMapTool, msg)
self.step = 5
elif value == QadMsg.translate("Command_SSGET", "WObjects") or value == "WObjects" or \
value == QadMsg.translate("Command_SSGET", "CObjects") or value == "CObjects":
# "FOggetti" = Seleziona oggetti che si trovano completamente all'interno di oggetti da selezionare
# "IOggetti" = Seleziona oggetti che intersecano o si trovano all'interno di oggetti da selezionare
self.SSGetClass = QadSSGetClass(self.plugIn)
self.SSGetClass.run(msgMapTool, msg)
self.step = 6
elif value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer" or \
value == QadMsg.translate("Command_SSGET", "CBuffer") or value == "CBuffer":
# ho dovuto spostare questo import perché qad_mbuffer_cmd fa l'import di qad_ssget_cmd
from qad_mbuffer_cmd import QadMBUFFERCommandClass
# "FBuffer" = Seleziona oggetti che si trovano completamente all'interno di buffer intorno ad oggetti da selezionare
# "IBuffer" = Seleziona oggetti che intersecano o si trovano all'interno di buffer intorno ad oggetti da selezionare
self.MBUFFERCommand = QadMBUFFERCommandClass(self.plugIn)
# se questo flag = True il comando serve all'interno di un altro comando per disegnare un cerchio
# che non verrà salvata su un layer
self.MBUFFERCommand.virtualCmd = True
if value == QadMsg.translate("Command_SSGET", "WBuffer") or value == "WBuffer":
self.MBUFFERCommand.setRubberBandColor(None, getColorForWindowSelectionArea())
else:
self.MBUFFERCommand.setRubberBandColor(None, getColorForCrossingSelectionArea())
self.MBUFFERCommand.run(msgMapTool, msg)
self.step = 8
elif value == QadMsg.translate("Command_SSGET", "Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Previous") or value == "Previous":
# Seleziona il gruppo di selezione più recente
if self.plugIn.lastEntitySet is None:
self.showMsgOnAddRemove(0)
else:
entitySet = QadEntitySet()
entitySet.set(self.plugIn.lastEntitySet)
# controllo sul layer
if self.onlyEditableLayers == True:
entitySet.removeNotEditable()
# controllo sul tipo
if self.checkPointLayer == False:
entitySet.removeGeomType(QGis.Point)
if self.checkLineLayer == False:
entitySet.removeGeomType(QGis.Line)
if self.checkPolygonLayer == False:
entitySet.removeGeomType(QGis.Polygon)
# controllo sulle quotature
if self.checkDimLayers == False:
QadDimStyles.removeAllDimLayersFromEntitySet(entitySet)
entitySet.removeNotExisting()
self.elaborateSelSet(entitySet, False)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Undo") or value == "Undo":
# Annulla la selezione dell'oggetto aggiunto più recentemente al gruppo di selezione.
# Inverto il tipo di selezione
prevAddOnSelection = self.AddOnSelection
self.AddOnSelection = not self.AddOnSelection
self.elaborateSelSet(self.lastEntitySet, False)
# Ripristino il tipo di selezione
self.AddOnSelection = prevAddOnSelection
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "AUto") or value == "AUto":
# Passa alla selezione automatica: vengono selezionati gli oggetti sui quali si posiziona il puntatore.
# Facendo clic su un'area vuota all'interno o all'esterno di un oggetto,
# si crea il primo angolo di un rettangolo di selezione, come per il metodo Riquadro
self.SingleSelection = False
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "SIngle") or value == "SIngle":
# Passa al metodo Singolo: viene selezionato il primo oggetto o gruppo di oggetti indicato,
# senza che vengano richieste altre selezioni.
self.SingleSelection = True
if self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
self.WaitForFirstPoint()
elif value == QadMsg.translate("Command_SSGET", "Help") or value == "Help":
self.help = True
self.WaitForFirstPoint()
elif type(value) == QgsPoint: # se é stato inserito il punto iniziale del rettangolo
self.currSelectionMode = QadMsg.translate("Command_SSGET", "Box")
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else: # se é stata selezionata un'entità
self.elaborateEntity(value, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DEL RETTANGOLO DA OPZIONE
# FINESTRA, INTERSECA, RIQUADRO (da step = 1)
elif self.step == 2: # 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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False
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) == QgsPoint:
self.points.append(value)
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITYSET_SELECTION)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.ELASTIC_RECTANGLE)
# cambio il colore impostato da setDrawMode
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or value == "Window":
self.getPointMapTool().rectangleCrossingSelectionColor = self.getPointMapTool().rectangleWindowSelectionColor
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Crossing") or value == "Crossing":
self.getPointMapTool().rectangleWindowSelectionColor = self.getPointMapTool().rectangleCrossingSelectionColor
self.rectangleCrossingSelectionColor = getColorForCrossingSelectionArea()
self.rectangleWindowSelectionColor = getColorForWindowSelectionArea()
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
self.step = 3
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
self.WaitForFirstPoint()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DEL RETTANGOLO (da step = 1)
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
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.getPointMapTool().clear()
self.points.append(value)
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "Box") or \
self.currSelectionMode == "Box":
if self.points[0].x() < value.x():
mode = "W"
else:
mode = "C"
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "Window") or \
self.currSelectionMode == "Window":
mode = "W"
else: # "Interseca"
mode = "C"
selSet = qad_utils.getSelSet(mode, self.getPointMapTool(), self.points, \
self.getLayersToCheck())
self.elaborateSelSet(selSet, shiftKey)
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
else:
self.showMsg(QadMsg.translate("Command_SSGET", "Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_SSGET", "Specify opposite corner: "))
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' INTERCETTA (da step = 1 o 4)
elif self.step == 4: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
self.AddRemoveSelSetByFence(self.PLINECommand.vertices)
del self.PLINECommand
self.PLINECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FCERCHIO e ICERCHIO (da step = 1 o 5)
elif self.step == 5: # dopo aver atteso un punto si riavvia il comando
if self.CIRCLECommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if (self.CIRCLECommand.centerPt is not None) and \
(self.CIRCLECommand.radius is not None):
circle = QadCircle()
circle.set(self.CIRCLECommand.centerPt, self.CIRCLECommand.radius)
points = circle.asPolyline()
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WCircle") or \
self.currSelectionMode == "WCircle":
self.AddRemoveSelSetByPolygon("WP", points)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CCircle") or \
self.currSelectionMode == "CCircle":
self.AddRemoveSelSetByPolygon("CP", points)
del self.CIRCLECommand
self.CIRCLECommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FOGGETTI e IOGGETTI (da step = 1 o 6)
elif self.step == 6: # dopo aver atteso un punto si riavvia il comando
if self.SSGetClass.run(msgMapTool, msg) == True:
self.showMsg("\n")
destCRS = self.SSGetClass.getPointMapTool().canvas.mapRenderer().destinationCrs()
geoms = self.SSGetClass.entitySet.getGeometryCollection(destCRS) # trasformo la geometria
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WObjects") or \
self.currSelectionMode == "WObjects":
self.AddRemoveSelSetByGeometry("WO", geoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CObjects") or \
self.currSelectionMode == "CObjects":
self.AddRemoveSelSetByGeometry("CO", geoms)
del self.SSGetClass
self.SSGetClass = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PER MODALITA' FPOLIGONO e IPOLIGONO (da step = 1 o 7)
elif self.step == 7: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WPolygon") or \
self.currSelectionMode == "WPolygon":
self.AddRemoveSelSetByPolygon("WP", self.MPOLYGONCommand.vertices)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CPolygon") or \
self.currSelectionMode == "CPolygon":
self.AddRemoveSelSetByPolygon("CP", self.MPOLYGONCommand.vertices)
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI SELEZIONE DI OGGETTI PER MODALITA' FBUFFER e IBUFFER (da step = 1 o 8)
elif self.step == 8: # dopo aver atteso un punto si riavvia il comando
if self.MBUFFERCommand.run(msgMapTool, msg) == True:
self.showMsg("\n")
bufferGeoms = []
for layerEntitySet in self.MBUFFERCommand.entitySet.layerEntitySetList:
geoms = layerEntitySet.getGeometryCollection()
width = qad_utils.distMapToLayerCoordinates(self.MBUFFERCommand.width, \
self.MBUFFERCommand.getPointMapTool().canvas,\
layerEntitySet.layer)
for geom in geoms:
bufferGeoms.append(geom.buffer(width, self.MBUFFERCommand.segments))
if self.currSelectionMode == QadMsg.translate("Command_SSGET", "WBuffer") or \
self.currSelectionMode == "WBuffer":
self.AddRemoveSelSetByGeometry("WO", bufferGeoms)
elif self.currSelectionMode == QadMsg.translate("Command_SSGET", "CBuffer") or \
self.currSelectionMode == "CBuffer":
self.AddRemoveSelSetByGeometry("CO", bufferGeoms)
del self.MBUFFERCommand
self.MBUFFERCommand = None
if self.SingleSelection == True and self.entitySet.count() > 0:
self.plugIn.setLastEntitySet(self.entitySet)
return True # fine
if self.exitAfterSelection == True:
return True # fine
self.WaitForFirstPoint()
return False
class QadSTRETCHCommandClass(QadCommandClass):
def instantiateNewCmd(self):
""" istanzia un nuovo comando dello stesso tipo """
return QadSTRETCHCommandClass(self.plugIn)
def getName(self):
return QadMsg.translate("Command_list", "STRETCH")
def getEnglishName(self):
return "STRETCH"
def connectQAction(self, action):
QObject.connect(action, SIGNAL("triggered()"),
self.plugIn.runSTRETCHCommand)
def getIcon(self):
return QIcon(":/plugins/qad/icons/stretch.png")
def getNote(self):
# impostare le note esplicative del comando
return QadMsg.translate("Command_STRETCH", "Stretches objects.")
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.AddOnSelection = True # se = False significa remove
self.points = []
self.MPOLYGONCommand = None
self.SSGeomList = [
] # lista di entità da stirare con geom di selezione
self.basePt = QgsPoint()
def __del__(self):
QadCommandClass.__del__(self)
if self.MPOLYGONCommand is not None:
del self.MPOLYGONCommand
for SSGeom in self.SSGeomList:
SSGeom[0].deselectOnLayer()
def getPointMapTool(self, drawMode=QadGetPointDrawModeEnum.NONE):
if self.step == 2: # quando si é in fase di disegno linea
return self.MPOLYGONCommand.getPointMapTool(drawMode)
else:
if (self.plugIn is not None):
if self.PointMapTool is None:
self.PointMapTool = Qad_stretch_maptool(self.plugIn)
return self.PointMapTool
else:
return None
def stretch(self, entity, containerGeom, offSetX, offSetY,
tolerance2ApproxCurve):
# entity = entità da stirare
# ptList = lista dei punti da stirare
# offSetX, offSetY = spostamento da fare
# tolerance2ApproxCurve = tolleranza per ricreare le curve
# verifico se l'entità appartiene ad uno stile di quotatura
if entity.whatIs() == "ENTITY":
stretchedGeom = entity.getGeometry()
# controllo inserito perchè con le quote, questa viene cancellata e ricreata quindi alcuni oggetti potrebbero non esistere più
if stretchedGeom is None: # se non c'è lo salto senza errore
return True
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
coordTransform = QgsCoordinateTransform(
entity.layer.crs(),
self.plugIn.canvas.mapRenderer().destinationCrs())
stretchedGeom.transform(coordTransform)
# stiro la feature
stretchedGeom = qad_stretch_fun.stretchQgsGeometry(stretchedGeom, containerGeom, \
offSetX, offSetY, \
tolerance2ApproxCurve)
if stretchedGeom is not None:
# trasformo la geometria nel crs del layer
coordTransform = QgsCoordinateTransform(
self.plugIn.canvas.mapRenderer().destinationCrs(),
entity.layer.crs())
stretchedGeom.transform(coordTransform)
f = entity.getFeature()
f.setGeometry(stretchedGeom)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, entity.layer, f,
False, False) == False:
return False
elif entity.whatIs() == "DIMENTITY":
# stiro la quota
if entity.deleteToLayers(self.plugIn) == False:
return False
entity.stretch(self.plugIn, containerGeom, offSetX, offSetY)
if entity.addToLayers(self.plugIn) == False:
return False
return True
#============================================================================
# stretchFeatures
#============================================================================
def stretchFeatures(self, newPt):
# mi ricavo un unico QadEntitySet con le entità selezionate
entitySet = QadEntitySet()
for SSGeom in self.SSGeomList:
entitySet.unite(SSGeom[0])
self.plugIn.beginEditCommand("Feature stretched",
entitySet.getLayerList())
dimElaboratedList = [] # lista delle quotature già elaborate
tolerance2ApproxCurve = QadVariables.get(
QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
offSetX = newPt.x() - self.basePt.x()
offSetY = newPt.y() - self.basePt.y()
entity = QadEntity()
for SSGeom in self.SSGeomList:
# copio entitySet
entitySet = QadEntitySet(SSGeom[0])
geomSel = SSGeom[1]
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
# verifico se l'entità appartiene ad uno stile di quotatura
dimEntity = QadDimStyles.getDimEntity(entity)
if dimEntity is None:
if self.stretch(entity, geomSel, offSetX, offSetY,
tolerance2ApproxCurve) == False:
self.plugIn.destroyEditCommand()
return
else:
found = False
for dimElaborated in dimElaboratedList:
if dimElaborated == dimEntity:
found = True
if found == False: # quota non ancora elaborata
dimElaboratedList.append(dimEntity)
if self.stretch(dimEntity, geomSel, offSetX,
offSetY,
tolerance2ApproxCurve) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
#============================================================================
# setEntitySetGeom
#============================================================================
def setEntitySetGeom(self, entitySet, selGeom):
for SSGeom in self.SSGeomList:
SSGeom[0].deselectOnLayer()
del self.SSGeomList[:] # svuoto la lista
# aggiuge il gruppo di selezione con la geometria usata per la selezione
self.SSGeomList.append([entitySet, selGeom])
entitySet.selectOnLayer(False) # incremental = False
#============================================================================
# addEntitySetGeom
#============================================================================
def addEntitySetGeom(self, entitySet, selGeom):
# elimino dai gruppi precedenti gli oggetti presenti in entitySet
self.removeEntitySet(entitySet)
# aggiuge il gruppo di selezione con la geometria usata per la selezione
self.SSGeomList.append([entitySet, selGeom])
entitySet.selectOnLayer(True) # incremental = True
#============================================================================
# removeEntitySet
#============================================================================
def removeEntitySet(self, entitySet):
# elimino dai gruppi precedenti gli oggetti presenti in entitySet
for SSGeom in self.SSGeomList:
SSGeom[0].subtract(entitySet)
for SSGeom in self.SSGeomList:
SSGeom[0].selectOnLayer(False) # incremental = False
#============================================================================
# SSGeomListIsEmpty
#============================================================================
def SSGeomListIsEmpty(self):
if len(self.SSGeomList) == 0:
return True
for SSGeom in self.SSGeomList:
if SSGeom[0].isEmpty() == False:
return False
return True
#============================================================================
# waitForObjectSel
#============================================================================
def waitForObjectSel(self):
self.step = 1
# imposto il map tool
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.ASK_FOR_FIRST_PT_RECTANGLE)
keyWords = QadMsg.translate("Command_STRETCH", "Polygon") + "/" + \
QadMsg.translate("Command_STRETCH", "Add") + "/" + \
QadMsg.translate("Command_STRETCH", "Remove")
if self.AddOnSelection == True:
prompt = QadMsg.translate("Command_STRETCH", "Select vertices")
else:
prompt = QadMsg.translate("Command_STRETCH", "Remove vertices")
prompt = prompt + QadMsg.translate(
"Command_STRETCH",
" to stretch crossed by a selection window or [{0}]: ").format(
keyWords)
englishKeyWords = "Polygon" + "/" + "Add" + "/" + "Remove"
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)
#============================================================================
# waitForBasePt
#============================================================================
def waitForBasePt(self):
self.step = 4
# imposto il map tool
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_BASE_PT)
keyWords = QadMsg.translate("Command_STRETCH", "Displacement")
prompt = QadMsg.translate(
"Command_STRETCH",
"Specify base point or [{0}] <{0}>: ").format(keyWords)
englishKeyWords = "Displacement"
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)
#============================================================================
# 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
#=========================================================================
# RICHIESTA SELEZIONE OGGETTI
if self.step == 0: # inizio del comando
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE OGGETTI DA STIRARE
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
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 type(value) == unicode:
if value == QadMsg.translate("Command_STRETCH",
"Polygon") or value == "Polygon":
# Seleziona tutti gli oggetti che sono interni al poligono
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 2
return False
elif value == QadMsg.translate("Command_SSGET",
"Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
elif value == QadMsg.translate("Command_SSGET",
"Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
elif type(value) == QgsPoint: # se é stato selezionato un punto
del self.points[:] # svuoto la lista
self.points.append(value)
# imposto il map tool
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.
FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(
QadMsg.translate("Command_STRETCH",
"Specify opposite corner: "))
self.step = 3
return False
else:
if self.SSGeomListIsEmpty():
return True
# si appresta ad attendere il punto base o lo spostamento
self.waitForBasePt()
return False
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' POLIGONO (da step = 1)
elif self.step == 2: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
if len(self.MPOLYGONCommand.vertices) > 1:
# cerco tutte le geometrie intersecanti il poligono
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("CP", self.getPointMapTool(), self.MPOLYGONCommand.vertices, \
None, True, True, True, \
True)
# se la selezione é avvenuta con shift premuto o se si deve rimuovere il gruppo selSet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
self.setEntitySetGeom(
selSet,
QgsGeometry.fromPolygon(
[self.MPOLYGONCommand.vertices]))
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
self.getPointMapTool().refreshSnapType(
) # aggiorno lo snapType che può essere variato dal maptool di mpolygon
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' FINESTRA (da step = 1)
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
self.showMsg(
QadMsg.translate("Command_STRETCH",
"Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(
QadMsg.translate("Command_STRETCH",
"Specify opposite corner: "))
return False
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.points.append(value)
# cerco tutte le geometrie intersecanti il rettangolo
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("C", self.getPointMapTool(), self.points, \
None, True, True, True, \
True)
# se si deve rimuovere il gruppo entitySet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
if shiftKey: # se la selezione é avvenuta con shift premuto
self.addEntitySetGeom(
selSet,
QgsGeometry.fromRect(
QgsRectangle(self.points[0], self.points[1])))
else:
self.setEntitySetGeom(
selSet,
QgsGeometry.fromRect(
QgsRectangle(self.points[0], self.points[1])))
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO BASE (da step = 1)
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
pass # opzione di default "spostamento"
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
# imposto il map tool
self.getPointMapTool().SSGeomList = self.SSGeomList
if value is None or type(value) == unicode:
self.basePt.set(0, 0)
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto
msg = QadMsg.translate(
"Command_STRETCH",
"Specify the displacement from the origin point 0,0 <{0}, {1}>: "
)
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg.format(str(self.plugIn.lastOffsetPt.x()), str(self.plugIn.lastOffsetPt.y())), \
QadInputTypeEnum.POINT2D, \
self.plugIn.lastOffsetPt, \
"", QadInputModeEnum.NONE)
self.step = 5
elif type(value) == QgsPoint: # se é stato inserito il punto base
self.basePt.set(value.x(), value.y())
# imposto il map tool
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_STRETCH", "Specify second point or [Array] <use first point as displacement from origin point 0,0>: "), \
QadInputTypeEnum.POINT2D, \
None, \
"", QadInputModeEnum.NONE)
self.step = 6
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PUNTO DI SPOSTAMENTO (da step = 2)
elif self.step == 5: # 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
self.plugIn.setLastOffsetPt(value)
self.stretchFeatures(value)
return True # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER SPOSTAMENTO (da step = 2)
elif self.step == 6: # 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 value is None:
newPt = QgsPoint(self.basePt.x() * 2, self.basePt.y() * 2)
self.stretchFeatures(newPt)
elif type(
value
) == QgsPoint: # se é stato inserito lo spostamento con un punto
self.stretchFeatures(value)
return True # fine comando
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
#=========================================================================
# RICHIESTA SELEZIONE OGGETTI
if self.step == 0: # inizio del comando
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE OGGETTI DA STIRARE
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
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 type(value) == unicode:
if value == QadMsg.translate("Command_STRETCH",
"Polygon") or value == "Polygon":
# Seleziona tutti gli oggetti che sono interni al poligono
self.MPOLYGONCommand = QadMPOLYGONCommandClass(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.MPOLYGONCommand.virtualCmd = True
self.MPOLYGONCommand.run(msgMapTool, msg)
self.step = 2
return False
elif value == QadMsg.translate("Command_SSGET",
"Add") or value == "Add":
# Passa al metodo Aggiungi: gli oggetti selezionati possono essere aggiunti al gruppo di selezione
self.AddOnSelection = True
elif value == QadMsg.translate("Command_SSGET",
"Remove") or value == "Remove":
# Passa al metodo Rimuovi: gli oggetti possono essere rimossi dal gruppo di selezione
self.AddOnSelection = False
elif type(value) == QgsPoint: # se é stato selezionato un punto
del self.points[:] # svuoto la lista
self.points.append(value)
# imposto il map tool
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.
FIRST_PT_KNOWN_ASK_FOR_SECOND_PT_RECTANGLE)
self.getPointMapTool().setStartPoint(value)
# si appresta ad attendere un punto
self.waitForPoint(
QadMsg.translate("Command_STRETCH",
"Specify opposite corner: "))
self.step = 3
return False
else:
if self.SSGeomListIsEmpty():
return True
# si appresta ad attendere il punto base o lo spostamento
self.waitForBasePt()
return False
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' POLIGONO (da step = 1)
elif self.step == 2: # dopo aver atteso un punto si riavvia il comando
if self.MPOLYGONCommand.run(msgMapTool, msg) == True:
if len(self.MPOLYGONCommand.vertices) > 1:
# cerco tutte le geometrie intersecanti il poligono
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("CP", self.getPointMapTool(), self.MPOLYGONCommand.vertices, \
None, True, True, True, \
True)
# se la selezione é avvenuta con shift premuto o se si deve rimuovere il gruppo selSet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
self.setEntitySetGeom(
selSet,
QgsGeometry.fromPolygon(
[self.MPOLYGONCommand.vertices]))
del self.MPOLYGONCommand
self.MPOLYGONCommand = None
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
self.getPointMapTool().refreshSnapType(
) # aggiorno lo snapType che può essere variato dal maptool di mpolygon
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' FINESTRA (da step = 1)
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
self.showMsg(
QadMsg.translate("Command_STRETCH",
"Window not correct."))
# si appresta ad attendere un punto
self.waitForPoint(
QadMsg.translate("Command_STRETCH",
"Specify opposite corner: "))
return False
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
shiftKey = self.getPointMapTool().shiftKey
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
shiftKey = False
value = msg
if type(value) == QgsPoint:
self.points.append(value)
# cerco tutte le geometrie intersecanti il rettangolo
# e considerando solo layer editabili
selSet = qad_utils.getSelSet("C", self.getPointMapTool(), self.points, \
None, True, True, True, \
True)
# se si deve rimuovere il gruppo entitySet dal gruppo
if self.AddOnSelection == False:
self.removeEntitySet(selSet)
else:
if shiftKey: # se la selezione é avvenuta con shift premuto
self.addEntitySetGeom(
selSet,
QgsGeometry.fromRect(
QgsRectangle(self.points[0], self.points[1])))
else:
self.setEntitySetGeom(
selSet,
QgsGeometry.fromRect(
QgsRectangle(self.points[0], self.points[1])))
# si appresta ad attendere la selezione degli oggetti da stirare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO BASE (da step = 1)
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
pass # opzione di default "spostamento"
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
# imposto il map tool
self.getPointMapTool().SSGeomList = self.SSGeomList
if value is None or type(value) == unicode:
self.basePt.set(0, 0)
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto
msg = QadMsg.translate(
"Command_STRETCH",
"Specify the displacement from the origin point 0,0 <{0}, {1}>: "
)
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg.format(str(self.plugIn.lastOffsetPt.x()), str(self.plugIn.lastOffsetPt.y())), \
QadInputTypeEnum.POINT2D, \
self.plugIn.lastOffsetPt, \
"", QadInputModeEnum.NONE)
self.step = 5
elif type(value) == QgsPoint: # se é stato inserito il punto base
self.basePt.set(value.x(), value.y())
# imposto il map tool
self.getPointMapTool().basePt = self.basePt
self.getPointMapTool().setMode(
Qad_stretch_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_MOVE_PT)
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_STRETCH", "Specify second point or [Array] <use first point as displacement from origin point 0,0>: "), \
QadInputTypeEnum.POINT2D, \
None, \
"", QadInputModeEnum.NONE)
self.step = 6
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PUNTO DI SPOSTAMENTO (da step = 2)
elif self.step == 5: # 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
self.plugIn.setLastOffsetPt(value)
self.stretchFeatures(value)
return True # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER SPOSTAMENTO (da step = 2)
elif self.step == 6: # 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 value is None:
newPt = QgsPoint(self.basePt.x() * 2, self.basePt.y() * 2)
self.stretchFeatures(newPt)
elif type(
value
) == QgsPoint: # se é stato inserito lo spostamento con un punto
self.stretchFeatures(value)
return True # fine comando
def __init__(self, plugIn):
self.plugIn = plugIn
self.__cmdObjs = [] # lista interna degli oggetti comandi
self.__cmdObjs.append(QadIDCommandClass(self.plugIn)) # ID
self.__cmdObjs.append(QadSETVARCommandClass(self.plugIn)) # SETVAR
self.__cmdObjs.append(QadPLINECommandClass(self.plugIn)) # PLINE
self.__cmdObjs.append(QadSETCURRLAYERBYGRAPHCommandClass(
self.plugIn)) # SETCURRLAYERBYGRAPH
self.__cmdObjs.append(
QadSETCURRUPDATEABLELAYERBYGRAPHCommandClass(
self.plugIn)) # SETCURRUPDATEABLELAYERBYGRAPH
self.__cmdObjs.append(QadARCCommandClass(self.plugIn)) # ARC
self.__cmdObjs.append(QadCIRCLECommandClass(self.plugIn)) # CIRCLE
self.__cmdObjs.append(QadDSETTINGSCommandClass(
self.plugIn)) # DSETTINGS
self.__cmdObjs.append(QadLINECommandClass(self.plugIn)) # LINE
self.__cmdObjs.append(QadERASECommandClass(self.plugIn)) # ERASE
self.__cmdObjs.append(QadMPOLYGONCommandClass(self.plugIn)) # MPOLYGON
self.__cmdObjs.append(QadMBUFFERCommandClass(self.plugIn)) # MBUFFER
self.__cmdObjs.append(QadROTATECommandClass(self.plugIn)) # ROTATE
self.__cmdObjs.append(QadMOVECommandClass(self.plugIn)) # MOVE
self.__cmdObjs.append(QadSCALECommandClass(self.plugIn)) # SCALE
self.__cmdObjs.append(QadCOPYCommandClass(self.plugIn)) # COPY
self.__cmdObjs.append(QadOFFSETCommandClass(self.plugIn)) # OFFSET
self.__cmdObjs.append(QadEXTENDCommandClass(self.plugIn)) # EXTEND
self.__cmdObjs.append(QadTRIMCommandClass(self.plugIn)) # TRIM
self.__cmdObjs.append(QadRECTANGLECommandClass(
self.plugIn)) # RECTANGLE
self.__cmdObjs.append(QadMIRRORCommandClass(self.plugIn)) # MIRROR
self.__cmdObjs.append(QadUNDOCommandClass(self.plugIn)) # UNDO
self.__cmdObjs.append(QadREDOCommandClass(self.plugIn)) # REDO
self.__cmdObjs.append(QadINSERTCommandClass(self.plugIn)) # INSERT
self.__cmdObjs.append(QadTEXTCommandClass(self.plugIn)) # TEXT
self.__cmdObjs.append(QadSTRETCHCommandClass(self.plugIn)) # STRETCH
self.__cmdObjs.append(QadBREAKCommandClass(self.plugIn)) # BREAK
self.__cmdObjs.append(QadPEDITCommandClass(self.plugIn)) # PEDIT
self.__cmdObjs.append(QadFILLETCommandClass(self.plugIn)) # FILLET
self.__cmdObjs.append(QadPOLYGONCommandClass(self.plugIn)) # POLYGON
self.__cmdObjs.append(QadDIMLINEARCommandClass(
self.plugIn)) # DIMLINEAR
self.__cmdObjs.append(QadDIMALIGNEDCommandClass(
self.plugIn)) # DIMALIGNED
self.__cmdObjs.append(QadDIMARCCommandClass(self.plugIn)) # DIMALIGNED
self.__cmdObjs.append(QadDIMSTYLECommandClass(self.plugIn)) # DIMSTYLE
self.__cmdObjs.append(QadHELPCommandClass(self.plugIn)) # HELP
self.__cmdObjs.append(QadLENGTHENCommandClass(self.plugIn)) # LENGTHEN
self.__cmdObjs.append(QadOPTIONSCommandClass(self.plugIn)) # OPTIONS
self.__cmdObjs.append(QadMAPMPEDITCommandClass(
self.plugIn)) # MAPMEDIT
self.__cmdObjs.append(QadJOINCommandClass(self.plugIn)) # JOIN
self.__cmdObjs.append(QadDISJOINCommandClass(self.plugIn)) # DISJOIN
self.__cmdObjs.append(QadARRAYCommandClass(self.plugIn)) # ARRAY
self.__cmdObjs.append(QadARRAYRECTCommandClass(
self.plugIn)) # ARRAYRECT
self.__cmdObjs.append(QadARRAYPATHCommandClass(
self.plugIn)) # ARRAYPATH
self.__cmdObjs.append(QadARRAYPOLARCommandClass(
self.plugIn)) # ARRAYPOLAR
self.__cmdObjs.append(QadDIVIDECommandClass(self.plugIn)) # DIVIDE
self.__cmdObjs.append(QadMEASURECommandClass(self.plugIn)) # MEASURE
self.actualCommand = None # Comando in corso di esecuzione
# scarto gli alias che hanno lo stesso nome dei comandi
exceptionList = []
for cmdObj in self.__cmdObjs:
exceptionList.append(cmdObj.getName())
exceptionList.append("_" + cmdObj.getEnglishName())
# carico alias dei comandi
self.commandAliases = QadCommandAliasesClass()
self.commandAliases.load("", exceptionList)
self.usedCmdNames = QadUsedCmdNamesClass()