def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
if self.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)
self.PLINECommand.setRubberBandColor(self.rubberBandBorderColor,
self.rubberBandFillColor)
# 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 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 run(self, msgMapTool = False, msg = None):
self.isValidPreviousInput = True # per gestire il comando anche in macro
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
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Line)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PRIMO PUNTO o CENTRO
if self.step == 0: # inizio del comando
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_START_PT)
keyWords = QadMsg.translate("Command_ARC", "Center")
prompt = QadMsg.translate("Command_ARC", "Specify the start point of the arc or [{0}]:").format(keyWords)
englishKeyWords = "Center"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo di modo
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
self.step = 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMO PUNTO o CENTRO
elif self.step == 1: # dopo aver atteso un punto o enter o una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None:
if self.plugIn.lastPoint is not None:
value = self.plugIn.lastPoint
else:
return True # fine comando
if type(value) == QgsPoint: # se é stato inserito il punto iniziale dell'arco
self.startPt = value
self.plugIn.setLastPoint(value)
# imposto il map tool
self.getPointMapTool().arcStartPt = self.startPt
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_SECOND_PT)
keyWords = QadMsg.translate("Command_ARC", "Center") + "/" + \
QadMsg.translate("Command_ARC", "End")
prompt = QadMsg.translate("Command_ARC", "Specify second point of the arc or [{0}]:").format(keyWords)
englishKeyWords = "Center" + "/" + "End"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NONE)
self.step = 2
return False
else: # si vuole inserire il centro dell'arco
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ARC", "Specify the center of the arc: "))
self.step = 13
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO o CENTRO o FINE
elif self.step == 2: # dopo aver atteso un punto o una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_ARC", "Center") or value == "Center":
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_CENTER_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ARC", "Specify the center of the arc: "))
self.step = 4
elif value == QadMsg.translate("Command_ARC", "End") or value == "End":
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_PT_KNOWN_ASK_FOR_END_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ARC", "Specify the final point of the arc: "))
self.step = 8
elif type(value) == QgsPoint: # se é stato inserito il secondo punto dell'arco
self.secondPt = value
# imposto il map tool
self.getPointMapTool().arcSecondPt = self.secondPt
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ARC", "Specify the final point of the arc: "))
self.step = 3
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO FINALE DELL'ARCO (da step = 2)
elif self.step == 3: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.endPt = value
arc = QadArc()
if arc.fromStartSecondEndPts(self.startPt, self.secondPt, self.endPt) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ARC", "Specify the final point of the arc: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA CENTRO DELL'ARCO (da step = 2)
elif self.step == 4: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.centerPt = value
self.plugIn.setLastPoint(value)
# imposto il map tool
self.getPointMapTool().arcCenterPt = self.centerPt
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT)
keyWords = QadMsg.translate("Command_ARC", "Angle") + "/" + \
QadMsg.translate("Command_ARC", "chord Length")
prompt = QadMsg.translate("Command_ARC", "Specify the final point of the arc or [{0}]: ").format(keyWords)
englishKeyWords = "Angle" + "/" + "chord Length"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords, valori nulli non ammessi
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NOT_NULL)
self.step = 5
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare punto finale dell'arco o [Angolo/Lunghezza corda]: " (da step = 4)
elif self.step == 5: # dopo aver atteso un punto o una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_ARC", "Angle") or value == "Angle":
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori nulli non ammessi
self.waitFor(QadMsg.translate("Command_ARC", "Specify the included angle: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.ANGLE, \
None, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO)
self.step = 6
return False
elif value == QadMsg.translate("Command_ARC", "chord Length") or value == "chord Length":
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi
self.waitFor(QadMsg.translate("Command_ARC", "Specify the chord length: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
None, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 7
return False
elif type(value) == QgsPoint: # se é stato inserito il punto finale dell'arco
self.endPt = value
arc = QadArc()
if arc.fromStartCenterEndPts(self.startPt, self.centerPt, self.endPt) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
keyWords = QadMsg.translate("Command_ARC", "Angle") + "/" + \
QadMsg.translate("Command_ARC", "chord Length")
prompt = QadMsg.translate("Command_ARC", "Specify the final point of the arc or [{0}]: ").format(keyWords)
englishKeyWords = "Angle" + "/" + "chord Length"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords, valori nulli non ammessi
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NOT_NULL)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare angolo inscritto: " (da step = 5)
elif self.step == 6: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint:
self.angle = qad_utils.getAngleBy2Pts(self.centerPt, value)
else:
self.angle = value
arc = QadArc()
if arc.fromStartCenterPtsAngle(self.startPt, self.centerPt, self.angle) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori nulli non ammessi
self.waitFor(QadMsg.translate("Command_ARC", "Specify the included angle: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.ANGLE, \
None, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare lunghezza della corda: " (da step = 5)
elif self.step == 7: # 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.chord = qad_utils.getDistance(self.startPt, value)
else:
self.chord = value
arc = QadArc()
if arc.fromStartCenterPtsChord(self.startPt, self.centerPt, self.chord) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi ammessi
self.waitFor(QadMsg.translate("Command_ARC", "Specify the chord length: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
None, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare punto finale dell'arco: " (da step = 1)
elif self.step == 8: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.endPt = value
self.plugIn.setLastPoint(self.endPt)
# imposto il map tool
self.getPointMapTool().arcEndPt = self.endPt
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER)
keyWords = QadMsg.translate("Command_ARC", "Angle") + "/" + \
QadMsg.translate("Command_ARC", "Direction") + "/" + \
QadMsg.translate("Command_ARC", "Radius")
prompt = QadMsg.translate("Command_ARC", "Specify the center point of the arc or [{0}]: ").format(keyWords)
englishKeyWords = "Angle" + "/" + "Direction" + "/" + "Radius"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords, valori nulli non ammessi
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NOT_NULL)
self.step = 9
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare centro dell'arco o [Angolo/Direzione/Raggio]: " (da step = 8)
elif self.step == 9: # dopo aver atteso un punto o una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_ARC", "Angle") or value == "Angle":
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, isNullable
self.waitFor(QadMsg.translate("Command_ARC", "Specify the included angle: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.ANGLE, \
None, "", QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO)
self.step = 10
return False
elif value == QadMsg.translate("Command_ARC", "Direction") or value == "Direction":
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, isNullable
self.waitFor(QadMsg.translate("Command_ARC", "Specify the tangent direction for the start point of the arc: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.ANGLE, \
None, "", QadInputModeEnum.NOT_NULL)
self.step = 11
return False
elif value == QadMsg.translate("Command_ARC", "Radius") or value == "Radius":
# imposto il map tool
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, isNullable
self.waitFor(QadMsg.translate("Command_ARC", "Specify the radius of the arc: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
None, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 12
return False
elif type(value) == QgsPoint: # se é stato inserito il centro dell'arco
self.centerPt = value
arc = QadArc()
if arc.fromStartCenterEndPts(self.startPt, self.centerPt, self.endPt) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
keyWords = QadMsg.translate("Command_ARC", "Angle") + "/" + \
QadMsg.translate("Command_ARC", "Direction") + "/" + \
QadMsg.translate("Command_ARC", "Radius")
prompt = QadMsg.translate("Command_ARC", "Specify the center point of the arc or [{0}]: ").format(keyWords)
englishKeyWords = "Angle" + "/" + "Direction" + "/" + "Radius"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords, isNullable
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NOT_NULL)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare angolo inscritto: " (da step = 9)
elif self.step == 10: # 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.angle = qad_utils.getAngleBy2Pts(self.startPt, value)
else:
self.angle = value
arc = QadArc()
if arc.fromStartEndPtsAngle(self.startPt, self.endPt, self.angle) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori non nulli
self.waitFor(QadMsg.translate("Command_ARC", "Specify the included angle: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.ANGLE, \
None, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare direzione tangente per il punto iniziale dell'arco: " (da step = 9)
elif self.step == 11: # 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.angleTan = qad_utils.getAngleBy2Pts(self.startPt, value)
else:
self.angleTan = value
arc = QadArc()
if arc.fromStartEndPtsTan(self.startPt, self.endPt, self.angleTan) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, isNullable
self.waitFor(QadMsg.translate("Command_ARC", "Specify the tangent direction for the start point of the arc: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.ANGLE, \
None, "", QadInputModeEnum.NOT_NULL)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA "Specificare raggio dell'arco: " (da step = 9)
elif self.step == 12: # 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.radius = qad_utils.getDistance(self.endPt, value)
else:
self.radius = value
self.plugIn.setLastRadius(self.radius)
arc = QadArc()
if arc.fromStartEndPtsRadius(self.startPt, self.endPt, self.radius) == True:
self.plugIn.setLastPoint(arc.getEndPt())
points = arc.asPolyline()
if points is not None:
# se i punti sono così vicini da essere considerati uguali
if qad_utils.ptNear(self.startPt, arc.getStartPt()):
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnEndPt())
else:
self.plugIn.setLastSegmentAng(arc.getTanDirectionOnStartPt() + math.pi)
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi
self.waitFor(QadMsg.translate("Command_ARC", "Specify the radius of the arc: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
None, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA CENTRO DELL'ARCO (da step = 1)
elif self.step == 13: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.centerPt = value
self.plugIn.setLastPoint(value)
# imposto il map tool
self.getPointMapTool().arcCenterPt = self.centerPt
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_START_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_ARC", "Specify the start point of the arc: "))
self.step = 14
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO INIZIALE DELL'ARCO (da step = 13)
elif self.step == 14: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.startPt = value
self.plugIn.setLastPoint(value)
# imposto il map tool
self.getPointMapTool().arcStartPt = self.startPt
self.getPointMapTool().setMode(Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT)
keyWords = QadMsg.translate("Command_ARC", "Angle") + "/" + \
QadMsg.translate("Command_ARC", "chord Length")
prompt = QadMsg.translate("Command_ARC", "Specify the final point of the arc or [{0}]: ").format(keyWords)
englishKeyWords = "Angle" + "/" + "chord Length"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords, isNullable
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NOT_NULL)
self.step = 5
return False
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
currLayer = 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
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO DELLA LARGHEZZA BUFFER (da step = 2)
elif self.step == 3: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool(
).point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.width = qad_utils.getDistance(self.startPtForBufferWidth,
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 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
# 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
#=========================================================================
# RICHIESTA DISTANZA DI OFFSET
if self.step == 0: # inizio del comando
CurrSettingsMsg = QadMsg.translate("QAD", "\nCurrent settings: ")
CurrSettingsMsg = CurrSettingsMsg + QadMsg.translate("Command_OFFSET", "OFFSETGAPTYPE = ") + str(self.gapType)
if self.gapType == 0:
CurrSettingsMsg = CurrSettingsMsg + QadMsg.translate("Command_OFFSET", " (extends the segments)")
elif self.gapType == 1:
CurrSettingsMsg = CurrSettingsMsg + QadMsg.translate("Command_OFFSET", " (fillets the segments)")
elif self.gapType == 2:
CurrSettingsMsg = CurrSettingsMsg + QadMsg.translate("Command_OFFSET", " (chamfers the segments)")
self.showMsg(CurrSettingsMsg)
self.waitForDistance()
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA DISTANZA DI OFFSET (da step = 0)
elif self.step == 1: # 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
if self.offSet < 0:
value = QadMsg.translate("Command_OFFSET", "Through")
else:
value = self.offSet
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_OFFSET", "Through") or value == "Through":
self.offSet = -1
self.getPointMapTool().offSet = self.offSet
QadVariables.set(QadMsg.translate("Environment variables", "OFFSETDIST"), self.offSet)
QadVariables.save()
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
elif value == QadMsg.translate("Command_OFFSET", "Erase") or value == "Erase":
keyWords = QadMsg.translate("QAD", "Yes") + "/" + \
QadMsg.translate("QAD", "No")
if self.eraseEntity == True:
default = QadMsg.translate("QAD", "Yes")
else:
default = QadMsg.translate("QAD", "No")
prompt = QadMsg.translate("Command_OFFSET", "Erase source object after offsetting ? [{0}] <{1}>: ").format(keyWords, default)
englishKeyWords = "Yes" + "/" + "No"
keyWords += "_" + englishKeyWords
# si appresta ad attendere enter o una parola chiave
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(prompt, \
QadInputTypeEnum.KEYWORDS, \
default, \
keyWords, QadInputModeEnum.NONE)
self.step = 5
elif value == QadMsg.translate("Command_OFFSET", "Multiple") or value == "Multiple":
self.multi = True
self.waitForBasePt()
elif type(value) == QgsPoint: # se é stato inserito il primo punto per il calcolo della distanza
self.firstPt.set(value.x(), value.y())
# imposto il map tool
self.getPointMapTool().firstPt = self.firstPt
self.getPointMapTool().setMode(Qad_offset_maptool_ModeEnum.FIRST_OFFSET_PT_KNOWN_ASK_FOR_SECOND_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_OFFSET", "Specify second point: "))
self.step = 6
elif type(value) == float:
self.offSet = value
self.getPointMapTool().offSet = self.offSet
QadVariables.set(QadMsg.translate("Environment variables", "OFFSETDIST"), self.offSet)
QadVariables.save()
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA SELEZIONE DI UN OGGETTO
elif self.step == 2:
entity = None
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 = QadMsg.translate("Command_OFFSET", "Exit")
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
entity = self.getPointMapTool().entity
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_OFFSET", "Exit") or value == "Exit":
self.offsetGeoms(currLayer)
return True
elif value == QadMsg.translate("Command_OFFSET", "Undo") or value == "Undo":
self.undoGeomsInCache()
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
elif type(value) == QgsPoint: # se é stato selezionato un punto
if entity is not None and entity.isInitialized(): # se é stata selezionata una entità
self.entity.set(entity.layer, entity.featureId)
self.getPointMapTool().layer = self.entity.layer
# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
geom = self.layerToMapCoordinates(entity.layer, entity.getGeometry())
# ritorna una tupla (<The squared cartesian distance>,
# <minDistPoint>
# <afterVertex>
# <leftOf>)
dummy = qad_utils.closestSegmentWithContext(value, geom)
if dummy[2] is not None:
# ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
# la posizione é espressa con una lista (<index ogg. princ> [<index ogg. sec.>])
self.subGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])[0]
self.subGeomSelectedPt = QgsPoint(value)
self.getPointMapTool().subGeom = self.subGeom
if self.offSet < 0: # richiesta di punto di passaggio
self.waitForPassagePt()
else: # richiesta la parte dell'oggetto
self.waitForSidePt()
else:
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI UN PUNTO PER STABILIRE LA PARTE DI OFFSET (da step = 2)
elif self.step == 3:
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
if self.multi == False: # default = esci
self.offsetGeoms(currLayer)
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None: # oggetto successivo
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
else:
if type(value) == unicode:
if value == QadMsg.translate("Command_OFFSET", "Exit") or value == "Exit":
self.offsetGeoms(currLayer)
return True # fine comando
elif value == QadMsg.translate("Command_OFFSET", "Multiple") or value == "Multiple":
self.multi = True
self.waitForSidePt()
elif value == QadMsg.translate("Command_OFFSET", "Undo") or value == "Undo":
self.undoGeomsInCache()
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
elif value == QadMsg.translate("Command_OFFSET", "Segment") or value == "Segment":
self.OnlySegment = True
linearObject = qad_utils.QadLinearObject()
if linearObject.setByClosestSegmentOfGeom(self.subGeomSelectedPt, self.subGeom) == True:
self.subGeom = QgsGeometry.fromPolyline(linearObject.asPolyline())
self.getPointMapTool().subGeom = self.subGeom
self.waitForSidePt()
elif type(value) == QgsPoint: # se é stato selezionato un punto
self.addFeatureCache(value)
if self.multi == False:
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
else:
# richiesta la parte dell'oggetto
self.waitForSidePt()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI UN PUNTO DI PASSAGGIO DI OFFSET (da step = 2)
elif self.step == 4:
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
if self.multi == False: # default = esci
self.offsetGeoms(currLayer)
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None: # oggetto successivo
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
else:
if type(value) == unicode:
if value == QadMsg.translate("Command_OFFSET", "Exit") or value == "Exit":
self.offsetGeoms(currLayer)
return True # fine comando
elif value == QadMsg.translate("Command_OFFSET", "Multiple") or value == "Multiple":
self.multi = True
self.waitForPassagePt()
elif value == QadMsg.translate("Command_OFFSET", "Undo") or value == "Undo":
self.undoGeomsInCache()
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
elif value == QadMsg.translate("Command_OFFSET", "Segment") or value == "Segment":
self.OnlySegment = True
linearObject = qad_utils.QadLinearObject()
if linearObject.setByClosestSegmentOfGeom(self.subGeomSelectedPt, self.subGeom) == True:
self.subGeom = QgsGeometry.fromPolyline(linearObject.asPolyline())
self.getPointMapTool().subGeom = self.subGeom
self.waitForPassagePt()
elif type(value) == QgsPoint: # se é stato selezionato un punto
self.addFeatureCache(value)
if self.multi == False:
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
else:
# richiesta di punto di passaggio
self.waitForPassagePt()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI CANCELLAZIONE OGGETTO SORGENTE (da step = 1)
elif self.step == 5: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
value = QadMsg.translate("QAD", "No")
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else: # il valore arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("QAD", "Yes") or value == "Yes":
self.eraseEntity = True
self.waitForDistance()
elif value == QadMsg.translate("QAD", "No") or value == "No":
self.eraseEntity = False
self.waitForDistance()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO PER LUNGHEZZA OFFSET (da step = 1)
elif self.step == 6: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value == self.firstPt:
self.showMsg(QadMsg.translate("QAD", "\nThe value must be positive and not zero."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_OFFSET", "Specify second point: "))
return False
self.offSet = qad_utils.getDistance(self.firstPt, value)
self.getPointMapTool().offSet = self.offSet
QadVariables.set(QadMsg.translate("Environment variables", "OFFSETDIST"), self.offSet)
QadVariables.save()
# si appresta ad attendere la selezione di un oggetto
self.waitForObjectSel()
return False
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapRenderer().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nIl sistema di riferimento del progetto deve essere un sistema di coordinate proiettate.\n"))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate("QAD", "\nIl layer corrente non é di tipo simbolo.")
errMsg = errMsg + QadMsg.translate("QAD", "\nUn layer simbolo é un layer vettoriale di tipo punto senza etichetta.\n")
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PUNTO DI INSERIMENTO
if self.step == 0: # inizio del comando
self.waitForPoint() # si appresta ad attendere un punto
self.step = self.step + 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO DI INSERIMENTO
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
pt = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
pt = msg
self.insPt = QgsPoint(pt)
self.plugIn.setLastPoint(self.insPt)
# se la scala dipende da un campo
scaleFldName = qad_layer.get_symbolScaleFieldName(currLayer)
if len(scaleFldName) > 0:
# si appresta ad attendere la scala
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la scala del simbolo <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.scale))
self.GetDistClass.dist = self.scale
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE | QadInputModeEnum.NOT_ZERO
self.GetDistClass.startPt = self.insPt
self.step = 2
self.GetDistClass.run(msgMapTool, msg)
return False
else:
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la rotazione del simbolo <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
#=========================================================================
# RISPOSTA ALLA RICHIESTA SCALA (da step = 1)
elif self.step == 2:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.scale = self.GetDistClass.dist
self.plugIn.setLastScale(self.scale)
del self.GetDistClass
self.GetDistClass = None
# se la rotazione dipende da un campo
rotFldName = qad_layer.get_symbolRotationFieldName(currLayer)
if len(rotFldName) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_INSERT", "Specificare la rotazione del simbolo <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.addFeature(currLayer)
return True
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE (da step = 1 o 2)
elif self.step == 3:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.addFeature(currLayer)
return True # fine comando
else:
return True
return False
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isTextLayer(currLayer) == False:
errMsg = QadMsg.translate("QAD", "\nCurrent layer is not a textual layer.")
errMsg = errMsg + QadMsg.translate("QAD", "\nA textual layer is a vector punctual layer having a label and the symbol transparency no more than 10%.\n")
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PUNTO DI INSERIMENTO
if self.step == 0: # inizio del comando
self.waitForPoint() # si appresta ad attendere un punto
self.step = self.step + 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO DI INSERIMENTO
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# éstato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool éstato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
pt = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
pt = msg
self.insPt = QgsPoint(pt)
self.plugIn.setLastPoint(self.insPt)
# se l'altezza testo dipende da un solo campo
sizeFldNames = qad_label.get_labelSizeFieldNames(currLayer)
if len(sizeFldNames) == 1 and len(sizeFldNames[0]) > 0:
# si appresta ad attendere la scala
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_TEXT", "Specify the text height <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.hText))
self.GetDistClass.dist = self.hText
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE | QadInputModeEnum.NOT_ZERO
self.GetDistClass.startPt = self.insPt
self.step = 2
self.GetDistClass.run(msgMapTool, msg)
return False
else:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(currLayer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_TEXT", "Specify the text rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.initLabelFields(currLayer)
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ALTEZZA TESTO (da step = 1)
elif self.step == 2:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.hText = self.GetDistClass.dist
self.plugIn.setLastHText(self.hText)
del self.GetDistClass
self.GetDistClass = None
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(currLayer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate("Command_TEXT", "Specify the text rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.initLabelFields(currLayer)
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE (da step = 1 o 2)
elif self.step == 3:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.initLabelFields(currLayer)
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True # fine comando
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL VALORE DI UN CAMPO
elif self.step == 4: # dopo aver atteso un valore si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
self.waitForFieldValue()
return False
# il valore arriva come parametro della funzione
self.labelFieldValues.append(msg)
self.labelFieldNamesNdx = self.labelFieldNamesNdx + 1
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True # fine comando
return False
def run(self, msgMapTool = False, msg = None):
self.isValidPreviousInput = True # per gestire il comando anche in macro
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
currLayer = None
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio 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
self.getPointMapTool().geomType = QGis.Line if currLayer.geometryType() == QGis.Line else QGis.Polygon
#=========================================================================
# RICHIESTA PRIMO PUNTO o CENTRO
if self.step == 0: # inizio del comando
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT)
keyWords = QadMsg.translate("Command_CIRCLE", "3Points") + "/" + \
QadMsg.translate("Command_CIRCLE", "2POints") + "/" + \
QadMsg.translate("Command_CIRCLE", "Ttr (tangent tangent radius)")
prompt = QadMsg.translate("Command_CIRCLE", "Specify the center point of the circle or [{0}]: ").format(keyWords)
englishKeyWords = "3Points" + "/" + "2POints" + "/" + "Ttr (tangent tangent radius)"
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)
self.step = 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA CENTRO
elif self.step == 1: # dopo aver atteso un punto o enter o una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi é stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if value is None:
if self.plugIn.lastPoint is not None:
value = self.plugIn.lastPoint
else:
return True # fine comando
if type(value) == unicode:
if value == QadMsg.translate("Command_CIRCLE", "3Points") or value == "3Points":
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify first point on the circle: "))
self.step = 4
elif value == QadMsg.translate("Command_CIRCLE", "2POints") or value == "2POints":
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_DIAM_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify first end of the circle diameter: "))
self.step = 7
elif value == QadMsg.translate("Command_CIRCLE", "Ttr (tangent tangent radius)") or \
value == "Ttr (tangent tangent radius)":
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_TAN)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify first tangent element of the circle: "))
self.step = 9
elif type(value) == QgsPoint: # se é stato inserito il centro del cerchio
self.centerPt = value
self.plugIn.setLastPoint(value)
# imposto il map tool
self.getPointMapTool().centerPt = self.centerPt
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS)
keyWords = QadMsg.translate("Command_CIRCLE", "Diameter") + "/" + \
QadMsg.translate("Command_CIRCLE", "Area")
prompt = QadMsg.translate("Command_CIRCLE", "Specify the circle radius or [{0}]: ").format(keyWords)
englishKeyWords = "Diameter" + "/" + "Area"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords, valori positivi
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, \
QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 2
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA RAGGIO O DIAMETRO O AREA
elif self.step == 2: # dopo aver atteso un punto o una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_CIRCLE", "Diameter") or value == "Diameter":
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_DIAM)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi
self.waitFor(QadMsg.translate("Command_CIRCLE", "Specify the circle diameter: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
None, \
"", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 3
elif value == QadMsg.translate("Command_CIRCLE", "Area") or value == "Area":
msg = QadMsg.translate("Command_CIRCLE", "Enter circle area in current unit <{0}>: ")
# si appresta ad attendere un numero reale
# msg, inputType, default, keyWords, valori positivi
self.waitFor(msg.format(str(self.area)), QadInputTypeEnum.FLOAT, \
self.area, "", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_CENTER_PT)
self.step = 13
elif type(value) == QgsPoint or type(value) == float: # se é stato inserito il raggio del cerchio
if type(value) == QgsPoint: # se é stato inserito il raggio del cerchio con un punto
self.radius = qad_utils.getDistance(self.centerPt, value)
else:
self.radius = value
self.plugIn.setLastRadius(self.radius)
circle = QadCircle()
circle.set(self.centerPt, self.radius)
points = circle.asPolyline()
if points is not None:
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio in un layer
if currLayer.geometryType() == QGis.Line:
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
else:
qad_layer.addPolygonToLayer(self.plugIn, currLayer, points)
return True # fine comando
keyWords = QadMsg.translate("Command_CIRCLE", "Diameter") + "/" + \
QadMsg.translate("Command_CIRCLE", "Area")
prompt = QadMsg.translate("Command_CIRCLE", "Specify the circle radius or [{0}]: ").format(keyWords)
englishKeyWords = "Diameter" + "/" + "Area"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o una parola chiave
# msg, inputType, default, keyWords, valori positivi
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.KEYWORDS, \
None, \
keyWords, QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DIAMETRO DEL CERCHIO (da step = 2)
elif self.step == 3: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # 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: # se é stato inserito un punto
self.radius = qad_utils.getDistance(self.centerPt, value) / 2
elif type(value) == float: # se é stato inserito un numero reale
self.radius = value
self.plugIn.setLastRadius(self.radius)
circle = QadCircle()
circle.set(self.centerPt, self.radius)
points = circle.asPolyline()
if points is not None:
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio in un layer
if currLayer.geometryType() == QGis.Line:
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
else:
qad_layer.addPolygonToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi
self.waitFor(QadMsg.translate("Command_CIRCLE", "Specify the circle diameter: "), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
None, \
"", \
QadInputModeEnum.NOT_NULL | QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DEL CERCHIO (da step = 1)
elif self.step == 4: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
snapTypeOnSel = self.getPointMapTool().snapTypeOnSelection
value = self.getPointMapTool().point
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
value = msg
snapTypeOnSel = QadSnapTypeEnum.NONE
# se é stato selezionato un punto con la modalità TAN_DEF é un punto differito
if snapTypeOnSel == QadSnapTypeEnum.TAN_DEF and entity.isInitialized():
self.firstPt = None
self.firstPtTan = value
self.firstGeomTan = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.firstGeomTan.transform(coordTransform)
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else: # altrimenti é un punto esplicito
self.firstPt = value
self.plugIn.setLastPoint(value)
# imposto il map tool
self.getPointMapTool().firstPt = self.firstPt
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second point on the circle: "))
self.step = 5
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DEL CERCHIO (da step = 4)
elif self.step == 5: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
snapTypeOnSel = self.getPointMapTool().snapTypeOnSelection
value = self.getPointMapTool().point
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
value = msg
snapTypeOnSel = QadSnapTypeEnum.NONE
# se é stato selezionato un punto con la modalità TAN_DEF é un punto differito
if snapTypeOnSel == QadSnapTypeEnum.TAN_DEF and entity.isInitialized():
self.secondPt = None
self.secondPtTan = value
self.secondGeomTan = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.secondGeomTan.transform(coordTransform)
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_THIRD_PT)
else: # altrimenti é un punto esplicito
self.secondPt = value
self.plugIn.setLastPoint(value)
# imposto il map tool
self.getPointMapTool().secondPt = self.secondPt
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_THIRD_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify the third point on the circle: "))
self.step = 6
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL TERZO PUNTO DEL CERCHIO (da step = 5)
elif self.step == 6: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
snapTypeOnSel = self.getPointMapTool().snapTypeOnSelection
value = self.getPointMapTool().point
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
value = msg
snapTypeOnSel = QadSnapTypeEnum.NONE
# se é stato selezionato un punto con la modalità TAN_DEF é un punto differito
if snapTypeOnSel == QadSnapTypeEnum.TAN_DEF and entity.isInitialized():
self.thirdPt = None
self.thirdPtTan = value
self.thirdGeomTan = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.thirdGeomTan.transform(coordTransform)
else: # altrimenti é un punto esplicito
self.thirdPt = value
self.plugIn.setLastPoint(value)
circle = QadCircle()
points = None
if self.firstPt is None: # se il primo punto é definito con un punto differito
if self.secondPt is None: # se il secondo punto é definito con un punto differito
if self.thirdPt is None: # se il terzo punto é definito con un punto differito
if circle.from3TanPts(self.firstGeomTan, self.firstPtTan, \
self.secondGeomTan, self.secondPtTan, \
self.thirdGeomTan, self.thirdPtTan) == True:
points = circle.asPolyline()
else: # se il terzo punto é definito con un punto esplicito
if circle.from1IntPt2TanPts(self.thirdPt, self.firstGeomTan, self.firstPtTan,
self.secondGeomTan, self.secondPtTan) == True:
points = circle.asPolyline()
else: # se il secondo punto é definito con un punto esplicito
if self.thirdPt is None: # se il terzo punto é definito con un punto differito
if circle.from1IntPt2TanPts(self.secondPt, self.firstGeomTan, self.firstPtTan,
self.thirdGeomTan, self.thirdPtTan) == True:
points = circle.asPolyline()
else: # se il terzo punto é definito con un punto esplicito
if circle.from2IntPts1TanPt(self.secondPt, self.thirdPt, \
self.firstGeomTan, self.firstPtTan) == True:
points = circle.asPolyline()
else: # se il primo punto é definito con un punto esplicito
if self.secondPt is None: # se il secondo punto é definito con un punto differito
if self.thirdPt is None: # se il terzo punto é definito con un punto differito
if circle.from1IntPt2TanPts(self.firstPt, self.secondGeomTan, self.secondPtTan,
self.thirdGeomTan, self.thirdPtTan) == True:
points = circle.asPolyline()
else: # se il terzo punto é definito con un punto esplicito
if circle.from2IntPts1TanPt(self.firstPt, self.thirdPt, \
self.secondGeomTan, self.secondPtTan) == True:
points = circle.asPolyline()
else: # se il secondo punto é definito con un punto esplicito
if self.thirdPt is None: # se il terzo punto é definito con un punto differito
if circle.from2IntPts1TanPt(self.firstPt, self.secondPt, \
self.thirdGeomTan, self.thirdPtTan) == True:
points = circle.asPolyline()
else: # se il terzo punto é definito con un punto esplicito
if circle.from3Pts(self.firstPt, self.secondPt, value) == True:
points = circle.asPolyline()
if points is not None:
self.centerPt = circle.center
self.radius = circle.radius
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio in un layer
if currLayer.geometryType() == QGis.Line:
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
else:
qad_layer.addPolygonToLayer(self.plugIn, currLayer, points)
return True # fine comando
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify the third point on the circle: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA PRIMA ESTREMITA' DIAM DEL CERCHIO (da step = 1)
elif self.step == 7: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
snapTypeOnSel = self.getPointMapTool().snapTypeOnSelection
value = self.getPointMapTool().point
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
value = msg
snapTypeOnSel = QadSnapTypeEnum.NONE
# se é stato selezionato un punto con la modalità TAN_DEF é un punto differito
if snapTypeOnSel == QadSnapTypeEnum.TAN_DEF and entity.isInitialized():
self.firstDiamPt = None
self.firstDiamPtTan = value
self.firstDiamGeomTan = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.firstDiamGeomTan.transform(coordTransform)
# imposto il map tool
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_DIAM_PT_KNOWN_ASK_FOR_SECOND_DIAM_PT)
else: # altrimenti é un punto esplicito
self.firstDiamPt = value
# imposto il map tool
self.getPointMapTool().firstDiamPt = self.firstDiamPt
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_DIAM_PT_KNOWN_ASK_FOR_SECOND_DIAM_PT)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second end of the circle diameter: "))
self.step = 8
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA SECONDA ESTREMITA' DIAM DEL CERCHIO (da step = 7)
elif self.step == 8: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
snapTypeOnSel = self.getPointMapTool().snapTypeOnSelection
value = self.getPointMapTool().point
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
value = msg
snapTypeOnSel = QadSnapTypeEnum.NONE
# se é stato selezionato un punto con la modalità TAN_DEF é un punto differito
if snapTypeOnSel == QadSnapTypeEnum.TAN_DEF and entity.isInitialized():
self.secondDiamPt = None
self.secondDiamPtTan = value
self.secondDiamGeomTan = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.secondDiamGeomTan.transform(coordTransform)
else: # altrimenti é un punto esplicito
self.secondDiamPt = value
circle = QadCircle()
points = None
if self.firstDiamPt is None: # se il diametro é definito con il primo punto differito
if self.secondDiamPt is None: # il diametro é definito con il secondo punto differito
if circle.fromDiamEnds2TanPts(self.firstDiamGeomTan, self.firstDiamPtTan, \
self.secondDiamGeomTan, self.secondDiamPtTan) == True:
points = circle.asPolyline()
else: # se il diametro è definito con il secondo punto esplicito
if circle.fromDiamEndsPtTanPt(self.secondDiamPt, self.firstDiamGeomTan, self.firstDiamPtTan) == True:
points = circle.asPolyline()
else: # se il diametro è definito con il primo punto esplicito
if self.secondDiamPt is None: # il diametro è definito con il secondo punto differito
if circle.fromDiamEndsPtTanPt(self.firstDiamPt, self.secondDiamGeomTan, self.secondDiamPtTan) == True:
points = circle.asPolyline()
else: # se il diametro è definito con il secondo punto esplicito
if circle.fromDiamEnds(self.firstDiamPt, self.secondDiamPt) == True:
points = circle.asPolyline()
if points is not None:
self.centerPt = circle.center
self.radius = circle.radius
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio in un layer
if currLayer.geometryType() == QGis.Line:
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
else:
qad_layer.addPolygonToLayer(self.plugIn, currLayer, points)
return True # fine comand
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second end of the circle diameter: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMA TANGENTE (da step = 1)
elif self.step == 9: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify first tangent element of the circle: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
if not entity.isInitialized(): # se non è stata selezionata una entità
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify first tangent element of the circle: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
wkbType = entity.getGeometry().wkbType()
if wkbType == QGis.WKBPoint or wkbType == QGis.WKBMultiPoint:
self.showErr(QadMsg.translate("Command_CIRCLE", "\nSelect a circle, an arc or a line."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify first tangent element of the circle: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
self.tanGeom1 = QgsGeometry(entity.getGeometry())
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.tanGeom1.transform(coordTransform)
self.tanPt1 = self.getPointMapTool().point
# imposto il map tool
self.getPointMapTool().tanGeom1 = self.tanGeom1
self.getPointMapTool().tanPt1 = self.tanPt1
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_TAN)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second tangent element of the circle: "))
self.step = 10
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDA TANGENTE (da step = 9)
elif self.step == 10: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second tangent element of the circle: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
if not entity.isInitialized(): # se non è stata selezionata una entità
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second tangent element of the circle: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
wkbType = entity.getGeometry().wkbType()
if wkbType == QGis.WKBPoint or wkbType == QGis.WKBMultiPoint:
self.showErr(QadMsg.translate("Command_CIRCLE", "\nSelect a circle, an arc or a line."))
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second tangent element of the circle: "))
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
self.tanGeom2 = QgsGeometry(entity.getGeometry())
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.tanGeom2.transform(coordTransform)
self.tanPt2 = self.getPointMapTool().point
# imposto il map tool
self.getPointMapTool().tanGeom2 = self.tanGeom2
self.getPointMapTool().tanPt2 = self.tanPt2
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_KNOWN_ASK_FOR_RADIUS)
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori positivi
msg = QadMsg.translate("Command_CIRCLE", "Specify the circle radius <{0}>: ")
self.waitFor(msg.format(str(self.plugIn.lastRadius)), \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT, \
self.plugIn.lastRadius, "", \
QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.step = 11
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA RAGGIO (da step = 10)
elif self.step == 11: # 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.startPtForRadius = value
# imposto il map tool
self.getPointMapTool().startPtForRadius = self.startPtForRadius
self.getPointMapTool().setMode(Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_FIRSTPTRADIUS_KNOWN_ASK_FOR_SECONDPTRADIUS)
# si appresta ad attendere un punto
self.waitForPoint(QadMsg.translate("Command_CIRCLE", "Specify second point: "))
self.step = 12
return False
else:
self.plugIn.setLastRadius(value)
circle = QadCircle()
if circle.from2TanPtsRadius(self.tanGeom1, self.tanPt1, \
self.tanGeom2, self.tanPt2, value) == True:
points = circle.asPolyline()
if points is not None:
self.centerPt = circle.center
self.radius = circle.radius
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio in un layer
if currLayer.geometryType() == QGis.Line:
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
else:
qad_layer.addPolygonToLayer(self.plugIn, currLayer, points)
else:
self.showMsg(QadMsg.translate("Command_CIRCLE", "\nThe circle doesn't exist."))
else:
self.showMsg(QadMsg.translate("Command_CIRCLE", "\nThe circle doesn't exist."))
return True # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO DEL RAGGIO (da step = 11)
elif self.step == 12: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.radius = qad_utils.getDistance(self.startPtForRadius, value)
self.plugIn.setLastRadius(self.radius)
circle = QadCircle()
if circle.from2TanPtsRadius(self.tanGeom1, self.tanPt1, \
self.tanGeom2, self.tanPt2, self.radius) == True:
points = circle.asPolyline()
if points is not None:
self.centerPt = circle.center
self.radius = circle.radius
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio in un layer
if currLayer.geometryType() == QGis.Line:
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
else:
qad_layer.addPolygonToLayer(self.plugIn, currLayer, points)
else:
self.showMsg(QadMsg.translate("Command_CIRCLE", "\nThe circle doesn't exist."))
else:
self.showMsg(QadMsg.translate("Command_CIRCLE", "\nThe circle doesn't exist."))
return True # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA AREA DEL CERCHIO (da step = 2)
elif self.step == 13: # dopo aver atteso un numero 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 NON usato il tasto destro del mouse
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) == float: # è stata inserita l'area
self.area = value
circle = QadCircle()
circle.fromCenterArea(self.centerPt, self.area)
self.radius = circle.radius
self.plugIn.setLastRadius(self.radius)
points = circle.asPolyline()
if points is not None:
if self.virtualCmd == False: # se si vuole veramente salvare il cerchio in un layer
if currLayer.geometryType() == QGis.Line:
qad_layer.addLineToLayer(self.plugIn, currLayer, points)
else:
qad_layer.addPolygonToLayer(self.plugIn, currLayer, points)
return True # fine comando
self.isValidPreviousInput = False # per gestire il comando anche in macro
return False
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
return True # fine comando
if self.virtualCmd == False: # se si vuole veramente salvare la polylinea in un layer
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Line)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
# RICHIESTA PRIMO PUNTO
if self.step == 0: # inizio del comando
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)
# si appresta ad attendere un punto o enter
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_LINE", "Specify first point: "), \
QadInputTypeEnum.POINT2D, None, "", QadInputModeEnum.NONE)
self.step = 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO OPPURE MENU PRINCIPALE
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
if self.virtualCmd == False: # se si vuole veramente salvare in un layer
self.addLinesToLayer(currLayer)
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
snapTypeOnSel = self.getPointMapTool().snapTypeOnSelection
value = self.getPointMapTool().point
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
value = msg
snapTypeOnSel = QadSnapTypeEnum.NONE
if type(value) == unicode or type(value) == str:
if value == QadMsg.translate("Command_LINE", "Undo") or value == "Undo":
self.delLastVertex() # cancello ultimo vertice
# imposto il map tool
if len(self.vertices) == 0:
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)
# si appresta ad attendere un punto o enter
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_LINE", "Specify first point: "), \
QadInputTypeEnum.POINT2D, None, "", QadInputModeEnum.NONE)
return False
else:
self.getPointMapTool().firstPt = self.vertices[-1]
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
elif value == QadMsg.translate("Command_LINE", "Close") or value == "Close":
newPt = self.vertices[0]
self.addVertex(newPt) # aggiungo un nuovo vertice
if self.virtualCmd == False: # se si vuole veramente salvare in un layer
self.addLinesToLayer(currLayer)
return True # fine comando
else:
if len(self.vertices) == 0: # primo punto
if value is None:
if self.plugIn.lastPoint is not None:
value = self.plugIn.lastPoint
else:
return True # fine comando
# se é stato selezionato un punto con la modalità TAN_DEF é un punto differito
if snapTypeOnSel == QadSnapTypeEnum.TAN_DEF and entity.isInitialized():
# se era stato selezionato un punto esplicito
if (self.firstPtTan is None) and (self.firstPtPer is None):
self.firstPtPer = None
self.firstPtTan = value
self.firstGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapSettings().destinationCrs()) # trasformo la geometria
self.firstGeom.transform(coordTransform)
# imposto il map tool
self.getPointMapTool().tan1 = self.firstPtTan
self.getPointMapTool().geom1 = self.firstGeom
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT)
# se era stato selezionato un punto con la modalità TAN_DEF
elif self.firstPtTan is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapSettings().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
tangent = qad_utils.lineFrom2TanPts(self.firstGeom, self.firstPtTan, secondGeom, value)
if tangent is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(tangent[0], value) < qad_utils.getDistance(tangent[1], value):
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[0]
else:
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo tangent possible"))
# se era stato selezionato un punto con la modalità PER_DEF
elif self.firstPtPer is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapSettings().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
tangent = qad_utils.lineFromTanPerPts(secondGeom, value, self.firstGeom, self.firstPtPer)
if tangent is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(tangent[0], value) < qad_utils.getDistance(tangent[1], value):
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[0]
else:
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo tangent possible"))
# se é stato selezionato un punto con la modalità PER_DEF é un punto differito
elif snapTypeOnSel == QadSnapTypeEnum.PER_DEF and entity.isInitialized():
# se era stato selezionato un punto esplicito
if (self.firstPtTan is None) and (self.firstPtPer is None):
self.firstPtTan = None
self.firstPtPer = value
self.firstGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapSettings().destinationCrs()) # trasformo la geometria
self.firstGeom.transform(coordTransform)
# imposto il map tool
self.getPointMapTool().per1 = self.firstPtPer
self.getPointMapTool().geom1 = self.firstGeom
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT)
# se era stato selezionato un punto con la modalità TAN_DEF
elif self.firstPtTan is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapSettings().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
tangent = qad_utils.lineFromTanPerPts(self.firstGeom, self.firstPtTan, secondGeom, value)
if tangent is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(tangent[0], value) < qad_utils.getDistance(tangent[1], value):
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[0]
else:
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo perpendicular possible"))
# se era stato selezionato un punto con la modalità PER_DEF
elif self.firstPtPer is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapSettings().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
line = qad_utils.lineFrom2PerPts(self.firstGeom, self.firstPtPer, secondGeom, value)
if line is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(line[0], value) < qad_utils.getDistance(line[1], value):
self.addVertex(line[1]) # aggiungo un nuovo vertice
self.addVertex(line[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = line[0]
else:
self.addVertex(line[0]) # aggiungo un nuovo vertice
self.addVertex(line[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = line[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo perpendicular possible"))
else: # altrimenti é un punto esplicito
# se era stato selezionato un punto con la modalità TAN_DEF
if self.firstPtTan is not None:
snapper = QadSnapper()
snapper.setSnapPointCRS(self.plugIn.canvas.mapSettings().destinationCrs())
snapper.setSnapType(QadSnapTypeEnum.TAN)
snapper.setStartPoint(value)
oSnapPoints = snapper.getSnapPoint(self.firstGeom, self.firstPtTan,
self.plugIn.canvas.mapSettings().destinationCrs())
# memorizzo il punto di snap in point (prendo il primo valido)
for item in oSnapPoints.items():
points = item[1]
if points is not None:
self.addVertex(points[0]) # aggiungo un nuovo vertice
self.addVertex(value) # aggiungo un nuovo vertice
break
if len(self.vertices) == 0:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo tangent possible"))
# se era stato selezionato un punto con la modalità PER_DEF
elif self.firstPtPer is not None:
snapper = QadSnapper()
snapper.setSnapPointCRS(self.plugIn.canvas.mapSettings().destinationCrs())
snapper.setSnapType(QadSnapTypeEnum.PER)
snapper.setStartPoint(value)
oSnapPoints = snapper.getSnapPoint(self.firstGeom, self.firstPtPer,
self.plugIn.canvas.mapSettings().destinationCrs())
# memorizzo il punto di snap in point (prendo il primo valido)
for item in oSnapPoints.items():
points = item[1]
if points is not None:
self.addVertex(points[0]) # aggiungo un nuovo vertice
self.addVertex(value) # aggiungo un nuovo vertice
break
if len(self.vertices) == 0:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo perpendicular possible"))
else:
self.addVertex(value) # aggiungo un nuovo vertice
if len(self.vertices) > 0:
# imposto il map tool
self.getPointMapTool().firstPt = value
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else: # secondo punto
if value is None:
if self.virtualCmd == False: # se si vuole veramente salvare in un layer
self.addLinesToLayer(currLayer)
return True # fine comando
# se il primo punto é esplicito
if len(self.vertices) > 0 is not None:
self.addVertex(value) # aggiungo un nuovo vertice
# imposto il map tool
self.getPointMapTool().firstPt = value
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
if len(self.vertices) > 2:
keyWords = QadMsg.translate("Command_LINE", "Close") + "/" + \
QadMsg.translate("Command_LINE", "Undo")
else:
keyWords = QadMsg.translate("Command_LINE", "Undo")
prompt = QadMsg.translate("Command_LINE", "Specify next point or [{0}]: ").format(keyWords)
englishKeyWords = "Close" + "/" + "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)
return 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
if self.virtualCmd == False: # se si vuole veramente salvare la polylinea in un layer
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Line)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
# RICHIESTA PRIMO PUNTO
if self.step == 0: # inizio del comando
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)
# si appresta ad attendere un punto o enter
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_LINE", "Specify first point: "), \
QadInputTypeEnum.POINT2D, None, "", QadInputModeEnum.NONE)
self.step = 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO OPPURE MENU PRINCIPALE
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
if self.virtualCmd == False: # se si vuole veramente salvare in un layer
self.addLinesToLayer(currLayer)
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
snapTypeOnSel = self.getPointMapTool().snapTypeOnSelection
value = self.getPointMapTool().point
entity = self.getPointMapTool().entity
else: # il punto arriva come parametro della funzione
value = msg
snapTypeOnSel = QadSnapTypeEnum.NONE
if type(value) == unicode:
if value == QadMsg.translate("Command_LINE", "Undo") or value == "Undo":
self.delLastVertex() # cancello ultimo vertice
# imposto il map tool
if len(self.vertices) == 0:
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)
# si appresta ad attendere un punto o enter
# msg, inputType, default, keyWords, nessun controllo
self.waitFor(QadMsg.translate("Command_LINE", "Specify first point: "), \
QadInputTypeEnum.POINT2D, None, "", QadInputModeEnum.NONE)
return False
else:
self.getPointMapTool().firstPt = self.vertices[-1]
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
elif value == QadMsg.translate("Command_LINE", "Close") or value == "Close":
newPt = self.vertices[0]
self.addVertex(newPt) # aggiungo un nuovo vertice
if self.virtualCmd == False: # se si vuole veramente salvare in un layer
self.addLinesToLayer(currLayer)
return True # fine comando
else:
if len(self.vertices) == 0: # primo punto
if value is None:
if self.plugIn.lastPoint is not None:
value = self.plugIn.lastPoint
else:
return True # fine comando
# se é stato selezionato un punto con la modalità TAN_DEF é un punto differito
if snapTypeOnSel == QadSnapTypeEnum.TAN_DEF and entity.isInitialized():
# se era stato selezionato un punto esplicito
if (self.firstPtTan is None) and (self.firstPtPer is None):
self.firstPtPer = None
self.firstPtTan = value
self.firstGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.firstGeom.transform(coordTransform)
# imposto il map tool
self.getPointMapTool().tan1 = self.firstPtTan
self.getPointMapTool().geom1 = self.firstGeom
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_TAN_KNOWN_ASK_FOR_SECOND_PT)
# se era stato selezionato un punto con la modalità TAN_DEF
elif self.firstPtTan is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
tangent = qad_utils.lineFrom2TanPts(self.firstGeom, self.firstPtTan, secondGeom, value)
if tangent is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(tangent[0], value) < qad_utils.getDistance(tangent[1], value):
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[0]
else:
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo tangent possible"))
# se era stato selezionato un punto con la modalità PER_DEF
elif self.firstPtPer is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
tangent = qad_utils.lineFromTanPerPts(secondGeom, value, self.firstGeom, self.firstPtPer)
if tangent is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(tangent[0], value) < qad_utils.getDistance(tangent[1], value):
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[0]
else:
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo tangent possible"))
# se é stato selezionato un punto con la modalità PER_DEF é un punto differito
elif snapTypeOnSel == QadSnapTypeEnum.PER_DEF and entity.isInitialized():
# se era stato selezionato un punto esplicito
if (self.firstPtTan is None) and (self.firstPtPer is None):
self.firstPtTan = None
self.firstPtPer = value
self.firstGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
self.firstGeom.transform(coordTransform)
# imposto il map tool
self.getPointMapTool().per1 = self.firstPtPer
self.getPointMapTool().geom1 = self.firstGeom
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PER_KNOWN_ASK_FOR_SECOND_PT)
# se era stato selezionato un punto con la modalità TAN_DEF
elif self.firstPtTan is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
tangent = qad_utils.lineFromTanPerPts(self.firstGeom, self.firstPtTan, secondGeom, value)
if tangent is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(tangent[0], value) < qad_utils.getDistance(tangent[1], value):
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[0]
else:
self.addVertex(tangent[0]) # aggiungo un nuovo vertice
self.addVertex(tangent[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = tangent[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo perpendicular possible"))
# se era stato selezionato un punto con la modalità PER_DEF
elif self.firstPtPer is not None:
secondGeom = QgsGeometry(entity.getGeometry()) # duplico la geometria
coordTransform = QgsCoordinateTransform(entity.layer.crs(), self.plugIn.canvas.mapRenderer().destinationCrs()) # trasformo la geometria
secondGeom.transform(coordTransform)
line = qad_utils.lineFrom2PerPts(self.firstGeom, self.firstPtPer, secondGeom, value)
if line is not None:
# prendo il punto più vicino a value
if qad_utils.getDistance(line[0], value) < qad_utils.getDistance(line[1], value):
self.addVertex(line[1]) # aggiungo un nuovo vertice
self.addVertex(line[0]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = line[0]
else:
self.addVertex(line[0]) # aggiungo un nuovo vertice
self.addVertex(line[1]) # aggiungo un nuovo vertice
self.getPointMapTool().firstPt = line[1]
# imposto il map tool
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo perpendicular possible"))
else: # altrimenti é un punto esplicito
# se era stato selezionato un punto con la modalità TAN_DEF
if self.firstPtTan is not None:
snapper = QadSnapper()
snapper.setSnapPointCRS(self.plugIn.canvas.mapRenderer().destinationCrs())
snapper.setSnapType(QadSnapTypeEnum.TAN)
snapper.setStartPoint(value)
oSnapPoints = snapper.getSnapPoint(self.firstGeom, self.firstPtTan,
self.plugIn.canvas.mapRenderer().destinationCrs())
# memorizzo il punto di snap in point (prendo il primo valido)
for item in oSnapPoints.items():
points = item[1]
if points is not None:
self.addVertex(points[0]) # aggiungo un nuovo vertice
self.addVertex(value) # aggiungo un nuovo vertice
break
if len(self.vertices) == 0:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo tangent possible"))
# se era stato selezionato un punto con la modalità PER_DEF
elif self.firstPtPer is not None:
snapper = QadSnapper()
snapper.setSnapPointCRS(self.plugIn.canvas.mapRenderer().destinationCrs())
snapper.setSnapType(QadSnapTypeEnum.PER)
snapper.setStartPoint(value)
oSnapPoints = snapper.getSnapPoint(self.firstGeom, self.firstPtPer,
self.plugIn.canvas.mapRenderer().destinationCrs())
# memorizzo il punto di snap in point (prendo il primo valido)
for item in oSnapPoints.items():
points = item[1]
if points is not None:
self.addVertex(points[0]) # aggiungo un nuovo vertice
self.addVertex(value) # aggiungo un nuovo vertice
break
if len(self.vertices) == 0:
self.showMsg(QadMsg.translate("Command_LINE", "\nNo perpendicular possible"))
else:
self.addVertex(value) # aggiungo un nuovo vertice
if len(self.vertices) > 0:
# imposto il map tool
self.getPointMapTool().firstPt = value
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
else: # secondo punto
if value is None:
if self.virtualCmd == False: # se si vuole veramente salvare in un layer
self.addLinesToLayer(currLayer)
return True # fine comando
# se il primo punto é esplicito
if len(self.vertices) > 0 is not None:
self.addVertex(value) # aggiungo un nuovo vertice
# imposto il map tool
self.getPointMapTool().firstPt = value
self.getPointMapTool().setMode(Qad_line_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)
if len(self.vertices) > 2:
keyWords = QadMsg.translate("Command_LINE", "Close") + "/" + \
QadMsg.translate("Command_LINE", "Undo")
else:
keyWords = QadMsg.translate("Command_LINE", "Undo")
prompt = QadMsg.translate("Command_LINE", "Specify next point or [{0}]: ").format(keyWords)
englishKeyWords = "Close" + "/" + "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)
return False
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"
)
)
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate("QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate("QAD", "\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
if len(QadDimStyles.getDimListByLayer(currLayer)) > 0:
errMsg = QadMsg.translate("QAD", "\nThe current layer belongs to a dimension style.\n")
self.showErr(errMsg)
return True # fine comando
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
return False # continua
# =========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ENT:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
# se il layer di destinazione è di tipo simbolo
if qad_layer.isSymbolLayer(currLayer) == True:
# se il simbolo può essere ruotato
if len(qad_layer.get_symbolRotationFieldName(currLayer)) > 0:
self.waitForAlignmentObjs()
else:
self.waitForSegmentNumber()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine comando
return True
self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
# =========================================================================
# RISPOSTA ALLA RICHIESTA DI ALLINEARE GLI OGGETTI (da step = ASK_FOR_ENT)
elif (
self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT
): # dopo aver atteso una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
value = self.defaultValue
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
# la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("QAD", "Yes") or value == "Yes":
self.objectAlignment = True
else:
self.objectAlignment = False
self.waitForSegmentNumber()
return False
# =========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI SEGMENTI (da step = ASK_FOR_ALIGNMENT)
# =========================================================================
elif (
self.step == QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER
): # dopo aver atteso un numero intero si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
# il numero di segmenti arriva come parametro della funzione
self.nSegments = msg
self.doDivide(currLayer)
return True # fine comando
return False
def run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(
self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isSymbolLayer(currLayer) == False:
errMsg = QadMsg.translate(
"QAD", "\nCurrent layer is not a symbol layer.")
errMsg = errMsg + QadMsg.translate(
"QAD",
"\nA symbol layer is a vector punctual layer without label.\n")
self.showErr(errMsg)
return True # fine comando
if len(QadDimStyles.getDimListByLayer(currLayer)) > 0:
errMsg = QadMsg.translate(
"QAD", "\nThe current layer belongs to a dimension style.\n")
self.showErr(errMsg)
return True # fine comando
if self.step == 0:
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA SELEZIONE DI UN'ENTITA' (da step = 0)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ENT:
if self.entSelClass.run(msgMapTool, msg) == True:
if self.entSelClass.entity.isInitialized():
# se il layer di destinazione è di tipo simbolo
if qad_layer.isSymbolLayer(currLayer) == True:
# se il simbolo può essere ruotato
if len(qad_layer.get_symbolRotationFieldName(
currLayer)) > 0:
self.waitForAlignmentObjs()
else:
self.waitForSegmentNumber()
return False
else:
if self.entSelClass.canceledByUsr == True: # fine comando
return True
self.showMsg(
QadMsg.translate("QAD",
"No geometries in this position."))
self.waitForEntsel(msgMapTool, msg)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI ALLINEARE GLI OGGETTI (da step = ASK_FOR_ENT)
elif self.step == QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT: # dopo aver atteso una parola chiave si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
value = self.defaultValue
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
else:
# la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("QAD", "Yes") or value == "Yes":
self.objectAlignment = True
else:
self.objectAlignment = False
self.waitForSegmentNumber()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI SEGMENTI (da step = ASK_FOR_ALIGNMENT)
#=========================================================================
elif self.step == QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER: # dopo aver atteso un numero intero si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
return False
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
else:
# il numero di segmenti arriva come parametro della funzione
self.nSegments = msg
self.doDivide(currLayer)
return True # fine comando
return False
def 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
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDO PUNTO DELLA LARGHEZZA BUFFER (da step = 2)
elif self.step == 3: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
self.width = qad_utils.getDistance(self.startPtForBufferWidth, 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 run(self, msgMapTool=False, msg=None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(
QadMsg.translate(
"QAD",
"\nThe coordinate reference system of the project must be a projected coordinate system.\n"
))
return True # fine comando
currLayer, errMsg = qad_layer.getCurrLayerEditable(
self.plugIn.canvas, QGis.Point)
if currLayer is None:
self.showErr(errMsg)
return True # fine comando
if qad_layer.isTextLayer(currLayer) == False:
errMsg = QadMsg.translate(
"QAD", "\nCurrent layer is not a textual layer.")
errMsg = errMsg + QadMsg.translate(
"QAD",
"\nA textual layer is a vector punctual layer having a label and the symbol transparency no more than 10%.\n"
)
self.showErr(errMsg)
return True # fine comando
#=========================================================================
# RICHIESTA PUNTO DI INSERIMENTO
if self.step == 0: # inizio del comando
self.waitForPoint() # si appresta ad attendere un punto
self.step = self.step + 1
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA PUNTO DI INSERIMENTO
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# éstato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool(
).point is None: # il maptool éstato attivato senza un punto
if self.getPointMapTool(
).rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(
self.getPointMapTool()) # riattivo il maptool
return False
pt = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
pt = msg
self.insPt = QgsPoint(pt)
self.plugIn.setLastPoint(self.insPt)
# se l'altezza testo dipende da un solo campo
sizeFldNames = qad_label.get_labelSizeFieldNames(currLayer)
if len(sizeFldNames) == 1 and len(sizeFldNames[0]) > 0:
# si appresta ad attendere la scala
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_TEXT",
"Specify the text height <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.hText))
self.GetDistClass.dist = self.hText
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE | QadInputModeEnum.NOT_ZERO
self.GetDistClass.startPt = self.insPt
self.step = 2
self.GetDistClass.run(msgMapTool, msg)
return False
else:
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(currLayer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate(
"Command_TEXT", "Specify the text rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(
str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.initLabelFields(currLayer)
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ALTEZZA TESTO (da step = 1)
elif self.step == 2:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.hText = self.GetDistClass.dist
self.plugIn.setLastHText(self.hText)
del self.GetDistClass
self.GetDistClass = None
# se la rotazione dipende da un solo campo
rotFldNames = qad_label.get_labelRotationFieldNames(
currLayer)
if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
if self.GetAngleClass is not None:
del self.GetAngleClass
# si appresta ad attendere l'angolo di rotazione
self.GetAngleClass = QadGetAngleClass(self.plugIn)
prompt = QadMsg.translate(
"Command_TEXT",
"Specify the text rotation <{0}>: ")
self.GetAngleClass.msg = prompt.format(
str(qad_utils.toDegrees(self.rot)))
self.GetAngleClass.angle = self.rot
self.GetAngleClass.startPt = self.insPt
self.step = 3
self.GetAngleClass.run(msgMapTool, msg)
return False
else:
self.initLabelFields(currLayer)
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE (da step = 1 o 2)
elif self.step == 3:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.initLabelFields(currLayer)
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True # fine comando
else:
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL VALORE DI UN CAMPO
elif self.step == 4: # dopo aver atteso un valore si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
self.waitForFieldValue()
return False
# il valore arriva come parametro della funzione
self.labelFieldValues.append(msg)
self.labelFieldNamesNdx = self.labelFieldNamesNdx + 1
if self.waitForFieldValue() == False:
self.addFeature(currLayer)
return True # fine comando
return False
def run(self, msgMapTool = False, msg = None):
if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
return True # fine comando
currLayer = 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
#=========================================================================
# RICHIESTA NUMERO DI LATI DEL POLIGONO
if self.step == 0: # inizio del comando
self.WaitForSideNumber()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI LATI DEL POLIGONO (da step = 0)
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
value = self.sideNumber
else:
return False
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == int:
if value < 3:
self.showErr(QadMsg.translate("Command_POLYGON", "\nEnter an integer greater than 2."))
else:
self.sideNumber = value
self.getPointMapTool().sideNumber = self.sideNumber
self.plugIn.setLastPolygonSideNumber(self.sideNumber)
self.WaitForCenter()
else:
self.WaitForSideNumber()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL CENTRO DEL POLIGONO (da step = 1)
elif self.step == 2: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
self.WaitForCenter()
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_POLYGON", "Edge") or value == "Edge":
self.WaitForFirstEdgePt()
elif type(value) == QgsPoint:
self.centerPt = value
self.getPointMapTool().centerPt = self.centerPt
self.WaitForInscribedCircumscribedOption()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI POLIGONO INSCRITTO O CIRCOSCRITTO (da step = 2)
elif self.step == 3:
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.constructionModeByCenter
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
value = self.getPointMapTool().point
else: # la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
self.constructionModeByCenter = value
self.plugIn.setLastPolygonConstructionModeByCenter(self.constructionModeByCenter)
self.getPointMapTool().constructionModeByCenter = self.constructionModeByCenter
if self.constructionModeByCenter == QadMsg.translate("Command_POLYGON", "Area") or self.constructionModeByCenter == "Area":
self.WaitForArea()
else:
self.WaitForRadius(currLayer)
return False # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL RAGGIO (da step = 3)
elif self.step == 4:
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 or type(value) == float: # se é stato inserito il raggio del cerchio
if type(value) == QgsPoint: # se é stato inserito il raggio del cerchio con un punto
self.radius = qad_utils.getDistance(self.centerPt, value)
ptStart = value
else:
self.radius = value
ptStart = None
self.plugIn.setLastRadius(self.radius)
if self.constructionModeByCenter == QadMsg.translate("Command_POLYGON", "Inscribed in circle") or \
self.constructionModeByCenter == "Inscribed in circle":
mode = True
else:
mode = False
self.vertices.extend(qad_utils.getPolygonByNsidesCenterRadius(self.sideNumber, self.centerPt, self.radius, \
mode, ptStart))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addPolygonToLayer(currLayer)
return True
return False # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DELLO SPIGOLO (da step = 2)
elif self.step == 5: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint:
self.firstEdgePt = value
self.WaitForSecondEdgePt(currLayer)
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DELLO SPIGOLO (da step = 5)
elif self.step == 6: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint:
self.vertices.extend(qad_utils.getPolygonByNsidesEdgePts(self.sideNumber, self.firstEdgePt, value))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addPolygonToLayer(currLayer)
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA AREA POLIGONO (da step = 3)
elif self.step == 7: # dopo aver atteso 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.area
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
return False
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == float: # é stata inserita l'area
self.vertices.extend(qad_utils.getPolygonByNsidesArea(self.sideNumber, self.centerPt, value))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addPolygonToLayer(currLayer)
return True
return 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
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
#=========================================================================
# RICHIESTA PRIMO PUNTO
if self.step == 0: # inizio del comando
self.WaitForFirstCorner()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DEL RETTANGOLO (da step = 0)
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
self.showMsg(QadMsg.translate("Command_RECTANGLE", "Window not correct."))
self.WaitForFirstCorner()
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_RECTANGLE", "Chamfer") or value == "Chamfer":
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_RECTANGLE", "Specify first chamfer distance for rectangle <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.gapValue1))
self.GetDistClass.dist = self.gapValue1
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE
self.step = 4
self.GetDistClass.run(msgMapTool, msg)
elif value == QadMsg.translate("Command_RECTANGLE", "Fillet") or value == "Fillet":
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_RECTANGLE", "Specify rectangle fillet radius <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.gapValue1))
self.GetDistClass.dist = self.gapValue1
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE
self.step = 3
self.GetDistClass.run(msgMapTool, msg)
elif type(value) == QgsPoint:
self.firstCorner = value
self.getPointMapTool().firstCorner = self.firstCorner
self.WaitForSecondCorner(currLayer)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DEL RETTANGOLO (da step = 1)
elif self.step == 2: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
self.showMsg(QadMsg.translate("Command_RECTANGLE", "Window not correct."))
self.WaitForSecondCorner(currLayer)
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_RECTANGLE", "Area") or value == "Area":
msg = QadMsg.translate("Command_RECTANGLE", "Enter rectangle area in current units <{0}>: ")
# si appresta ad attendere un numero reale
# msg, inputType, default, keyWords, valori positivi
self.waitFor(msg.format(str(self.area)), QadInputTypeEnum.FLOAT, \
self.area, "", \
QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)
self.getPointMapTool().setMode(Qad_rectangle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_CORNER)
self.step = 6
elif value == QadMsg.translate("Command_RECTANGLE", "Dimensions") or value == "Dimensions":
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_RECTANGLE", "Specify length for rectangle <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.dim1))
self.GetDistClass.dist = self.dim1
self.step = 10
self.GetDistClass.run(msgMapTool, msg)
elif value == QadMsg.translate("Command_RECTANGLE", "Rotation") or value == "Rotation":
keyWords = QadMsg.translate("Command_RECTANGLE", "Points")
self.defaultValue = self.rot
prompt = QadMsg.translate("Command_RECTANGLE", "Specify rotation angle or [{0}] <{1}>: ").format(keyWords, str(qad_utils.toDegrees(self.rot)))
englishKeyWords = "Points"
keyWords += "_" + englishKeyWords
# si appresta ad attendere un punto o un numero reale
# msg, inputType, default, keyWords, valori non nulli
self.waitFor(prompt, \
QadInputTypeEnum.POINT2D | QadInputTypeEnum.FLOAT | QadInputTypeEnum.KEYWORDS, \
self.rot, keyWords)
self.getPointMapTool().setMode(Qad_rectangle_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_CORNER)
self.step = 12
elif type(value) == QgsPoint:
self.vertices.extend(qad_utils.getRectByCorners(self.firstCorner, value, self.rot, \
self.gapType, self.gapValue1, self.gapValue2))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addRectangleToLayer(currLayer)
return True
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA RAGGIO DI CURVATURA (da step = 1)
elif self.step == 3:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.gapValue1 = self.GetDistClass.dist
if self.gapValue1 == 0:
self.gapType = 0 # 0 = Angoli retti
else:
self.gapType = 1 # 1 = Raccorda i segmenti
self.WaitForFirstCorner()
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di distanza
return False # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA PRIMA DISTANZA DI CIMATURA (da step = 1)
elif self.step == 4:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.gapValue1 = self.GetDistClass.dist
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_RECTANGLE", "Specify second chamfer distance for rectangle <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.gapValue2))
self.GetDistClass.dist = self.gapValue2
self.GetDistClass.inputMode = QadInputModeEnum.NOT_NEGATIVE
self.step = 5
self.GetDistClass.run(msgMapTool, msg)
else:
self.WaitForFirstCorner()
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di distanza
return False # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA SECONDA DISTANZA DI CIMATURA (da step = 1)
elif self.step == 5:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.gapValue2 = self.GetDistClass.dist
if self.gapValue1 == 0 or self.gapValue2 == 0:
self.gapType = 0 # 0 = Angoli retti
else:
self.gapType = 2 # 2 = Cima i segmenti
self.WaitForFirstCorner()
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di distanza
return False # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA AREA RETTANGOLO (da step = 2)
elif self.step == 6: # dopo aver atteso un punto si riavvia il comando
keyWords = QadMsg.translate("Command_RECTANGLE", "Length") + "/" + \
QadMsg.translate("Command_RECTANGLE", "Width")
englishKeyWords = "Length" + "/" + "Width"
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
self.defaultValue = QadMsg.translate("Command_RECTANGLE", "Length")
prompt = QadMsg.translate("Command_RECTANGLE", "Calcolate the rectangle dimensions based on [{0}] <{1}>: ").format(keyWords, self.defaultValue)
keyWords += "_" + englishKeyWords
# si appresta ad attendere una parola chiave
# msg, inputType, default, keyWords, valori positivi
self.waitFor(prompt, QadInputTypeEnum.KEYWORDS, \
self.defaultValue, \
keyWords, QadInputModeEnum.NONE)
self.step = 7
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == float: # é stata inserita l'area
self.area = value
self.defaultValue = QadMsg.translate("Command_RECTANGLE", "Length")
prompt = QadMsg.translate("Command_RECTANGLE", "Calcolate the rectangle dimensions based on [{0}] <{1}>: ").format(keyWords, self.defaultValue)
keyWords += "_" + englishKeyWords
# si appresta ad attendere una parola chiave
# msg, inputType, default, keyWords, valori positivi
self.waitFor(prompt, QadInputTypeEnum.KEYWORDS, \
self.defaultValue, \
keyWords, QadInputModeEnum.NONE)
self.step = 7
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DELLA MODALITA' (LUNGHEZZA / LARGHEZZA) DATA L'AREA (da step = 6)
elif self.step == 7: # 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.defaultValue
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
return False
else: # il punto arriva come parametro della funzione
value = msg
if value == QadMsg.translate("Command_RECTANGLE", "Length") or value == "Length":
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_RECTANGLE", "Enter length for rectangle <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.dim1))
self.GetDistClass.dist = self.dim1
self.step = 8
self.GetDistClass.run(msgMapTool, msg)
elif value == QadMsg.translate("Command_RECTANGLE", "Width") or value == "Width":
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_RECTANGLE", "Enter width for rectangle <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.dim1))
self.GetDistClass.dist = self.dim1
self.step = 9
self.GetDistClass.run(msgMapTool, msg)
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA LUNGHEZZA RETTANGOLO DATA L'AREA (da step = 7)
elif self.step == 8:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.vertices.extend(qad_utils.getRectByAreaAndLength(self.firstCorner, self.area, self.GetDistClass.dist, \
self.rot, self.gapType, self.gapValue1, self.gapValue2))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addRectangleToLayer(currLayer)
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA LARGHEZZA RETTANGOLO DATA L'AREA (da step = 7)
elif self.step == 9:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.vertices.extend(qad_utils.getRectByAreaAndWidth(self.firstCorner, self.area, self.GetDistClass.dist, \
self.rot, self.gapType, self.gapValue1, self.gapValue2))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addRectangleToLayer(currLayer)
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA LUNGHEZZA RETTANGOLO (da step = 2)
elif self.step == 10:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.dim1 = self.GetDistClass.dist
if self.GetDistClass is not None:
del self.GetDistClass
self.GetDistClass = QadGetDistClass(self.plugIn)
prompt = QadMsg.translate("Command_RECTANGLE", "Enter width for rectangle <{0}>: ")
self.GetDistClass.msg = prompt.format(str(self.dim1))
self.GetDistClass.dist = self.dim1
self.step = 11
self.GetDistClass.run(msgMapTool, msg)
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA LARGHEZZA RETTANGOLO (da step = 10)
elif self.step == 11:
if self.GetDistClass.run(msgMapTool, msg) == True:
if self.GetDistClass.dist is not None:
self.vertices.extend(qad_utils.getRectByCornerAndDims(self.firstCorner, self.dim1, self.GetDistClass.dist, \
self.rot, self.gapType, self.gapValue1, self.gapValue2))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addRectangleToLayer(currLayer)
return True # fine comando
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE RETTANGOLO (da step = 2)
elif self.step == 12: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
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_RECTANGLE", "Points") or value == "Points":
# si appresta ad attendere l'angolo di rotazione
if self.GetAngleClass is not None:
del self.GetAngleClass
self.GetAngleClass = QadGetAngleClass(self.plugIn)
self.GetAngleClass.msg = QadMsg.translate("Command_RECTANGLE", "Specify first point: ")
self.GetAngleClass.angle = self.rot
self.step = 13
self.GetAngleClass.run(msgMapTool, msg)
elif type(value) == QgsPoint:
self.rot = qad_utils.getAngleBy2Pts(self.firstCorner, value)
self.WaitForSecondCorner(currLayer)
elif type(value) == float:
self.rot = qad_utils.toRadians(value)
self.WaitForSecondCorner(currLayer)
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA ROTAZIONE RETTANGOLO (da step = 12)
elif self.step == 13:
if self.GetAngleClass.run(msgMapTool, msg) == True:
if self.GetAngleClass.angle is not None:
self.rot = self.GetAngleClass.angle
self.plugIn.setLastRot(self.rot)
self.WaitForSecondCorner(currLayer)
self.getPointMapTool().refreshSnapType() # aggiorno lo snapType che può essere variato dal maptool di rotazione
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
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
#=========================================================================
# RICHIESTA NUMERO DI LATI DEL POLIGONO
if self.step == 0: # inizio del comando
self.WaitForSideNumber()
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL NUMERO DI LATI DEL POLIGONO (da step = 0)
elif self.step == 1: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
value = self.sideNumber
else:
return False
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == int:
if value < 3:
self.showErr(QadMsg.translate("Command_POLYGON", "\nEnter an integer greater than 2."))
else:
self.sideNumber = value
self.getPointMapTool().sideNumber = self.sideNumber
self.plugIn.setLastPolygonSideNumber(self.sideNumber)
self.WaitForCenter()
else:
self.WaitForSideNumber()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL CENTRO DEL POLIGONO (da step = 1)
elif self.step == 2: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
self.WaitForCenter()
return False
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == unicode:
if value == QadMsg.translate("Command_POLYGON", "Edge") or value == "Edge":
self.WaitForFirstEdgePt()
elif type(value) == QgsPoint:
self.centerPt = value
self.getPointMapTool().centerPt = self.centerPt
self.WaitForInscribedCircumscribedOption()
return False # continua
#=========================================================================
# RISPOSTA ALLA RICHIESTA DI POLIGONO INSCRITTO O CIRCOSCRITTO (da step = 2)
elif self.step == 3:
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.constructionModeByCenter
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
value = self.getPointMapTool().point
else: # la parola chiave arriva come parametro della funzione
value = msg
if type(value) == unicode:
self.constructionModeByCenter = value
self.plugIn.setLastPolygonConstructionModeByCenter(self.constructionModeByCenter)
self.getPointMapTool().constructionModeByCenter = self.constructionModeByCenter
if self.constructionModeByCenter == QadMsg.translate("Command_POLYGON", "Area") or self.constructionModeByCenter == "Area":
self.WaitForArea()
else:
self.WaitForRadius(currLayer)
return False # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL RAGGIO (da step = 3)
elif self.step == 4:
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 or type(value) == float: # se é stato inserito il raggio del cerchio
if type(value) == QgsPoint: # se é stato inserito il raggio del cerchio con un punto
self.radius = qad_utils.getDistance(self.centerPt, value)
ptStart = value
else:
self.radius = value
ptStart = None
self.plugIn.setLastRadius(self.radius)
if self.constructionModeByCenter == QadMsg.translate("Command_POLYGON", "Inscribed in circle") or \
self.constructionModeByCenter == "Inscribed in circle":
mode = True
else:
mode = False
self.vertices.extend(qad_utils.getPolygonByNsidesCenterRadius(self.sideNumber, self.centerPt, self.radius, \
mode, ptStart))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addPolygonToLayer(currLayer)
return True
return False # fine comando
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL PRIMO PUNTO DELLO SPIGOLO (da step = 2)
elif self.step == 5: # dopo aver atteso un punto si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint:
self.firstEdgePt = value
self.WaitForSecondEdgePt(currLayer)
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA DEL SECONDO PUNTO DELLO SPIGOLO (da step = 5)
elif self.step == 6: # dopo aver atteso un punto o un numero reale si riavvia il comando
if msgMapTool == True: # il punto arriva da una selezione grafica
# la condizione seguente si verifica se durante la selezione di un punto
# é stato attivato un altro plugin che ha disattivato Qad
# quindi stato riattivato il comando che torna qui senza che il maptool
# abbia selezionato un punto
if self.getPointMapTool().point is None: # il maptool é stato attivato senza un punto
if self.getPointMapTool().rightButton == True: # se usato il tasto destro del mouse
return True # fine comando
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
value = self.getPointMapTool().point
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == QgsPoint:
self.vertices.extend(qad_utils.getPolygonByNsidesEdgePts(self.sideNumber, self.firstEdgePt, value))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addPolygonToLayer(currLayer)
return True
return False
#=========================================================================
# RISPOSTA ALLA RICHIESTA AREA POLIGONO (da step = 3)
elif self.step == 7: # dopo aver atteso 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.area
else:
self.setMapTool(self.getPointMapTool()) # riattivo il maptool
return False
else:
return False
else: # il punto arriva come parametro della funzione
value = msg
if type(value) == float: # é stata inserita l'area
self.vertices.extend(qad_utils.getPolygonByNsidesArea(self.sideNumber, self.centerPt, value))
if self.virtualCmd == False: # se si vuole veramente salvare i buffer in un layer
self.addPolygonToLayer(currLayer)
return True
return False
