def elaborateSelSet(self, selSet, shiftKey):
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)
selSet.unite(dimEntitySet)
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
def setMode(self, mode):
self.mode = mode
# si richiede la selezione dell'oggetto da misurare
if self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_MISURE:
self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
# solo layer di tipo lineari che non appartengano a quote o di tipo poligono
layerList = []
for layer in self.plugIn.canvas.layers():
if layer.type() == QgsMapLayer.VectorLayer and \
layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon:
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.layersToCheck = layerList
self.onlyEditableLayers = False
self.setSnapType(QadSnapTypeEnum.DISABLE)
# si richiede il delta
elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DELTA:
self.OpMode = "DElta"
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
# non si richiede niente
elif self.mode == Qad_lengthen_maptool_ModeEnum.NONE:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
# si richiede la selezione dell'oggetto da allungare
elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_LENGTHEN:
self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)
# solo layer lineari editabili che non appartengano a quote
layerList = []
for layer in self.plugIn.canvas.layers():
if layer.type() == QgsMapLayer.VectorLayer and layer.geometryType() == QGis.Line and \
layer.isEditable():
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.layersToCheck = layerList
self.onlyEditableLayers = True
self.setSnapType(QadSnapTypeEnum.DISABLE)
# si richiede la percentuale
elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_PERCENT:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.OpMode = "Percent"
# si richiede il totale
elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_TOTAL:
self.OpMode = "Total"
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
# si richiede il nuovo punto dell'estremità in modalità dinamica
elif self.mode == Qad_lengthen_maptool_ModeEnum.ASK_FOR_DYNAMIC_POINT:
self.OpMode = "DYnamic"
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
def waitForObjectSel(self):
self.step = 2
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)
# solo layer lineari editabili che non appartengano a quote
layerList = []
for layer in qad_utils.getVisibleVectorLayers(self.plugIn.canvas): # Tutti i layer vettoriali visibili
if layer.geometryType() == QGis.Line and layer.isEditable():
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.getPointMapTool().layersToCheck = layerList
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
self.getPointMapTool().onlyEditableLayers = True
keyWords = QadMsg.translate("Command_TRIM", "Fence") + "/" + \
QadMsg.translate("Command_TRIM", "Crossing") + "/" + \
QadMsg.translate("Command_TRIM", "Edge") + "/" + \
QadMsg.translate("Command_TRIM", "Undo")
prompt = QadMsg.translate("Command_TRIM", "Select the object to trim or shift-select to extend or [{0}]: ").format(keyWords)
englishKeyWords = "Fence" + "/" + "Crossing" + "/" + "Edge" + "/" + "Undo"
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)
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)
def setMode(self, mode):
self.mode = mode
# si richiede la selezione di un'entità
if self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_ENTITY_SEL:
self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
# solo layer lineari o poligono editabili che non appartengano a quote
layerList = []
for layer in self.plugIn.canvas.layers():
if layer.type() == QgsMapLayer.VectorLayer and \
(layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \
layer.isEditable():
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.layersToCheck = layerList
self.setSnapType(QadSnapTypeEnum.DISABLE)
# non si richiede niente
elif self.mode == Qad_pedit_maptool_ModeEnum.NONE:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
# si richiede il primo punto per calcolo distanza di approssimazione
# si richiede la posizione più vicina ad un vertice
elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_FIRST_TOLERANCE_PT:
self.onlyEditableLayers = False
self.checkPointLayer = True
self.checkLineLayer = True
self.checkPolygonLayer = True
self.setSnapType()
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
# noto il primo punto per calcolo distanza di approssimazione si richiede il secondo punto
elif self.mode == Qad_pedit_maptool_ModeEnum.FIRST_TOLERANCE_PT_KNOWN_ASK_FOR_SECOND_PT or \
self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_NEW_VERTEX or \
self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_MOVE_VERTEX:
self.onlyEditableLayers = False
self.checkPointLayer = True
self.checkLineLayer = True
self.checkPolygonLayer = True
self.setSnapType()
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
self.setStartPoint(self.firstPt)
# si richiede la posizione più vicina ad un vertice
elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_VERTEX:
self.setSnapType(QadSnapTypeEnum.DISABLE)
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
# si richede il punto base (grip mode)
elif self.mode == Qad_pedit_maptool_ModeEnum.ASK_FOR_BASE_PT:
self.setSnapType()
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
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)
def setMode(self, mode):
self.mode = mode
# si richiede la selezione del primo oggetto
# si richiede la selezione del secondo oggetto
if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING or \
self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_SECOND_LINESTRING:
if self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_FIRST_LINESTRING:
self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
else:
self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)
# solo layer lineari editabili che non appartengano a quote
layerList = []
for layer in self.plugIn.canvas.layers():
if layer.type() == QgsMapLayer.VectorLayer and layer.geometryType() == QGis.Line and layer.isEditable():
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.layersToCheck = layerList
self.setSnapType(QadSnapTypeEnum.DISABLE)
# non si richiede niente
elif self.mode == Qad_fillet_maptool_ModeEnum.NONE:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
# si richiede la selezione della polilinea
elif self.mode == Qad_fillet_maptool_ModeEnum.ASK_FOR_POLYLINE:
self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION_DYNAMIC)
# solo layer lineari o poligono editabili che non appartengano a quote
layerList = []
for layer in self.plugIn.canvas.layers():
if layer.type() == QgsMapLayer.VectorLayer and \
(layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \
layer.isEditable():
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.layersToCheck = layerList
self.setSnapType(QadSnapTypeEnum.DISABLE)
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)
def setEntity(self, layer, fid):
del self.entity
if self.selDimEntity: # se è possibile restituire un oggetto QadDimEntity
# verifico se l'entità appartiene ad uno stile di quotatura
self.entity = QadDimStyles.getDimEntity(layer, fid)
if self.entity is None: # se non è una quota
self.entity = QadEntity()
self.entity.set(layer, fid)
else:
self.entity = QadEntity()
self.entity.set(layer, fid)
self.entity.selectOnLayer()
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
def setMode(self, mode):
self.clear()
self.mode = mode
# si richiede il primo punto per calcolo offset
if self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_FIRST_OFFSET_PT:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
self.onlyEditableLayers = False
# noto il primo punto per calcolo offset si richiede il secondo punto
if self.mode == Qad_offset_maptool_ModeEnum.FIRST_OFFSET_PT_KNOWN_ASK_FOR_SECOND_PT:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.ELASTIC_LINE)
self.setStartPoint(self.firstPt)
self.onlyEditableLayers = False
# nota la distanza di offset si richiede il punto per stabilire da che parte
elif self.mode == Qad_offset_maptool_ModeEnum.OFFSET_KNOWN_ASK_FOR_SIDE_PT:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
self.onlyEditableLayers = False
# si richiede il punto di passaggio per stabilire da che parte e a quale offset
elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_PASSAGE_PT:
self.setSelectionMode(QadGetPointSelectionModeEnum.POINT_SELECTION)
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
self.onlyEditableLayers = False
# si richiede la selezione di un oggetto
elif self.mode == Qad_offset_maptool_ModeEnum.ASK_FOR_ENTITY_SELECTION:
self.setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
# solo layer lineari o poligono editabili che non appartengano a quote
layerList = []
for layer in self.plugIn.canvas.layers():
if layer.type() == QgsMapLayer.VectorLayer and \
(layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon) and \
layer.isEditable():
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.layersToCheck = layerList
self.setDrawMode(QadGetPointDrawModeEnum.NONE)
self.onlyEditableLayers = True
#.........这里部分代码省略.........
self.defaultValue = QadMsg.translate("Command_TRIM", "No")
else:
self.defaultValue = QadMsg.translate("Command_TRIM", "Extend")
prompt = QadMsg.translate("Command_TRIM", "Specify an extension mode [{0}] <{1}>: ").format(keyWords, self.defaultValue)
englishKeyWords = "Extend" + "/" + "No extend"
keyWords += "_" + englishKeyWords
# si appresta ad attendere enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.KEYWORDS, \
self.defaultValue, \
keyWords, QadInputModeEnum.NONE)
self.step = 5
return False
elif value == QadMsg.translate("Command_TRIM", "Undo") or value == "Undo":
if self.nOperationsToUndo > 0:
self.nOperationsToUndo = self.nOperationsToUndo - 1
self.plugIn.undoEditCommand()
else:
self.showMsg(QadMsg.translate("QAD", "\nThe command has been canceled."))
elif type(value) == QgsPoint: # se é stato selezionato un punto
self.entitySet.clear()
if self.getPointMapTool().entity.isInitialized():
self.entitySet.addEntity(self.getPointMapTool().entity)
ToExtend = True if self.getPointMapTool().shiftKey == True else False
self.trimFeatures(QgsGeometry.fromPoint(value), ToExtend)
else:
# cerco se ci sono entità nel punto indicato considerando
# solo layer lineari editabili che non appartengano a quote
layerList = []
for layer in qad_utils.getVisibleVectorLayers(self.plugIn.canvas): # Tutti i layer vettoriali visibili
if layer.geometryType() == QGis.Line and layer.isEditable():
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
result = qad_utils.getEntSel(self.getPointMapTool().toCanvasCoordinates(value),
self.getPointMapTool(), \
QadVariables.get(QadMsg.translate("Environment variables", "PICKBOX")), \
layerList)
if result is not None:
feature = result[0]
layer = result[1]
point = result[2]
self.entitySet.addEntity(QadEntity().set(layer, feature.id()))
self.trimFeatures(QgsGeometry.fromPoint(point), False)
else:
return True # fine comando
# si appresta ad attendere la selezione degli oggetti da estendere/tagliare
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO PER MODALITA' INTERCETTA (da step = 2)
elif self.step == 3: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
if len(self.PLINECommand.vertices) > 1:
if msgMapTool == True: # se la polilinea arriva da una selezione grafica
ToExtend = True if self.getPointMapTool().shiftKey == True else False
else:
ToExtend = False
# cerco tutte le geometrie passanti per la polilinea saltando i layer punto e poligono
# e considerando solo layer editabili
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
return True # fine comando
currLayer = None
if self.virtualCmd == False: # se si vuole veramente salvare la polylinea in un layer
# il layer corrente deve essere editabile e di tipo linea o poligono
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, [QGis.Line, QGis.Polygon])
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
# il layer corrente non deve appartenere a quotature
dimStyleList = QadDimStyles.getDimListByLayer(currLayer)
if len(dimStyleList) > 0:
dimStyleNames = ""
for i in xrange(0, len(dimStyleList), 1):
if i > 0:
dimStyleNames += ", "
dimStyleNames += dimStyleList[i].name
errMsg = QadMsg.translate("QAD", "\nCurrent layer is a layer referenced to {0} dimension style and it is not valid.\n")
self.showErr(errMsg.format(dimStyleNames))
return True # fine comando
#=========================================================================
# RICHIESTA SELEZIONE OGGETTI
if self.step == 0: # inizio del comando
if self.SSGetClass.run(msgMapTool, msg) == True:
# selezione terminata
self.step = 1
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di selezione entità
return self.run(msgMapTool, msg)
#=========================================================================
# BUFFER OGGETTI
elif self.step == 1:
self.entitySet.set(self.SSGetClass.entitySet)
if self.entitySet.count() == 0:
return True # fine comando
# imposto il map tool
self.getPointMapTool().setMode(Qad_mbuffer_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)
if currLayer is not None:
self.getPointMapTool().geomType = QGis.Line if currLayer.geometryType() == QGis.Line else QGis.Polygon
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi
msg = QadMsg.translate("Command_MBUFFER", "Specify the buffer length <{0}>: ")
self.waitFor(msg.format(str(self.plugIn.lastRadius)), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
self.plugIn.lastRadius, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 2
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA LARGHEZZA (da step = 1)
elif self.step == 2: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint:
self.startPtForBufferWidth = value
# imposto il map tool
self.getPointMapTool().startPtForBufferWidth = self.startPtForBufferWidth
self.getPointMapTool().entitySet.set(self.entitySet)
self.getPointMapTool().segments = self.segments
self.getPointMapTool().setMode(Qad_mbuffer_maptool_ModeEnum.FIRST_PT_ASK_FOR_BUFFER_WIDTH)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_MBUFFER", "Specify second point: "))
self.step = 3
return False
else:
self.width = value
self.plugIn.setLastRadius(self.width)
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.AddGeoms(currLayer)
return True # fine comando
#=========================================================================
#.........这里部分代码省略.........
def __initQadInfo(self):
# inizializza entityType, qadGeom, dimStyle, dimId
if self.isInitialized() == False:
return QadEntityGeomTypeEnum.NONE
self.dimStyle = None
self.dimId = None
g = self.getGeometry()
if g is None:
return QadEntityGeomTypeEnum.NONE
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
coordTransform = QgsCoordinateTransform(self.layer.crs(), iface.mapCanvas().mapRenderer().destinationCrs())
g.transform(coordTransform)
wkbType = g.wkbType()
if wkbType == QGis.WKBPoint:
from qad_dim import QadDimStyles # to avoid cyclic import
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(self)
if (dimStyle is not None) and (dimId is not None):
self.dimStyle = dimStyle # stile di quotatura di appartenenza
self.dimId = dimId # codice quotatura di appartenenza
if qad_layer.isTextLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.TEXT
elif qad_layer.isSymbolLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.SYMBOL
self.qadGeom = g.asPoint() # un punto
if wkbType == QGis.WKBMultiPoint:
if qad_layer.isTextLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.TEXT
elif qad_layer.isSymbolLayer(self.layer):
self.entityType = QadEntityGeomTypeEnum.SYMBOL
self.qadGeom = g.asMultiPoint() # lista di punti
elif wkbType == QGis.WKBLineString:
from qad_dim import QadDimStyles # to avoid cyclic import
# verifico se l'entità appartiene ad uno stile di quotatura
dimStyle, dimId = QadDimStyles.getDimIdByEntity(self)
if (dimStyle is not None) and (dimId is not None):
self.entityType = QadEntityGeomTypeEnum.DIMENSION_COMPONENT
self.dimStyle = dimStyle # stile di quotatura di appartenenza
self.dimId = dimId # codice quotatura di appartenenza
self.entityType, self.qadGeom = self.__fromPoyline(g.asPolyline())
elif wkbType == QGis.WKBMultiLineString:
self.entityType = []
self.qadGeom = []
lineList = g.asMultiPolyline() # vettore di linee
for line in lineList:
entityType, qadGeom = self.__fromPoyline(g.asPolyline())
self.entityType.append(entityType)
self.qadGeom.append(qadGeom)
elif wkbType == QGis.WKBPolygon:
self.entityType = []
self.qadGeom = []
polygon = g.asPolygon() # vettore di linee
for line in polygon:
entityType, qadGeom = self.__fromPoyline(line)
self.entityType.append(entityType)
self.qadGeom.append(qadGeom)
elif wkbType == QGis.WKBMultiPolygon:
self.entityType = []
self.qadGeom = []
polygonList = g.asMultiPolygon() # vettore di poligoni
for polygon in polygonList:
partialEntityType = []
partialQadGeom = []
for line in polygon:
entityType, qadGeom = self.__fromPoyline(line)
partialEntityType.append(entityType)
partialQadGeom.append(qadGeom)
self.entityType.append(partialEntityType)
self.qadGeom.append(partialQadGeom)
#.........这里部分代码省略.........
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
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 OGGETTO
if self.step == 0: # inizio del comando
# si appresta ad attendere la selezione degli oggetti da estendere/tagliare
self.waitForObjectSelToMisure()
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE OGGETTI DA MISURARE
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 = self.defaultValue
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_LENGTHEN", "DElta") or value == "DElta":
self.waitForDelta()
return False
elif value == QadMsg.translate("Command_LENGTHEN", "Percent") or value == "Percent":
self.waitForPercent()
return False
elif value == QadMsg.translate("Command_LENGTHEN", "Total") or value == "Total":
self.waitForTotal()
return False
elif value == QadMsg.translate("Command_LENGTHEN", "DYnamic") or value == "DYnamic":
self.OpMode = "DYnamic"
self.plugIn.setLastOpMode_lengthen(self.OpMode)
# si appresta ad attendere la selezione degli oggetti da allungare
self.waitForObjectSel()
return False
elif type(value) == QgsPoint: # se é stato selezionato un punto
if self.getPointMapTool().entity.isInitialized():
self.showLength(self.getPointMapTool().entity, value)
else:
# cerco se ci sono entità nel punto indicato considerando
# solo layer di tipo lineari che non appartengano a quote o di tipo poligono
layerList = []
for layer in self.plugIn.canvas.layers():
if layer.type() == QgsMapLayer.VectorLayer and \
layer.geometryType() == QGis.Line or layer.geometryType() == QGis.Polygon:
if len(QadDimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
result = qad_utils.getEntSel(self.getPointMapTool().toCanvasCoordinates(value),
self.getPointMapTool(), \
layerList)
if result is not None:
feature = result[0]
layer = result[1]
self.showLength(QadEntity().set(layer, feature.id()), value)
else:
return True # fine comando
# si appresta ad attendere la selezione degli oggetti da misurare
self.waitForObjectSelToMisure()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL DELTA (da step = 1)
elif self.step == 2: # 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
value = self.plugIn.lastDelta_lengthen # opzione di default "spostamento"
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_LENGTHEN", "Angle") or value == "Angle":
self.waitForDeltaAngle(msgMapTool, msg)
elif type(value) == QgsPoint: # se é stato inserito un punto
#.........这里部分代码省略.........
请发表评论