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 waitForObjectSel(self):
self.step = 2
# imposto il map tool
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.ENTITY_SELECTION)
# 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(self.plugIn.dimStyles.getDimListByLayer(layer)) == 0:
layerList.append(layer)
self.getPointMapTool().layersToCheck = layerList
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
self.getPointMapTool().onlyEditableLayers = True
keyWords = QadMsg.translate("Command_EXTEND", "iNTercetta") + "/" + \
QadMsg.translate("Command_EXTEND", "Interseca") + "/" + \
QadMsg.translate("Command_EXTEND", "Spigolo") + "/" + \
QadMsg.translate("Command_EXTEND", "Annulla")
prompt = QadMsg.translate("Command_EXTEND", "Selezionare oggetto da estendere o selezionare oggetto tenendo premuto il tasto Maiusc per tagliarlo o [{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 waitForObjectSelToMisure(self):
self.step = 1
# imposto il map tool
self.getPointMapTool().setMode(Qad_lengthen_maptool_ModeEnum.ASK_FOR_OBJ_TO_MISURE)
if self.plugIn.lastOpMode_lengthen == "DElta":
self.defaultValue = QadMsg.translate("Command_LENGTHEN", "DElta")
elif self.plugIn.lastOpMode_lengthen == "Percent":
self.defaultValue = QadMsg.translate("Command_LENGTHEN", "Percent")
elif self.plugIn.lastOpMode_lengthen == "Total":
self.defaultValue = QadMsg.translate("Command_LENGTHEN", "Total")
elif self.plugIn.lastOpMode_lengthen == "DYnamic":
self.defaultValue = QadMsg.translate("Command_LENGTHEN", "DYnamic")
else:
self.defaultValue = None
keyWords = QadMsg.translate("Command_LENGTHEN", "DElta") + "/" + \
QadMsg.translate("Command_LENGTHEN", "Percent") + "/" + \
QadMsg.translate("Command_LENGTHEN", "Total") + "/" + \
QadMsg.translate("Command_LENGTHEN", "DYnamic")
if self.defaultValue is None:
prompt = QadMsg.translate("Command_LENGTHEN", "Select an object or [{0}] <{1}>: ").format(keyWords, self.defaultValue)
else:
prompt = QadMsg.translate("Command_LENGTHEN", "Select an object or [{0}] <{1}>: ").format(keyWords, self.defaultValue)
englishKeyWords = "DElta" + "/" + "Percent" + "/" + "Total" + "/" + "DYnamic"
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, \
self.defaultValue, \
keyWords, QadInputModeEnum.NONE)
def displayPopupMenu(self, pos):
if self.selectedDimStyle is None:
return
popupMenu = QMenu(self)
action = QAction(QadMsg.translate("DimStyle_Dialog", "Set current"), popupMenu)
popupMenu.addAction(action)
QObject.connect(action, SIGNAL("triggered()"), self.setCurrentStyle)
action = QAction(QadMsg.translate("DimStyle_Dialog", "Rename"), popupMenu)
popupMenu.addAction(action)
QObject.connect(action, SIGNAL("triggered()"), self.startEditingItem)
action = QAction(QadMsg.translate("DimStyle_Dialog", "Modify description"), popupMenu)
popupMenu.addAction(action)
QObject.connect(action, SIGNAL("triggered()"), self.updDescrSelectedDimStyle)
action = QAction(QadMsg.translate("DimStyle_Dialog", "Remove"), popupMenu)
currDimStyleName = QadVariables.get(QadMsg.translate("Environment variables", "DIMSTYLE"))
if self.selectedDimStyle.name == currDimStyleName:
action.setDisabled(True)
popupMenu.addAction(action)
QObject.connect(action, SIGNAL("triggered()"), self.delSelectedDimStyle)
popupMenu.popup(self.dimStyleList.mapToGlobal(pos))
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapRenderer().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
return True # fine comando
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
self.step = 1
return False # continua
elif self.step == 1:
if self.EntSelClass.run(msgMapTool, msg) == True:
if self.EntSelClass.entity.isInitialized():
layer = self.EntSelClass.entity.layer
if self.plugIn.canvas.currentLayer() is None or \
self.plugIn.canvas.currentLayer() != layer:
self.plugIn.canvas.setCurrentLayer(layer)
self.plugIn.iface.setActiveLayer(layer) # lancia evento di deactivate e activate dei plugin
self.plugIn.iface.legendInterface().refreshLayerSymbology(layer)
msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "\nThe current layer is {0}.")
self.showMsg(msg.format(layer.name()))
del self.EntSelClass
return True
else:
self.showMsg(QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
def run(self, msgMapTool = False, msg = None):
if self.step == 0: # inizio del comando
if self.firstTime == True:
self.showMsg(QadMsg.translate("Command_SETCURRUPDATEABLELAYERBYGRAPH", "\nSelect objects whose layers will be the editable: "))
self.firstTime = False
if self.SSGetClass.run(msgMapTool, msg) == True:
# selezione terminata
self.step = 1
return self.run(msgMapTool, msg)
else:
return False # continua
elif self.step == 1: # dopo aver atteso la selezione di oggetti
message = ""
for layerEntitySet in self.SSGetClass.entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.isEditable() == False:
if layer.startEditing() == True:
self.plugIn.iface.legendInterface().refreshLayerSymbology(layer)
self.showMsg(QadMsg.translate("Command_SETCURRUPDATEABLELAYERBYGRAPH", "\nThe layer {0} is editable.").format(layer.name()))
if len(self.SSGetClass.entitySet.layerEntitySetList) == 1:
layer = self.SSGetClass.entitySet.layerEntitySetList[0].layer
if self.plugIn.canvas.currentLayer() is None or \
self.plugIn.canvas.currentLayer() != layer:
self.plugIn.canvas.setCurrentLayer(layer)
self.plugIn.iface.setActiveLayer(layer) # lancia evento di deactivate e activate dei plugin
self.plugIn.iface.legendInterface().refreshLayerSymbology(layer)
self.showMsg(QadMsg.translate("Command_SETCURRUPDATEABLELAYERBYGRAPH", "\nThe current layer is {0}.").format(layer.name()))
return True
def delCurrentSubGeomToPolygon(self):
"""
Cancella la sotto-geometria corrente dal poligono da modificare
"""
geom = self.poligonEntity.getGeometry()
# la posizione é espressa con una lista (<index ogg. princ> [<index ogg. sec.>])
part = self.currAtSubGeom[0]
if len(self.currAtSubGeom) == 2:
ring = self.currAtSubGeom[1]
if geom.deleteRing(ring + 1, part) == False: # cancello una isola (Ring 0 is outer ring and can't be deleted)
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
else:
if geom.deletePart(part) == False: # cancello una parte
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.poligonEntity.getFeature()
f.setGeometry(geom)
self.plugIn.beginEditCommand("Feature edited", self.poligonEntity.layer)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
self.plugIn.endEditCommand()
self.nOperationsToUndo = self.nOperationsToUndo + 1
def getInvalidInputMsg(self):
"""
restituisce il messaggio di input non valido
"""
if self.inputType & QadInputTypeEnum.POINT2D or \
self.inputType & QadInputTypeEnum.POINT3D:
if self.inputType & QadInputTypeEnum.KEYWORDS and \
(self.inputType & QadInputTypeEnum.FLOAT or self.inputType & QadInputTypeEnum.ANGLE):
return QadMsg.translate("QAD", "\nEnter a point, a real number or a keyword.\n")
elif self.inputType & QadInputTypeEnum.KEYWORDS:
return QadMsg.translate("QAD", "\nEnter a point or a keyword.\n")
elif self.inputType & QadInputTypeEnum.FLOAT or self.inputType & QadInputTypeEnum.ANGLE:
return QadMsg.translate("QAD", "\nEnter a point or a real number.\n")
else:
return QadMsg.translate("QAD", "\nPoint not valid.\n")
elif self.inputType & QadInputTypeEnum.KEYWORDS:
return QadMsg.translate("QAD", "\nKeyword not valid.\n")
elif self.inputType & QadInputTypeEnum.STRING:
return QadMsg.translate("QAD", "\nString not valid.\n")
elif self.inputType & QadInputTypeEnum.INT:
return QadMsg.translate("QAD", "\nInteger number not valid.\n")
elif self.inputType & QadInputTypeEnum.LONG:
return QadMsg.translate("QAD", "\nLong integer number not valid.\n")
elif self.inputType & QadInputTypeEnum.FLOAT or self.inputType & QadInputTypeEnum.ANGLE:
return QadMsg.translate("QAD", "\nReal number not valid.\n")
elif self.inputType & QadInputTypeEnum.BOOL:
return QadMsg.translate("QAD", "\nBoolean not valid.\n")
else:
return ""
def init_selection_tab(self):
# Inizializzazione del TAB "selection"
# PICKBOX
# aggiungo il QWidget chiamato QadPreviewPickBox
# che eredita la posizione di widget_PICKBOX (che viene nascosto)
self.widget_PICKBOX.setHidden(True)
pickBoxColor = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "PICKBOXCOLOR")))
self.previewPickBox = QadPreviewPickBox(self.plugIn, pickBoxColor, self.widget_PICKBOX.parent())
self.previewPickBox.setGeometry(self.widget_PICKBOX.geometry())
self.previewPickBox.setObjectName("previewPickBox")
var = self.tempQadVariables.getVariable(QadMsg.translate("Environment variables", "PICKBOX"))
self.horizontalSlider_PICKBOX.setMinimum(var.minNum)
#self.horizontalSlider_PICKBOX.setMaximum(var.maxNum)
self.horizontalSlider_PICKBOX.setMaximum(20) # oltre i 20 non ci sta nel riquadro
self.horizontalSlider_PICKBOX.setValue(var.value)
# PICKFIRST
pickFirst = False if self.tempQadVariables.get(QadMsg.translate("Environment variables", "PICKFIRST")) == 0 else True
self.checkBox_PICKFIRST.setChecked(pickFirst)
# PICKADD
pickAdd = self.tempQadVariables.get(QadMsg.translate("Environment variables", "PICKADD"))
if pickAdd == 0:
self.checkBox_PICKADD.setChecked(True)
else:
self.checkBox_PICKADD.setChecked(False)
# GRIPSIZE
# aggiungo il QWidget chiamato QadPreviewGripSize
# che eredita la posizione di widget_GRIPSIZE (che viene nascosto)
self.widget_GRIPSIZE.setHidden(True)
fillColor = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPCOLOR")))
borderColor = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPCONTOUR")))
self.previewGripSize = QadPreviewGripSize(self.plugIn, fillColor, borderColor, self.widget_GRIPSIZE.parent())
self.previewGripSize.setGeometry(self.widget_GRIPSIZE.geometry())
self.previewGripSize.setObjectName("previewGripSize")
var = self.tempQadVariables.getVariable(QadMsg.translate("Environment variables", "GRIPSIZE"))
self.horizontalSlider_GRIPSIZE.setMinimum(var.minNum)
#self.horizontalSlider_PGRIPSIZE.setMaximum(var.maxNum)
self.horizontalSlider_GRIPSIZE.setMaximum(20) # oltre i 20 non ci sta nel riquadro
self.horizontalSlider_GRIPSIZE.setValue(var.value)
# GRIPS
grips = False if self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPS")) == 0 else True
self.checkBox_GRIPS.setChecked(grips)
# GRIPMULTIFUNCTIONAL
gripMultiFunctional = self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPMULTIFUNCTIONAL"))
self.checkBox_GRIPMULTIFUNCTIONAL_ON_DYNAMIC_MENU_AND_HOT_GRIPT.setChecked(gripMultiFunctional & QadGRIPMULTIFUNCTIONALEnum.ON_DYNAMIC_MENU_AND_HOT_GRIPT)
# GRIPOBJLIMIT
gripObjLimit = self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPOBJLIMIT"))
self.lineEdit_GRIPOBJLIMIT.setText(str(gripObjLimit))
self.lineEdit_GRIPOBJLIMIT.setValidator(QIntValidator(self.lineEdit_GRIPOBJLIMIT))
self.lineEdit_GRIPOBJLIMIT.installEventFilter(self)
self.checkBox_GRIPS_ON_clicked()
def waitForDistance(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_offset_maptool_ModeEnum.ASK_FOR_FIRST_OFFSET_PT)
self.getPointMapTool().gapType = self.gapType
keyWords = QadMsg.translate("Command_OFFSET", "Punto") + "/" + QadMsg.translate("Command_OFFSET", "Cancella")
if self.offSet < 0:
default = QadMsg.translate("Command_OFFSET", "Punto")
else:
default = self.offSet
prompt = QadMsg.translate("Command_OFFSET", "Specificare distanza di offset o [{0}] <{1}>: ").format(
keyWords, str(default)
)
englishKeyWords = "Through" + "/" + "Erase"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave o un numero reale
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(
prompt,
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS,
default,
keyWords,
QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE,
)
self.step = 1
def WaitForMainMenu(self):
self.poligonEntity.selectOnLayer(False)
keyWords = QadMsg.translate("Command_MAPMPEDIT", "Add") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Delete") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Union") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Substract") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Intersect") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "include Objs")
englishKeyWords = "Add" + "/" + "Delete" + "/" + "Union" + "/" + "Substract" + "/" + "Intersect" "/" + "include Objs"
if self.nOperationsToUndo > 0: # se c'è qualcosa che si può annullare
keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT", "Undo")
englishKeyWords = englishKeyWords + "/" + "Undo"
keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT", "eXit")
englishKeyWords = englishKeyWords + "/" + "eXit"
default = QadMsg.translate("Command_MAPMPEDIT", "eXit")
prompt = QadMsg.translate("Command_MAPMPEDIT", "Enter an option [{0}] <{1}>: ").format(keyWords, default)
self.step = 2
self.getPointMapTool().setSelectionMode(QadGetPointSelectionModeEnum.NONE)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
keyWords += "_" + englishKeyWords
# si appresta ad attendere enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
return False
def waitForPassagePt(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_offset_maptool_ModeEnum.ASK_FOR_PASSAGE_PT)
if self.multi == False:
keyWords = QadMsg.translate("Command_OFFSET", "Exit") + "/" + \
QadMsg.translate("Command_OFFSET", "Multiple") + "/" + \
QadMsg.translate("Command_OFFSET", "Undo")
defaultMsg = QadMsg.translate("Command_OFFSET", "Exit")
default = QadMsg.translate("Command_OFFSET", "Exit")
englishKeyWords = "Exit" + "/" + "Multiple" + "/" + "Undo"
else:
keyWords = QadMsg.translate("Command_OFFSET", "Exit") + "/" + \
QadMsg.translate("Command_OFFSET", "Undo")
defaultMsg = QadMsg.translate("Command_OFFSET", "next object")
default = None
englishKeyWords = "Exit" + "/" + "Undo"
if self.OnlySegment == False:
keyWords = keyWords + "/" + \
QadMsg.translate("Command_OFFSET", "Segment")
englishKeyWords = englishKeyWords + "/" + "Segment"
prompt = QadMsg.translate("Command_OFFSET", "Specify through point or [{0}] <{1}>: ")
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, valore nullo non permesso
self.waitFor(prompt.format(keyWords, defaultMsg), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
default, \
keyWords, QadInputModeEnum.NONE)
self.step = 4
def init_osnap_tab(self):
# Inizializzazione del TAB che riguarda gli SNAP ad oggetto
# Memorizzo il valore dell'OSMODE per determinare gli osnap impostati
OsMode = QadVariables.get(QadMsg.translate("Environment variables", "OSMODE"))
self.checkBox_CENP.setChecked(OsMode & QadSnapTypeEnum.CEN)
self.checkBox_ENDP.setChecked(OsMode & QadSnapTypeEnum.END)
self.checkBox_END_PLINE.setChecked(OsMode & QadSnapTypeEnum.END_PLINE)
self.checkBox_EXTP.setChecked(OsMode & QadSnapTypeEnum.EXT)
self.checkBox_INTP.setChecked(OsMode & QadSnapTypeEnum.INT)
self.checkBox_MIDP.setChecked(OsMode & QadSnapTypeEnum.MID)
self.checkBox_NODP.setChecked(OsMode & QadSnapTypeEnum.NOD)
self.checkBox_QUADP.setChecked(OsMode & QadSnapTypeEnum.QUA)
#self.checkBox_INSP.setChecked(OsMode & QadSnapTypeEnum.INS)
#self.checkBox_INTAPP.setChecked(OsMode & QadSnapTypeEnum.APP)
self.checkBox_NEARP.setChecked(OsMode & QadSnapTypeEnum.NEA)
self.checkBox_PERP.setChecked(OsMode & QadSnapTypeEnum.PER)
self.checkBox_PARALP.setChecked(OsMode & QadSnapTypeEnum.PAR)
self.checkBox_PROGRESP.setChecked(OsMode & QadSnapTypeEnum.PR)
self.checkBox_TANP.setChecked(OsMode & QadSnapTypeEnum.TAN)
self.checkBox_EXT_INT.setChecked(OsMode & QadSnapTypeEnum.EXT_INT)
self.checkBox_TANP.setChecked(OsMode & QadSnapTypeEnum.TAN)
self.checkBox_IsOsnapON.setChecked(not(OsMode & QadSnapTypeEnum.DISABLE))
ProgrDistance = QadVariables.get(QadMsg.translate("Environment variables", "OSPROGRDISTANCE"))
stringA = str(ProgrDistance)
self.lineEdit_ProgrDistance.setText(stringA)
self.lineEdit_ProgrDistance.setValidator(QDoubleValidator(self.lineEdit_ProgrDistance))
self.lineEdit_ProgrDistance.installEventFilter(self)
def showAllProps(self, dimStyle):
if self.tableWidget.model() is not None:
# Pulisce la tabella
self.tableWidget.model().reset()
self.tableWidget.setRowCount(0)
self.tableWidget.setColumnCount(2)
headerLabels = []
headerLabels.append(QadMsg.translate("DimStyle_Diff_Dialog", "Descrizione"))
headerLabels.append(dimStyle.name)
self.tableWidget.setHorizontalHeaderLabels(headerLabels)
self.tableWidget.horizontalHeader().show()
self.count = 0
propsDict = dimStyle.getPropList().items()
for prop in propsDict:
propName = prop[0]
propDescr = prop[1][0]
propValue = prop[1][1]
self.insertProp(propDescr, propValue)
self.tableWidget.sortItems(0)
self.tableWidget.horizontalHeader().setResizeMode(0, QHeaderView.ResizeToContents)
self.tableWidget.horizontalHeader().setResizeMode(1, QHeaderView.Interactive)
self.msg.setText(QadMsg.translate("DimStyle_Diff_Dialog", "Tutte le proprietà dello stile di quota: ") + dimStyle.name)
def floatLineEditWidgetValidation(self, widget, varName, msg):
var = self.tempQadVariables.getVariable(QadMsg.translate("Environment variables", varName))
err = False
string = widget.text()
if qad_utils.str2float(string) is None:
err = True
else:
if var.minNum is not None:
if qad_utils.str2float(string) < var.minNum:
err = True
if var.maxNum is not None:
if qad_utils.str2float(string) > var.maxNum:
err = True
if err:
msg = msg + QadMsg.translate("QAD", ": enter a number")
if var.minNum is not None:
minValMsg = msg + QadMsg.translate("QAD", " > {0}").format(str(var.minNum))
else:
minValMsg = ""
if var.maxNum is not None:
if len(minValMsg) > 0:
msg = msg + QadMsg.translate("QAD", " and")
msg = msg + QadMsg.translate("QAD", " < {0}").format(str(var.maxNum))
msg = msg + "."
QMessageBox.critical(self, "QAD", msg)
widget.setFocus()
widget.selectAll()
return False
return True
def getInvalidInputMsg(self):
"""
restituisce il messaggio di input non valido
"""
if self.inputType & QadInputTypeEnum.POINT2D or \
self.inputType & QadInputTypeEnum.POINT3D:
if self.inputType & QadInputTypeEnum.KEYWORDS and \
(self.inputType & QadInputTypeEnum.FLOAT or self.inputType & QadInputTypeEnum.ANGLE):
return QadMsg.translate("QAD", "\nE' richiesto un punto, un numero reale o la parola chiave di un'opzione.\n")
elif self.inputType & QadInputTypeEnum.KEYWORDS:
return QadMsg.translate("QAD", "\nE' richiesto un punto o la parola chiave di un'opzione.\n")
elif self.inputType & QadInputTypeEnum.FLOAT or self.inputType & QadInputTypeEnum.ANGLE:
return QadMsg.translate("QAD", "\nE' richiesto un punto o un numero reale.\n")
else:
return QadMsg.translate("QAD", "\nPunto non valido.\n")
elif self.inputType & QadInputTypeEnum.KEYWORDS:
return QadMsg.translate("QAD", "\nParola chiave dell'opzione non valida.\n")
elif self.inputType & QadInputTypeEnum.STRING:
return QadMsg.translate("QAD", "\nStringa non valida.\n")
elif self.inputType & QadInputTypeEnum.INT:
return QadMsg.translate("QAD", "\nNumero intero non valido.\n")
elif self.inputType & QadInputTypeEnum.LONG:
return QadMsg.translate("QAD", "\nNumero intero lungo non valido.\n")
elif self.inputType & QadInputTypeEnum.FLOAT or self.inputType & QadInputTypeEnum.ANGLE:
return QadMsg.translate("QAD", "\nNumero reale non valido.\n")
elif self.inputType & QadInputTypeEnum.BOOL:
return QadMsg.translate("QAD", "\nValore booleano non valido.\n")
else:
return ""
def refreshEntityGripPoints(self, entitySet = None):
if entitySet is None:
entitySet = self.entitySet
gripObjLimit = QadVariables.get(QadMsg.translate("Environment variables", "GRIPOBJLIMIT"))
if gripObjLimit != 0: # When set to 0, grips are always displayed.
if entitySet.count() > gripObjLimit:
# Suppresses the display of grips when the selection set includes more than the specified number of objects
self.clearEntityGripPoints()
return
# cancello i grip delle entità che non sono in entitySet o che non sono in layer vettoriali modificabili
i = self.entitySetGripPoints.count() - 1
while i >= 0:
entityGripPoint = self.entitySetGripPoints.entityGripPoints[i]
if entitySet.containsEntity(entityGripPoint.entity) == False or \
entityGripPoint.entity.layer.type() != QgsMapLayer.VectorLayer or entityGripPoint.entity.layer.isEditable() == False:
self.entitySetGripPoints.entityGripPoints[i].removeItems() # lo stacco dal canvas
del self.entitySetGripPoints.entityGripPoints[i]
i = i - 1
entity = QadEntity()
for layerEntitySet in entitySet.layerEntitySetList:
# considero solo i layer vettoriali che sono modificabili
layer = layerEntitySet.layer
if layer.type() == QgsMapLayer.VectorLayer and layer.isEditable():
for featureId in layerEntitySet.featureIds:
entity.set(layer, featureId)
self.entitySetGripPoints.addEntity(entity, QadVariables.get(QadMsg.translate("Environment variables", "GRIPS")))
def addSnapTypeByPopupMenu(self, _snapType):
value = QadVariables.get(QadMsg.translate("Environment variables", "OSMODE"))
if value & QadSnapTypeEnum.DISABLE:
value = value - QadSnapTypeEnum.DISABLE
QadVariables.set(QadMsg.translate("Environment variables", "OSMODE"), value | _snapType)
QadVariables.save()
self.plugIn.refreshCommandMapToolSnapType()
def ButtonBOX_Accepted(self):
newOSMODE = 0
if self.checkBox_CENP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.CEN
if self.checkBox_ENDP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.END
if self.checkBox_END_PLINE.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.END_PLINE
if self.checkBox_EXTP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.EXT
if self.checkBox_INTP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.INT
if self.checkBox_MIDP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.MID
if self.checkBox_NODP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.NOD
if self.checkBox_QUADP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.QUA
#if self.checkBox_INSP.checkState() == Qt.Checked:
# newOSMODE = newOSMODE | QadSnapTypeEnum.INS
#if self.checkBox_INTAPP.checkState() == Qt.Checked:
# newOSMODE = newOSMODE | QadSnapTypeEnum.APP
if self.checkBox_NEARP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.NEA
if self.checkBox_PARALP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.PAR
if self.checkBox_PERP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.PER
if self.checkBox_PROGRESP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.PR
if self.checkBox_TANP.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.TAN
if self.checkBox_EXT_INT.checkState() == Qt.Checked:
newOSMODE = newOSMODE | QadSnapTypeEnum.EXT_INT
if self.checkBox_IsOsnapON.checkState() == Qt.Unchecked:
newOSMODE = newOSMODE | QadSnapTypeEnum.DISABLE
QadVariables.set(QadMsg.translate("Environment variables", "OSMODE"), newOSMODE)
AutoSnap = QadVariables.get(QadMsg.translate("Environment variables", "AUTOSNAP"))
if self.checkBox_PolarPickPoint.checkState() == Qt.Checked:
AutoSnap = AutoSnap | 8
elif AutoSnap & 8:
AutoSnap = AutoSnap - 8
QadVariables.set(QadMsg.translate("Environment variables", "AUTOSNAP"), AutoSnap)
# Memorizzo il valore di PolarANG
SUserAngle = self.comboBox_increment_angle.currentText()
UserAngle = qad_utils.str2float(SUserAngle)
QadVariables.set(QadMsg.translate("Environment variables", "POLARANG"), UserAngle)
SProgrDist = self.lineEdit_ProgrDistance.text()
ProgrDist = qad_utils.str2float(SProgrDist)
QadVariables.set(QadMsg.translate("Environment variables", "OSPROGRDISTANCE"), ProgrDist)
QadVariables.save()
self.close()
return True
def addEntitySetToPolyline(self, entitySet, removeOriginals = True):
"""
Aggiunge il set di entità alla polilinea da modificare
"""
geom = self.entity.getGeometry()
layerList = []
layerList.append(self.entity.layer)
for layerEntitySet in entitySet.layerEntitySetList:
layer = layerEntitySet.layer
if layer.geometryType() != QGis.Polygon and layer.geometryType() != QGis.Line:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
if removeOriginals: layerList.append(layer)
coordTransform = QgsCoordinateTransform(layer.crs(), self.entity.layer.crs())
for featureId in layerEntitySet.featureIds:
# se la feature è quella di entity è errore
if layer.id() == self.entity.layerId() and featureId == self.entity.featureId:
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = layerEntitySet.getFeature(featureId)
# trasformo la geometria nel crs del layer dell'entità da modificare
geomToAdd = f.geometry()
geomToAdd.transform(coordTransform)
# Riduco la geometria in point o polyline
simplifiedGeoms = qad_utils.asPointOrPolyline(geomToAdd)
for simplifiedGeom in simplifiedGeoms:
points = simplifiedGeom.asPolyline() # vettore di punti
# aggiungo una parte
if geom.addPart(points) != 0: # 0 in case of success
self.showMsg(QadMsg.translate("QAD", "Invalid object."))
return False
f = self.entity.getFeature()
f.setGeometry(geom)
layerList = entitySet.getLayerList()
layerList.append(self.entity.layer)
self.plugIn.beginEditCommand("Feature edited", layerList)
# plugIn, layer, feature, refresh, check_validity
if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f, False, False) == False:
self.plugIn.destroyEditCommand()
return False
if removeOriginals:
for layerEntitySet in entitySet.layerEntitySetList:
if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
self.plugIn.destroyEditCommand()
return
self.plugIn.endEditCommand()
return True
def renSelectedDimStyle(self, newName):
if self.selectedDimStyle is None:
return
if QadDimStyles.renameDimStyle(self.selectedDimStyle.name, newName) == False:
QMessageBox.critical(self, QadMsg.translate("QAD", "QAD"), \
QadMsg.translate("DimStyle_Dialog", "Dimension style not renamed."))
else:
self.init()
def renSelectedDimStyle(self, newName):
if self.selectedDimStyle is None:
return
if self.plugIn.dimStyles.renameDimStyle(self.selectedDimStyle.name, newName) == False:
QMessageBox.critical(self, QadMsg.translate("QAD", "QAD"), \
QadMsg.translate("DimStyle_Dialog", "Lo stile di quotatura non è stato rinominato."))
else:
self.init()
def __init__(self, mapCanvas):
QgsMapCanvasItem.__init__(self, mapCanvas)
self.canvas = mapCanvas
self.iconType = QadGripIconTypeEnum.BOX # icon to be shown
self.iconSize = QadVariables.get(QadMsg.translate("Environment variables", "GRIPSIZE"))
self.borderColor = QadVariables.get(QadMsg.translate("Environment variables", "GRIPCONTOUR")) # color of the border
self.center = QgsPoint(0, 0) # coordinates of the point in the center
self.setGrip(QadGripStatusEnum.UNSELECTED, QadGripIconTypeEnum.BOX)
def retranslateUi(self, DimStyle_Dialog):
qad_dimstyle_ui.Ui_DimStyle_Dialog.retranslateUi(self, self)
# "none" viene tradotto in italiano in "nessuno" nel contesto "currentDimStyle"
# "none" viene tradotto in italiano in "nessuna" nel contesto "descriptionSelectedStyle"
# "none" viene tradotto in italiano in "nessuno" nel contesto "selectedStyle"
self.currentDimStyle.setText(QadMsg.translate("DimStyle_Dialog", "none", "currentDimStyle"))
self.descriptionSelectedStyle.setText(QadMsg.translate("DimStyle_Dialog", "none", "descriptionSelectedStyle"))
self.selectedStyle.setText(QadMsg.translate("DimStyle_Dialog", "none", "selectedStyle"))
def init_context_list(self):
self.contextList = dict()
# description, element dictionary
contextDescr = QadMsg.translate("WindowColor_Dialog", "Model Space") # x lupdate
self.contextList[QadColorContextEnum.MODEL_SPACE_2D] = [contextDescr, self.get_MODEL_SPACE_2D_element_dict()]
contextDescr = QadMsg.translate("WindowColor_Dialog", "Command line") # x lupdate
self.contextList[QadColorContextEnum.COMMAND_LINE] = [contextDescr, self.get_COMMAND_LINE_element_dict()]
def refreshPreviewColor(self):
pickBoxColor = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "PICKBOXCOLOR")))
self.previewPickBox.color = pickBoxColor
autoSnapColor = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "AUTOSNAPCOLOR")))
self.previewAutoSnapMarker.color = autoSnapColor
apertureColor = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "PICKBOXCOLOR")))
cursorColor = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "CURSORCOLOR")))
self.previewAperture.color = apertureColor
self.previewAperture.cursorColor = cursorColor
def init_polar_tab(self):
# Inizializzazione del TAB che riguarda il puntamento polare
UserAngle = QadVariables.get(QadMsg.translate("Environment variables", "POLARANG"))
angoliDef = ["90", "45", "30", "22.5", "18", "15", "10", "5"]
self.comboBox_increment_angle.addItems(angoliDef)
stringA = str(UserAngle)
self.comboBox_increment_angle.lineEdit().setText(stringA)
self.comboBox_increment_angle.installEventFilter(self)
AutoSnap = QadVariables.get(QadMsg.translate("Environment variables", "AUTOSNAP"))
self.checkBox_PolarPickPoint.setChecked(AutoSnap & 8)
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapRenderer().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"
)
)
return True # fine comando
if self.virtualCmd == False: # se si vuole veramente salvare la polylinea in un layer
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Polygon)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
# =========================================================================
# RICHIESTA PRIMO PUNTO PER SELEZIONE OGGETTI
if self.step == 0:
self.PLINECommand = QadPLINECommandClass(self.plugIn, True)
# 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.asToolForMPolygon = True # per rubberband tipo poligono
self.PLINECommand.run(msgMapTool, msg)
self.step = 1
return False # continua
# =========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO (da step = 0 o 1)
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if self.PLINECommand.run(msgMapTool, msg) == True:
verticesLen = len(self.PLINECommand.vertices)
if verticesLen > 3:
self.vertices = self.PLINECommand.vertices[:] # copio la lista
firstVertex = self.vertices[0]
# se l'ultimo vertice non é uguale al primo
if self.vertices[verticesLen - 1] != firstVertex:
# aggiungo un vertice con le stesse coordinate del primo
self.vertices.append(firstVertex)
if self.virtualCmd == False: # se si vuole veramente salvare la polylinea in un layer
if qad_layer.addPolygonToLayer(self.plugIn, currLayer, self.vertices) == False:
self.showMsg(QadMsg.translate("Command_MPOLYGON", "\nPolygon not valid.\n"))
del self.vertices[:] # svuoto la lista
else:
self.showMsg(QadMsg.translate("Command_MPOLYGON", "\nPolygon not valid.\n"))
del self.PLINECommand
self.PLINECommand = None
return True # fine
return False
def initActions(self, inputType, keyWords):
self.delActions()
# inizializzo la lista di parole chiave contestuale al comando corrente (lingua locale)
# carattere separatore tra le parole chiave in lingua locale e quelle in inglese
localEnglishKeyWords = keyWords.split("_")
localKeyWords = localEnglishKeyWords[0].split("/") # carattere separatore delle parole chiave
msg = QadMsg.translate("ContextualCmdMenu", "Enter")
action = QAction(msg, self)
self.addAction(action)
self.connections.append([action, self.enterActionByContextualMenu])
msg = QadMsg.translate("ContextualCmdMenu", "Cancel")
action = QAction(msg, self)
self.addAction(action)
self.connections.append([action, self.cancelActionByContextualMenu])
if inputType & QadInputTypeEnum.POINT2D or inputType & QadInputTypeEnum.POINT3D:
msg = QadMsg.translate("ContextualCmdMenu", "Recent Input")
recentPtsMenu = self.addMenu(msg)
ptsHistory = self.plugIn.ptsHistory
ptsHistoryLen = len(ptsHistory)
i = ptsHistoryLen - 1
cmdInputHistoryMax = QadVariables.get(QadMsg.translate("Environment variables", "CMDINPUTHISTORYMAX"))
# ciclo sulla storia degli ultimi punti usati
while i >= 0 and (ptsHistoryLen - i) <= cmdInputHistoryMax:
strPt = qad_utils.QgsPointToString(ptsHistory[i])
i = i - 1
action = QAction(strPt, recentPtsMenu)
recentPtsMenu.addAction(action)
self.connections.append([action, self.showEvaluateMsgByContextualMenu])
self.addSeparator()
# ciclo sulle opzioni correnti del comando in uso
for keyWord in localKeyWords:
action = QAction(keyWord, self)
self.addAction(action)
self.connections.append([action, self.showEvaluateMsgByContextualMenu])
if inputType & QadInputTypeEnum.POINT2D or inputType & QadInputTypeEnum.POINT3D:
self.addSeparator()
osnapMenu = QadOsnapContextualMenuClass(self.plugIn)
self.addMenu(osnapMenu)
# creo tutte le connessioni per gli eventi
for connection in self.connections:
action = connection[0]
slot = connection[1]
QObject.connect(action, SIGNAL("triggered()"), slot)
def displayPopupMenuOnQuiescentState(self, pos):
popupMenu = QMenu(self.canvas)
history = self.plugIn.getHistoryfromTxtWindow()
isLastCmdToInsert = True
isRecentMenuToInsert = True
historyLen = len(history)
i = historyLen - 1
cmdInputHistoryMax = QadVariables.get(QadMsg.translate("Environment variables", "CMDINPUTHISTORYMAX"))
while i >= 0 and (historyLen - i) <= cmdInputHistoryMax:
cmdName = history[i]
i = i - 1
cmd = self.plugIn.QadCommands.getCommandObj(cmdName)
if cmd is not None:
if isLastCmdToInsert:
isLastCmdToInsert = False
msg = QadMsg.translate("Popup_menu_graph_window", "Repeat ") + cmd.getName()
icon = cmd.getIcon()
if icon is None:
lastCmdAction = QAction(msg, popupMenu)
else:
lastCmdAction = QAction(icon, msg, popupMenu)
cmd.connectQAction(lastCmdAction)
popupMenu.addAction(lastCmdAction)
else:
if isRecentMenuToInsert:
isRecentMenuToInsert = False
recentCmdsMenu = popupMenu.addMenu(QadMsg.translate("Popup_menu_graph_window", "Recent commands"))
icon = cmd.getIcon()
if icon is None:
recentCmdAction = QAction(cmd.getName(), recentCmdsMenu)
else:
recentCmdAction = QAction(icon, cmd.getName(), recentCmdsMenu)
cmd.connectQAction(recentCmdAction)
recentCmdsMenu.addAction(recentCmdAction)
if isLastCmdToInsert == False: # menu non vuoto
popupMenu.addSeparator()
# aggiungo comando "OPTIONS"
cmd = self.plugIn.QadCommands.getCommandObj(QadMsg.translate("Command_list", "OPTIONS"))
icon = cmd.getIcon()
if icon is None:
optionsCmdAction = QAction(cmd.getName(), popupMenu)
else:
optionsCmdAction = QAction(icon, cmd.getName(), popupMenu)
cmd.connectQAction(optionsCmdAction)
popupMenu.addAction(optionsCmdAction)
popupMenu.popup(self.canvas.mapToGlobal(pos))
def waitForDynamicPt(self):
self.step = 10
# imposto il map tool
self.getPointMapTool().setMode(Qad_lengthen_maptool_ModeEnum.ASK_FOR_DYNAMIC_POINT)
prompt = QadMsg.translate("Command_LENGTHEN", "Specify new endpoint: ")
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D, \
None, \
"", QadInputModeEnum.NONE)
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.SSGetClass = QadSSGetClass(plugIn)
self.SSGetClass.onlyEditableLayers = True
self.entitySet = QadEntitySet()
self.basePt = QgsPoint()
self.series = False
self.seriesLen = 2
self.adjust = False
self.copyMode = QadVariables.get(QadMsg.translate("Environment variables", "COPYMODE"))
self.featureCache = [] # lista di (layer, feature)
self.nOperationsToUndo = 0
def lineEdit_ProgrDistance_Validation(self):
string = self.lineEdit_ProgrDistance.text()
if qad_utils.str2float(string) is None or qad_utils.str2float(
string) == 0:
msg = QadMsg.translate(
"DSettings_Dialog",
"Invalid progressive distance object snap: enter a number not zero."
)
QMessageBox.critical(self, "QAD", msg)
self.lineEdit_ProgrDistance.setFocus()
self.lineEdit_ProgrDistance.selectAll()
return False
return True
def comboBox_increment_angle_Validation(self):
string = self.comboBox_increment_angle.lineEdit().text()
if qad_utils.str2float(string) is None or qad_utils.str2float(
string) <= 0 or qad_utils.str2float(string) >= 360:
msg = QadMsg.translate(
"DSettings_Dialog",
"Invalid increment angle: enter a number greater than zero and less than 360 degree."
)
QMessageBox.critical(self, "QAD", msg)
self.comboBox_increment_angle.lineEdit().setFocus()
self.comboBox_increment_angle.lineEdit().selectAll()
return False
return True
def init_osnap_tab(self):
# Inizializzazione del TAB che riguarda gli SNAP ad oggetto
# Memorizzo il valore dell'OSMODE per determinare gli osnap impostati
OsMode = QadVariables.get(
QadMsg.translate("Environment variables", "OSMODE"))
self.checkBox_CENP.setChecked(OsMode & QadSnapTypeEnum.CEN)
self.checkBox_ENDP.setChecked(OsMode & QadSnapTypeEnum.END)
self.checkBox_END_PLINE.setChecked(OsMode & QadSnapTypeEnum.END_PLINE)
self.checkBox_EXTP.setChecked(OsMode & QadSnapTypeEnum.EXT)
self.checkBox_INTP.setChecked(OsMode & QadSnapTypeEnum.INT)
self.checkBox_MIDP.setChecked(OsMode & QadSnapTypeEnum.MID)
self.checkBox_NODP.setChecked(OsMode & QadSnapTypeEnum.NOD)
self.checkBox_QUADP.setChecked(OsMode & QadSnapTypeEnum.QUA)
#self.checkBox_INSP.setChecked(OsMode & QadSnapTypeEnum.INS)
#self.checkBox_INTAPP.setChecked(OsMode & QadSnapTypeEnum.APP)
self.checkBox_NEARP.setChecked(OsMode & QadSnapTypeEnum.NEA)
self.checkBox_PERP.setChecked(OsMode & QadSnapTypeEnum.PER)
self.checkBox_PARALP.setChecked(OsMode & QadSnapTypeEnum.PAR)
self.checkBox_PROGRESP.setChecked(OsMode & QadSnapTypeEnum.PR)
self.checkBox_TANP.setChecked(OsMode & QadSnapTypeEnum.TAN)
self.checkBox_EXT_INT.setChecked(OsMode & QadSnapTypeEnum.EXT_INT)
self.checkBox_TANP.setChecked(OsMode & QadSnapTypeEnum.TAN)
self.checkBox_IsOsnapON.setChecked(not (OsMode
& QadSnapTypeEnum.DISABLE))
AutoSnap = QadVariables.get(
QadMsg.translate("Environment variables", "AUTOSNAP"))
self.checkBox_ObjectSnapTracking.setChecked(
AutoSnap & QadAUTOSNAPEnum.OBJ_SNAP_TRACKING)
ProgrDistance = QadVariables.get(
QadMsg.translate("Environment variables", "OSPROGRDISTANCE"))
stringA = str(ProgrDistance)
self.lineEdit_ProgrDistance.setText(stringA)
self.lineEdit_ProgrDistance.setValidator(
QDoubleValidator(self.lineEdit_ProgrDistance))
self.lineEdit_ProgrDistance.installEventFilter(self)
def temporaryModStyle(self):
if self.selectedDimStyle is None:
return
self.previewDim.eraseDim()
Form = QadDIMSTYLE_DETAILS_Dialog(self.plugIn, self, self.selectedDimStyle)
title = QadMsg.translate("DimStyle_Dialog", "Set temporary overrides to dimension style: ") + self.selectedDimStyle.name
Form.setWindowTitle(title)
if Form.exec_() == QDialog.Accepted:
self.selectedDimStyle.set(Form.dimStyle)
self.init()
self.previewDim.drawDim(self.selectedDimStyle)
def createNewStyle(self):
self.previewDim.eraseDim()
Form = QadDIMSTYLE_NEW_Dialog(self.plugIn, self, self.selectedDimStyle.name if self.selectedDimStyle is not None else None)
if Form.exec_() == QDialog.Accepted:
Form.dimStyle.path = ""
QadDimStyles.addDimStyle(Form.dimStyle, True)
self.selectedDimStyle = QadDimStyles.findDimStyle(Form.dimStyle.name)
# setto lo stile corrente
QadVariables.set(QadMsg.translate("Environment variables", "DIMSTYLE"), self.selectedDimStyle.name)
self.init()
self.previewDim.drawDim(self.selectedDimStyle)
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DISJOIN",
"Select object to disjoin: ")
# scarto la selezione di quote
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.deselectOnFinish = True
self.entSelClass.run(msgMapTool, msg)
def waitForBoundary(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select boundary: ")
# scarto la selezione di punti e polilinee
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = False
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entity = QadEntity()
self.subGeom = None
self.subGeomSelectedPt = None
self.offSet = QadVariables.get(
QadMsg.translate("Environment variables", "OFFSETDIST"))
self.lastOffSetOnLeftSide = 0
self.lastOffSetOnRightSide = 0
self.firstPt = QgsPoint()
self.eraseEntity = False
self.multi = False
self.OnlySegment = False
self.gapType = QadVariables.get(
QadMsg.translate("Environment variables", "OFFSETGAPTYPE"))
self.featureCache = [] # lista di (layer, feature)
self.undoFeatureCacheIndexes = [
] # posizioni in featureCache dei punti di undo
self.rubberBand = createRubberBand(self.plugIn.canvas, QGis.Line)
self.rubberBandPolygon = createRubberBand(self.plugIn.canvas,
QGis.Polygon)
def waitForReferenceLen(self):
self.__referenceLenMode = True
# imposto il map tool
self.getPointMapTool().setMode(Qad_scale_maptool_ModeEnum.ASK_FOR_FIRST_PT_REFERENCE_LEN)
msg = QadMsg.translate("Command_GRIPSCALE", "Specify reference length <{0}>: ")
# si appresta ad attendere un punto o enter
# msg, inputType, default, keyWords, valori positivi
self.waitFor(msg.format(str(self.plugIn.lastReferenceLen)), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
self.plugIn.lastReferenceLen, \
"", QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 3
def paint_COMMAND_LINE(self):
rect = self.rect()
sep = rect.height() * 2 / 3
painter = QPainter(self)
# CMDHISTORYBACKCOLOR
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "CMDHISTORYBACKCOLOR")))
painter.fillRect(0, 0, rect.width(), sep, color)
# CMDHISTORYFORECOLOR
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "CMDHISTORYFORECOLOR")))
painter.setPen(QPen(color))
painter.drawText(QRectF(0, 0, rect.width(), sep), Qt.AlignCenter, QadMsg.translate("QAD", "Command: "))
# CMDLINEBACKCOLOR
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "CMDLINEBACKCOLOR")))
painter.fillRect(0, sep, rect.width(), rect.height(), color)
# CMDLINEFORECOLOR
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "CMDLINEFORECOLOR")))
painter.setPen(QPen(color))
painter.drawText(QRectF(0, sep, rect.width(), rect.height() - sep), Qt.AlignCenter, QadMsg.translate("QAD", "Command: "))
def WaitForRadius(self, layer):
self.step = 4
if layer is not None:
self.getPointMapTool().geomType = layer.geometryType()
self.getPointMapTool().setMode(Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi
prompt = QadMsg.translate("Command_CIRCLE", "Specify the circle radius <{0}>: ")
self.waitFor(prompt.format(str(self.plugIn.lastRadius)), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
self.plugIn.lastRadius, "", \
QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
def button_GripColor_clicked(self):
Form = QadGripColorDialog(self.plugIn, self, \
self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPCOLOR")), \
self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPHOT")), \
self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPHOVER")), \
self.tempQadVariables.get(QadMsg.translate("Environment variables", "GRIPCONTOUR")))
if Form.exec_() == QDialog.Accepted:
self.tempQadVariables.set(QadMsg.translate("Environment variables", "GRIPCOLOR"), Form.gripColor)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "GRIPHOT"), Form.gripHot)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "GRIPHOVER"), Form.gripHover)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "GRIPCONTOUR"), Form.gripContour)
self.previewGripSize.fillColor = QColor(Form.gripColor)
self.previewGripSize.borderColor = QColor(Form.gripContour)
def accept_display_tab(self):
# Memorizzo il valore di SHOWTEXTWINDOW
newSHOWTEXTWINDOW = True if self.checkBox_SHOWTEXTWINDOW.checkState() == Qt.Checked else False
self.tempQadVariables.set(QadMsg.translate("Environment variables", "SHOWTEXTWINDOW"), newSHOWTEXTWINDOW)
# Memorizzo il valore di CMDINPUTHISTORYMAX
SHistoryMax = self.lineEdit_CMDINPUTHISTORYMAX.text()
historyMax = qad_utils.str2int(SHistoryMax)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "CMDINPUTHISTORYMAX"), historyMax)
# Memorizzo il valore di INPUTSEARCHOPTIONS
newInputSearchOptions = 0
if self.checkBox_INPUTSEARCHOPTIONS_ON.checkState() == Qt.Checked:
newInputSearchOptions = newInputSearchOptions | QadINPUTSEARCHOPTIONSEnum.ON
if self.checkBox_INPUTSEARCHOPTIONS_AUTOCOMPLETE.checkState() == Qt.Checked:
newInputSearchOptions = newInputSearchOptions | QadINPUTSEARCHOPTIONSEnum.AUTOCOMPLETE
if self.checkBox_INPUTSEARCHOPTIONS_DISPLAY_LIST.checkState() == Qt.Checked:
newInputSearchOptions = newInputSearchOptions | QadINPUTSEARCHOPTIONSEnum.DISPLAY_LIST
if self.checkBox_INPUTSEARCHOPTIONS_DISPLAY_ICON.checkState() == Qt.Checked:
newInputSearchOptions = newInputSearchOptions | QadINPUTSEARCHOPTIONSEnum.DISPLAY_ICON
if self.checkBox_INPUTSEARCHOPTIONS_EXCLUDE_SYS_VAR.checkState() == Qt.Checked:
newInputSearchOptions = newInputSearchOptions | QadINPUTSEARCHOPTIONSEnum.EXCLUDE_SYS_VAR
self.tempQadVariables.set(QadMsg.translate("Environment variables", "INPUTSEARCHOPTIONS"), newInputSearchOptions)
# Memorizzo il valore di INPUTSEARCHDELAY
SInputSearchDelay = self.lineEdit_INPUTSEARCHDELAY.text()
InputSearchDelay = qad_utils.str2int(SInputSearchDelay)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "INPUTSEARCHDELAY"), InputSearchDelay)
# Memorizzo il valore di ARCMINSEGMENTQTY
SArcMinSegmentQty = self.lineEdit_ARCMINSEGMENTQTY.text()
ArcMinSegmentQty = qad_utils.str2int(SArcMinSegmentQty)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "ARCMINSEGMENTQTY"), ArcMinSegmentQty)
# Memorizzo il valore di CIRCLEMINSEGMENTQTY
SCircleMinSegmentQty = self.lineEdit_CIRCLEMINSEGMENTQTY.text()
CircleMinSegmentQty = qad_utils.str2int(SCircleMinSegmentQty)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "CIRCLEMINSEGMENTQTY"), CircleMinSegmentQty)
# Memorizzo il valore di TOLERANCE2APPROXCURVE
STolerance2ApproxCurve = self.lineEdit_TOLERANCE2APPROXCURVE.text()
Tolerance2ApproxCurve = qad_utils.str2int(STolerance2ApproxCurve)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"), Tolerance2ApproxCurve)
# Memorizzo il valore di CURSORSIZE
SCursorSize = self.lineEdit_CURSORSIZE.text()
CursorSize = qad_utils.str2int(SCursorSize)
self.tempQadVariables.set(QadMsg.translate("Environment variables", "CURSORSIZE"), CursorSize)
def WaitForMainMenu(self):
self.poligonEntity.selectOnLayer(False)
keyWords = QadMsg.translate("Command_MAPMPEDIT", "Add") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Delete") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Union") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Substract") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "Intersect") + "/" + \
QadMsg.translate("Command_MAPMPEDIT", "include Objs")
englishKeyWords = "Add" + "/" + "Delete" + "/" + "Union" + "/" + "Substract" + "/" + "Intersect" "/" + "include Objs"
if self.nOperationsToUndo > 0: # se c'è qualcosa che si può annullare
keyWords = keyWords + "/" + QadMsg.translate(
"Command_MAPMPEDIT", "Undo")
englishKeyWords = englishKeyWords + "/" + "Undo"
keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT",
"eXit")
englishKeyWords = englishKeyWords + "/" + "eXit"
default = QadMsg.translate("Command_MAPMPEDIT", "eXit")
prompt = QadMsg.translate("Command_MAPMPEDIT",
"Enter an option [{0}] <{1}>: ").format(
keyWords, default)
self.step = 2
self.getPointMapTool().setSelectionMode(
QadGetPointSelectionModeEnum.NONE)
self.getPointMapTool().setDrawMode(QadGetPointDrawModeEnum.NONE)
keyWords += "_" + englishKeyWords
# si appresta ad attendere enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
return False
def setCmdAndOptionsToRun(self, CmdAndArglist):
# primo elemento della lista = nome comando
# gli altri elementi sono gli argomenti del comando None = input dell'utente
cmdName = CmdAndArglist[0]
self.args = CmdAndArglist[1:] # copio la lista saltando il primo elemento
self.command = self.plugIn.getCommandObj(cmdName)
if self.command is None:
msg = QadMsg.translate("QAD", "\nInvalid command \"{0}\".")
self.showErr(msg.format(command))
return False
self.plugIn.updateCmdsHistory(cmdName)
return True
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ENT
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_DIVIDE", "Select object to divide: ")
# scarto la selezione di punti
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = True
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = False
self.entSelClass.run(msgMapTool, msg)
def waitForNewReferenceLen(self):
# imposto il map tool
self.getPointMapTool().setMode(
Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_LEN_PT)
keyWords = QadMsg.translate("Command_SCALE", "Points")
if self.plugIn.lastNewReferenceLen == 0:
default = self.plugIn.lastScale
else:
default = self.plugIn.lastNewReferenceLen
prompt = QadMsg.translate(
"Command_SCALE", "Specify new length or [{0}] <{1}>: ").format(
keyWords, str(default))
englishKeyWords = "Points"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, valori positivi
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS, \
default, \
keyWords, QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 6
def waitForEntsel(self, msgMapTool, msg):
if self.entSelClass is not None:
del self.entSelClass
self.step = 1
self.entSelClass = QadEntSelClass(self.plugIn)
self.entSelClass.msg = QadMsg.translate("Command_BREAK", "Select the object to break: ")
# scarto la selezione di punti e poligoni
self.entSelClass.checkPointLayer = False
self.entSelClass.checkLineLayer = True
self.entSelClass.checkPolygonLayer = False
self.entSelClass.checkDimLayers = False
self.entSelClass.onlyEditableLayers = True
self.entSelClass.run(msgMapTool, msg)
def __init__(self, plugIn):
QadCommandClass.__init__(self, plugIn)
self.entity = QadEntity()
self.point = None
# opzioni per limitare gli oggetti da selezionare
self.onlyEditableLayers = False
self.checkPointLayer = True
self.checkLineLayer = True
self.checkPolygonLayer = True
self.checkDimLayers = True
self.selDimEntity = False # per restituire o meno un oggetto QadDimEntity
self.msg = QadMsg.translate("QAD", "Select object: ")
self.deselectOnFinish = False
self.canceledByUsr = False # diventa true se l'utente non vuole scegliere niente (es. se usato il tasto destro del mouse)
def waitForTotalLength(self, msgMapTool, msg):
self.step = 8
self.OpType = "length"
# si appresta ad attendere una distanza
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_LENGTHEN", "Enter total length <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.plugIn.lastTotal_lengthen))
self.GetDistClass.startPt = self.startPt
self.GetDistClass.dist = self.plugIn.lastTotal_lengthen
self.GetDistClass.inputMode = QadInputModeEnum.NONE
self.GetDistClass.run(msgMapTool, msg)
def waitForFilletMode(self):
self.step = 4
# imposto il map tool
self.getPointMapTool().setMode(Qad_fillet_maptool_ModeEnum.NONE)
keyWords = QadMsg.translate("Command_FILLET", "Trim-extend") + "/" + \
QadMsg.translate("Command_FILLET", "No trim-extend")
if self.filletMode == 1:
default = QadMsg.translate("Command_FILLET", "Trim-extend")
elif self.filletMode == 2:
default = QadMsg.translate("Command_FILLET", "No trim-extend")
prompt = QadMsg.translate("Command_FILLET",
"Specify trim mode [{0}] <{1}>: ").format(
keyWords, default)
englishKeyWords = "Trim-extend" + "/" + "No trim-extend"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave o un numero reale
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, QadInputTypeEnum.KEYWORDS, default, \
keyWords)
def waitForObjectSel(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_offset_maptool_ModeEnum.ASK_FOR_ENTITY_SELECTION)
self.lastOffSetOnLeftSide = 0
self.getPointMapTool().lastOffSetOnLeftSide = self.lastOffSetOnLeftSide
self.lastOffSetOnRightSide = 0
self.getPointMapTool().lastOffSetOnRightSide = self.lastOffSetOnRightSide
# "Esci" "ANnulla"
keyWords = QadMsg.translate("Command_OFFSET", "Exit") + "/" + \
QadMsg.translate("Command_OFFSET", "Undo")
default = QadMsg.translate("Command_OFFSET", "Exit")
prompt = QadMsg.translate("Command_OFFSET", "Select object to offset or [{0}] <{1}>: ").format(keyWords, default)
englishKeyWords = "Exit" + "/" + "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, \
default, \
keyWords, QadInputModeEnum.NONE)
self.step = 2
def waitForDistance(self):
# imposto il map tool
self.getPointMapTool().setMode(Qad_offset_maptool_ModeEnum.ASK_FOR_FIRST_OFFSET_PT)
self.getPointMapTool().gapType = self.gapType
keyWords = QadMsg.translate("Command_OFFSET", "Through") + "/" + \
QadMsg.translate("Command_OFFSET", "Erase")
if self.offSet < 0:
default = QadMsg.translate("Command_OFFSET", "Through")
else:
default = self.offSet
prompt = QadMsg.translate("Command_OFFSET", "Specify the offset distance or [{0}] <{1}>: ").format(keyWords, str(default))
englishKeyWords = "Through" + "/" + "Erase"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave o un numero reale
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS, \
default, \
keyWords, \
QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 1
def waitForReferenceRot(self):
# imposto il map tool
self.getPointMapTool().setMode(
Qad_rotate_maptool_ModeEnum.ASK_FOR_FIRST_PT_REFERENCE_ANG)
msg = QadMsg.translate("Command_GRIPROTATE",
"Specify reference angle <{0}>: ")
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(msg.format(str(qad_utils.toDegrees(self.plugIn.lastReferenceRot))), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
self.plugIn.lastReferenceRot, \
"")
self.step = 3
def paint_MODEL_SPACE_2D(self):
rect = self.rect()
painter = QPainter(self)
painter.fillRect(rect, self.plugIn.canvas.canvasColor())
painter.setRenderHint(QPainter.Antialiasing)
# PICKBOX
x1 = rect.width() / 3
y1 = rect.height() - rect.height() / 3
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "PICKBOXCOLOR")))
pickSize = 5
painter.setPen(QPen(color, 1, Qt.SolidLine))
painter.drawRect(x1 - pickSize, y1 - pickSize, 2 * pickSize, 2 * pickSize)
# CROSSHAIRS
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "CURSORCOLOR")))
cursorSize = 20
painter.setPen(QPen(color, 1, Qt.SolidLine))
painter.drawLine(x1 - pickSize, y1, x1 - pickSize - cursorSize, y1)
painter.drawLine(x1 + pickSize, y1, x1 + pickSize + cursorSize, y1)
painter.drawLine(x1, y1 - pickSize, x1, y1 - pickSize - cursorSize)
painter.drawLine(x1, y1 + pickSize, x1, y1 + pickSize + cursorSize)
# AUTOTRECK_VECTOR
x1 = rect.width() / 3
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "AUTOTRECKINGVECTORCOLOR")))
painter.setPen(QPen(color, 1, Qt.DashLine))
painter.drawLine(x1, 0, x1, rect.height())
painter.drawLine(x1 + rect.height() * 2 / 3, 0, x1 - rect.height() / 3, rect.height())
# AUTOSNAP
x1 = rect.width() / 3
y1 = rect.height() / 3
color = QColor(self.tempQadVariables.get(QadMsg.translate("Environment variables", "AUTOSNAPCOLOR")))
pickSize = 5
painter.setPen(QPen(color, 2, Qt.SolidLine))
painter.drawRect(x1 - pickSize, y1 - pickSize, 2 * pickSize, 2 * pickSize)
def createQADTempLayer(plugIn, GeomType):
"""
Aggiunge tre liste di geometrie rispettivamente a tre layer temporanei di QAD (uno per tipologia di
geometria). Se le geometrie sono da convertire allora
deve essere passato il parametro <coordTransform> di tipo QgsCoordinateTransform.
<epsg> = the authority identifier for this srs
"""
layer = None
epsg = plugIn.iface.mapCanvas().mapSettings().destinationCrs().authid()
if GeomType == QGis.Point:
layerName = QadMsg.translate("QAD", "QAD - Temporary points")
layerList = getLayersByName(qad_utils.wildCard2regularExpr(layerName))
if len(layerList) == 0:
layer = QgsVectorLayer("Point?crs=%s&index=yes" % epsg, layerName, "memory")
QgsMapLayerRegistry.instance().addMapLayers([layer], True)
else:
layer = layerList[0]
elif GeomType == QGis.Line:
layerName = QadMsg.translate("QAD", "QAD - Temporary lines")
layerList = getLayersByName(qad_utils.wildCard2regularExpr(layerName))
if len(layerList) == 0:
layer = QgsVectorLayer("LineString?crs=%s&index=yes" % epsg, layerName, "memory")
QgsMapLayerRegistry.instance().addMapLayers([layer], True)
else:
layer = layerList[0]
elif GeomType == QGis.Polygon:
layerName = QadMsg.translate("QAD", "QAD - Temporary polygons")
layerList = getLayersByName(qad_utils.wildCard2regularExpr(layerName))
if len(layerList) == 0:
layer = QgsVectorLayer("Polygon?crs=%s&index=yes" % epsg, layerName, "memory")
QgsMapLayerRegistry.instance().addMapLayers([layer], True)
else:
layer = layerList[0]
layer.startEditing()
return layer
def setCurrentSubGeom(self, entSelClass):
"""
Setta la sottogeometria corrente
"""
self.currSubGeom = None
self.currAtSubGeom = None
# verifico che sia stata selezionata un'entità
if entSelClass.entity.isInitialized() == False:
self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
return False
# verifico che sia stata selezionata attraverso un punto
# (per capire quale sottogeometria è stata selezionata)
if entSelClass.point is None: return False
# verifico che sia stato selezionato lo stesso polygono che è da modificare
if self.poligonEntity != entSelClass.entity:
self.showMsg(QadMsg.translate("Command_MAPMPEDIT", "The boundary doesn't belong to the selected polygon."))
return False
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
geom = self.layerToMapCoordinates(entSelClass.entity.layer, entSelClass.entity.getGeometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(entSelClass.point, geom)
if dummy[2] is None:
return False
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
self.currSubGeom, self.currAtSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])
if self.currSubGeom is None or self.currAtSubGeom is None:
self.currSubGeom = None
self.currAtSubGeom = None
return False
return True
def canvasPressEvent(self, event):
# volevo mettere questo evento nel canvasReleaseEvent
# ma il tasto destro non genera quel tipo di evento
if event.button() == Qt.RightButton:
self.displayPopupMenuOnQuiescentState(event.pos())
elif event.button() == Qt.LeftButton:
# verifico se tasto shift premuto
shiftKey = True if event.modifiers() & Qt.ShiftModifier else False
# posizione corrente del mouse
point = self.toMapCoordinates(event.pos())
# leggo il punto grip che si interseca alla posizione del mouse
entityGripPoint = self.entitySetGripPoints.isIntersecting(point)
if entityGripPoint is not None:
if shiftKey == False: # lancio il comando
selectedEntityGripPoints = self.entitySetGripPoints.getSelectedEntityGripPoints(
)
# se non ci sono già grip selezionati
if len(selectedEntityGripPoints) == 0:
# seleziono il corrente
if self.entitySetGripPoints.selectIntersectingGripPoints(
point) > 0:
selectedEntityGripPoints = self.entitySetGripPoints.getSelectedEntityGripPoints(
)
# lancio il comando
self.plugIn.runCommand("QadVirtualGripCommandsClass", [QadVirtualGripCommandsEnum.STRECTH, \
self.entitySetGripPoints, entityGripPoint.getPoint()])
else: # shift premuto
# inverto lo stato ai grip che intersecano il punto
self.entitySetGripPoints.toggleSelectIntersectingGripPoints(
point)
else:
result = qad_utils.getEntSel(event.pos(), self, \
QadVariables.get(QadMsg.translate("Environment variables", "PICKBOX")))
if result is not None:
feature = result[0]
layer = result[1]
tmpEntity = QadEntity()
tmpEntity.set(layer, feature.id())
SSGetClass = QadSSGetClass(self.plugIn)
SSGetClass.entitySet.set(self.entitySet)
SSGetClass.elaborateEntity(tmpEntity, shiftKey)
self.plugIn.showMsg("\n", True) # ripete il prompt
self.entitySet.set(SSGetClass.entitySet)
del SSGetClass # che deseleziona gli oggetti
self.entitySet.selectOnLayer(False)
self.refreshEntityGripPoints(self.entitySet)
else:
self.plugIn.runCommand("QadVirtualSelCommandClass", point)
