Python qad_entsel_cmd.QadEntSelClass类代码示例

 def waitForEntsel(self, msgMapTool, msg):
    if self.EntSelClass is not None:
       del self.EntSelClass            
    self.EntSelClass = QadEntSelClass(self.plugIn)
    self.EntSelClass.msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "Select object whose layer will be the current layer: ")
    self.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
    self.EntSelClass.run(msgMapTool, msg)

 def waitForEntsel(self, msgMapTool, msg):
    if self.entSelClass is not None:
       del self.entSelClass
    self.step = 1
    self.entSelClass = QadEntSelClass(self.plugIn)
    self.entSelClass.msg = QadMsg.translate("Command_DISJOIN", "Select object to disjoin: ")
    # scarto la selezione di quote
    self.entSelClass.checkDimLayers = False     
    self.entSelClass.onlyEditableLayers = True
    self.entSelClass.deselectOnFinish = True
    
    self.entSelClass.run(msgMapTool, msg)

 def waitForEntsel(self, msgMapTool, msg):
    if self.EntSelClass is not None:
       del self.EntSelClass
    self.step = 1     
    self.EntSelClass = QadEntSelClass(self.plugIn)
    self.EntSelClass.msg = QadMsg.translate("Command_DIM", "Select arc or polyline arc segment: ")
    # scarto la selezione di punti
    self.EntSelClass.checkPointLayer = False
    self.EntSelClass.checkLineLayer = True
    self.EntSelClass.checkPolygonLayer = True
    self.EntSelClass.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)         
    self.EntSelClass.run(msgMapTool, msg)

   def waitForBoundary(self, msgMapTool, msg):
      if self.entSelClass is not None:
         del self.entSelClass
      self.entSelClass = QadEntSelClass(self.plugIn)
      self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select boundary: ")
      # scarto la selezione di punti e polilinee
      self.entSelClass.checkPointLayer = False
      self.entSelClass.checkLineLayer = False
      self.entSelClass.checkPolygonLayer = True
      self.entSelClass.checkDimLayers = False
      self.entSelClass.onlyEditableLayers = True

      self.entSelClass.run(msgMapTool, msg)

    def waitForEntsel(self, msgMapTool, msg):
        if self.EntSelClass is not None:
            del self.EntSelClass
        self.step = 1
        self.EntSelClass = QadEntSelClass(self.plugIn)
        self.EntSelClass.msg = QadMsg.translate("Command_BREAK", "Select the object to break: ")
        # scarto la selezione di punti e poligoni
        self.EntSelClass.checkPointLayer = False
        self.EntSelClass.checkLineLayer = True
        self.EntSelClass.checkPolygonLayer = False
        self.EntSelClass.checkDimLayers = False
        self.EntSelClass.onlyEditableLayers = True

        self.EntSelClass.run(msgMapTool, msg)

    def waitForEntsel(self, msgMapTool, msg):
        if self.entSelClass is not None:
            del self.entSelClass
        self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ENT
        self.entSelClass = QadEntSelClass(self.plugIn)
        self.entSelClass.msg = QadMsg.translate("Command_DIVIDE", "Select object to divide: ")
        # scarto la selezione di punti
        self.entSelClass.checkPointLayer = False
        self.entSelClass.checkLineLayer = True
        self.entSelClass.checkPolygonLayer = True
        self.entSelClass.checkDimLayers = False
        self.entSelClass.onlyEditableLayers = False

        self.entSelClass.run(msgMapTool, msg)

class QadBREAKCommandClass(QadCommandClass):
    def instantiateNewCmd(self):
        """ istanzia un nuovo comando dello stesso tipo """
        return QadBREAKCommandClass(self.plugIn)

    def getName(self):
        return QadMsg.translate("Command_list", "BREAK")

    def getEnglishName(self):
        return "BREAK"

    def connectQAction(self, action):
        QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runBREAKCommand)

    def getIcon(self):
        return QIcon(":/plugins/qad/icons/break.png")

    def getNote(self):
        # impostare le note esplicative del comando
        return QadMsg.translate("Command_BREAK", "Breaks an object.")

    def __init__(self, plugIn):
        QadCommandClass.__init__(self, plugIn)
        self.EntSelClass = None
        self.firstPt = None
        self.secondPt = None

    def __del__(self):
        QadCommandClass.__del__(self)
        if self.EntSelClass is not None:
            self.EntSelClass.entity.deselectOnLayer()
            del self.EntSelClass

    def getPointMapTool(self, drawMode=QadGetPointDrawModeEnum.NONE):
        if self.step == 1:  # quando si é in fase di selezione entità
            return self.EntSelClass.getPointMapTool(drawMode)
        else:
            return QadCommandClass.getPointMapTool(self, drawMode)

    def waitForEntsel(self, msgMapTool, msg):
        if self.EntSelClass is not None:
            del self.EntSelClass
        self.step = 1
        self.EntSelClass = QadEntSelClass(self.plugIn)
        self.EntSelClass.msg = QadMsg.translate("Command_BREAK", "Select the object to break: ")
        # scarto la selezione di punti e poligoni
        self.EntSelClass.checkPointLayer = False
        self.EntSelClass.checkLineLayer = True
        self.EntSelClass.checkPolygonLayer = False
        self.EntSelClass.checkDimLayers = False
        self.EntSelClass.onlyEditableLayers = True

        self.EntSelClass.run(msgMapTool, msg)

    # ============================================================================
    # breakFeatures
    # ============================================================================
    def breakFeatures(self):
        f = self.EntSelClass.entity.getFeature()
        if f is None:
            return

        layer = self.EntSelClass.entity.layer
        LineTempLayer = None
        self.plugIn.beginEditCommand("Feature broken", layer)

        tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))

        # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
        g = self.layerToMapCoordinates(layer, f.geometry())
        result = qad_utils.breakQgsGeometry(g, self.firstPt, self.secondPt, tolerance2ApproxCurve)
        if result is not None:
            line1 = result[0]
            line2 = result[1]
            atSubGeom = result[2]
            if layer.geometryType() == QGis.Line:
                if line1 is not None:
                    updGeom = qad_utils.setSubGeom(g, line1, atSubGeom)
                    if updGeom is None:
                        self.plugIn.destroyEditCommand()
                        return
                    brokenFeature1 = QgsFeature(f)
                    # trasformo la geometria nel crs del layer
                    brokenFeature1.setGeometry(self.mapToLayerCoordinates(layer, updGeom))
                    # plugIn, layer, feature, refresh, check_validity
                    if qad_layer.updateFeatureToLayer(self.plugIn, layer, brokenFeature1, False, False) == False:
                        self.plugIn.destroyEditCommand()
                        return
                if line2 is not None:
                    brokenFeature2 = QgsFeature(f)
                    # trasformo la geometria nel crs del layer
                    brokenFeature2.setGeometry(self.mapToLayerCoordinates(layer, line2))
                    # plugIn, layer, feature, coordTransform, refresh, check_validity
                    if qad_layer.addFeatureToLayer(self.plugIn, layer, brokenFeature2, None, False, False) == False:
                        self.plugIn.destroyEditCommand()
                        return
            else:
                # aggiungo le linee nei layer temporanei di QAD
                if LineTempLayer is None:
                    LineTempLayer = qad_layer.createQADTempLayer(self.plugIn, QGis.Line)
#.........这里部分代码省略.........

#.........这里部分代码省略.........
                        return False
                  else:
                     # aggiungo una parte
                     if geom.addPart(points) != 0: # 0 in case of success
                        self.showMsg(QadMsg.translate("QAD", "Invalid object."))
                        return False

      f = self.entity.getFeature()
      f.setGeometry(geom)

      layerList = entitySet.getLayerList()
      layerList.append(self.entity.layer)

      self.plugIn.beginEditCommand("Feature edited", layerList)
         
      # plugIn, layer, feature, refresh, check_validity
      if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False

      if removeOriginals:
         for layerEntitySet in entitySet.layerEntitySetList:            
            if qad_layer.deleteFeaturesToLayer(self.plugIn, layerEntitySet.layer, layerEntitySet.featureIds, False) == False:
               self.plugIn.destroyEditCommand()
               return 

      self.plugIn.endEditCommand()

      return True


   #============================================================================
   # waitForEntsel
   #============================================================================
   def waitForEntsel(self, msgMapTool, msg):
      if self.entSelClass is not None:
         del self.entSelClass
      self.step = 1
      self.entSelClass = QadEntSelClass(self.plugIn)
      self.entSelClass.msg = QadMsg.translate("Command_JOIN", "Select object to join to: ")
      # scarto la selezione di quote
      self.entSelClass.checkDimLayers = False     
      self.entSelClass.onlyEditableLayers = True
      self.entSelClass.deselectOnFinish = True
      
      self.entSelClass.run(msgMapTool, msg)


   #============================================================================
   # waitForSSsel
   #============================================================================
   def waitForSSsel(self, msgMapTool, msg):
      self.reinitSSGetClass()
      self.step = 2
      self.showMsg(QadMsg.translate("Command_JOIN", "\nSelect objects to join: "))
      self.SSGetClass.run(msgMapTool, msg)


   def run(self, msgMapTool = False, msg = None):
      if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
         self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
         return True # fine comando
      
      if self.step == 0:
         self.waitForEntsel(msgMapTool, msg) # seleziona l'oggetto a cui aggregarsi
         return False # continua
      
      #=========================================================================
      # RISPOSTA ALLA SELEZIONE ENTITA' DA MODIFICARE
      elif self.step == 1:
         if self.entSelClass.run(msgMapTool, msg) == True:
            if self.entSelClass.entity.isInitialized():
               self.entity.set(self.entSelClass.entity)

               self.waitForSSsel(msgMapTool, msg)
            else:
               if self.entSelClass.canceledByUsr == True: # fine comando
                  return True
               self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
               self.waitForEntsel(msgMapTool, msg)

         return False # continua

      #=========================================================================
      # RISPOSTA ALLA RICHIESTA DEL GRUPPO DI SELEZIONE (da step = 1)
      elif self.step == 2:
         if self.SSGetClass.run(msgMapTool, msg) == True:
            if self.SSGetClass.entitySet.count() > 0:
               geometryType = self.entity.layer.geometryType()
               if geometryType == QGis.Point:
                  self.addEntitySetToPoint(self.SSGetClass.entitySet)
               elif geometryType == QGis.Line:
                  self.addEntitySetToPolyline(self.SSGetClass.entitySet)
               elif geometryType == QGis.Polygon:
                  self.addEntitySetToPolygon(self.SSGetClass.entitySet)
               
               return True
               
            self.waitForSSsel(msgMapTool, msg)
         return False

#.........这里部分代码省略.........
      wkbType = geom.wkbType()
      if wkbType == QGis.WKBMultiPoint or wkbType == QGis.WKBMultiLineString:
         if geom.deletePart(part) == False: # disgrego una parte
            self.showMsg(QadMsg.translate("QAD", "Invalid object."))
            return False
         newGeom = self.mapToLayerCoordinates(layer, self.currSubGeom)
      elif wkbType == QGis.WKBPolygon or wkbType == QGis.WKBMultiPolygon:
         if ring is not None: # disgrego un'isola 
            if geom.deleteRing(ring + 1, part) == False: # cancello una isola (Ring 0 is outer ring and can't be deleted)
               self.showMsg(QadMsg.translate("QAD", "Invalid object."))
               return False
            newGeom = QgsGeometry.fromPolygon([self.mapToLayerCoordinates(layer, self.currSubGeom).asPolyline()])
         else: # disgrego una parte
            if wkbType == QGis.WKBPolygon:
               self.showMsg(QadMsg.translate("QAD", "Invalid object."))
               return False
            
            newGeom = QgsGeometry.fromPolygon([self.mapToLayerCoordinates(layer, self.currSubGeom).asPolyline()])
            ring = 0
            ringGeom = qad_utils.getSubGeomAt(geom, [part, ring])
            # se la parte ha delle isole
            while ringGeom is not None:
               # aggiungo un'isola
               points = ringGeom.asPolyline() # vettore di punti
               if newGeom.addRing(points) != 0: # 0 in case of success
                  self.showMsg(QadMsg.translate("QAD", "Invalid object."))
                  return False
               ring = ring + 1
               ringGeom = qad_utils.getSubGeomAt(geom, [part, ring])

            if geom.deletePart(part) == False: # cancello una parte
               self.showMsg(QadMsg.translate("QAD", "Invalid object."))
               return False
      else:
         self.showMsg(QadMsg.translate("QAD", "Invalid object."))
         return False

      f = self.entity.getFeature()
      f.setGeometry(geom)

      self.plugIn.beginEditCommand("Feature edited", self.entity.layer)
         
      # plugIn, layer, feature, refresh, check_validity
      if qad_layer.updateFeatureToLayer(self.plugIn, self.entity.layer, f, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False

      # Aggiungo nuova feature
      newF = QgsFeature(f)
      newF.setGeometry(newGeom)
      if qad_layer.addFeatureToLayer(self.plugIn, self.entity.layer, newF, None, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False
         
      self.plugIn.endEditCommand()

      return True


   #============================================================================
   # waitForEntsel
   #============================================================================
   def waitForEntsel(self, msgMapTool, msg):
      if self.entSelClass is not None:
         del self.entSelClass
      self.step = 1
      self.entSelClass = QadEntSelClass(self.plugIn)
      self.entSelClass.msg = QadMsg.translate("Command_DISJOIN", "Select object to disjoin: ")
      # scarto la selezione di quote
      self.entSelClass.checkDimLayers = False     
      self.entSelClass.onlyEditableLayers = True
      self.entSelClass.deselectOnFinish = True
      
      self.entSelClass.run(msgMapTool, msg)


   def run(self, msgMapTool = False, msg = None):
      if self.plugIn.canvas.mapSettings().destinationCrs().geographicFlag():
         self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
         return True # fine comando
      
      if self.step == 0:
         self.waitForEntsel(msgMapTool, msg) # seleziona l'oggetto da disgregare
         return False # continua
      
      #=========================================================================
      # RISPOSTA ALLA SELEZIONE ENTITA' DA MODIFICARE
      elif self.step == 1:
         if self.entSelClass.run(msgMapTool, msg) == True:
            if self.setCurrentSubGeom(self.entSelClass) == True:
               if self.disjoinCurrentSubGeomToPolygon() == True:
                  return True
            else:
               if self.entSelClass.canceledByUsr == True: # fine comando
                  return True
               self.showMsg(QadMsg.translate("QAD", "No geometries in this position."))
               
            self.waitForEntsel(msgMapTool, msg)
            
         return False # continua

class QadDIMARCCommandClass(QadCommandClass):

   def instantiateNewCmd(self):
      """ istanzia un nuovo comando dello stesso tipo """
      return QadDIMARCCommandClass(self.plugIn)
   
   def getName(self):
      return QadMsg.translate("Command_list", "DIMARC")

   def getEnglishName(self):
      return "DIMARC"

   def connectQAction(self, action):
      QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runDIMARCCommand)

   def getIcon(self):
      return QIcon(":/plugins/qad/icons/dimArc.png")

   def getNote(self):
      # impostare le note esplicative del comando
      return QadMsg.translate("Command_DIM", "Creates an arc length dimension.")
   
   def __init__(self, plugIn):
      QadCommandClass.__init__(self, plugIn)
      self.EntSelClass = None
      self.GetAngleClass = None
      
      self.dimPt1 = QgsPoint()
      self.dimPt2 = QgsPoint()
      self.dimArc = None    # oggetto arco da quotare
      
      self.measure = None # misura della quota (se None viene calcolato)
      self.leader = False
      # leggo lo stile di quotatura corrente
      dimStyleName = QadVariables.get(QadMsg.translate("Environment variables", "DIMSTYLE"))
      self.dimStyle = self.plugIn.dimStyles.findDimStyle(dimStyleName)
      if self.dimStyle is not None:
         self.dimStyle.dimType = QadDimTypeEnum.ALIGNED
      

   def __del__(self):
      QadCommandClass.__del__(self)
      if self.EntSelClass is not None:
         self.EntSelClass.entity.deselectOnLayer()
         del self.EntSelClass
      if self.GetAngleClass is not None:
         del self.GetAngleClass
      
   def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
      if self.step == 1: # quando si é in fase di selezione entità
         return self.EntSelClass.getPointMapTool(drawMode)
      # quando si é in fase di richiesta rotazione
      elif self.step == 6:
         return self.GetAngleClass.getPointMapTool()
      else:
         if (self.plugIn is not None):
            if self.PointMapTool is None:
               self.PointMapTool = Qad_dim_maptool(self.plugIn)
            return self.PointMapTool
         else:
            return None

   
   #============================================================================
   # addDimToLayers
   #============================================================================
   def addDimToLayers(self, linePosPt):
      return self.dimStyle.addAlignedDimToLayers(self.plugIn, self.dimPt1, self.dimPt2, \
                                                 linePosPt, self.measure)

   
   #============================================================================
   # waitForEntsel
   #============================================================================
   def waitForEntsel(self, msgMapTool, msg):
      if self.EntSelClass is not None:
         del self.EntSelClass
      self.step = 1     
      self.EntSelClass = QadEntSelClass(self.plugIn)
      self.EntSelClass.msg = QadMsg.translate("Command_DIM", "Select arc or polyline arc segment: ")
      # scarto la selezione di punti
      self.EntSelClass.checkPointLayer = False
      self.EntSelClass.checkLineLayer = True
      self.EntSelClass.checkPolygonLayer = True
      self.EntSelClass.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)         
      self.EntSelClass.run(msgMapTool, msg)

   
   #============================================================================
   # waitForDimensionLinePos
   #============================================================================
   def waitForDimensionLinePos(self):
      self.step = 4
      # imposto il map tool      
      self.getPointMapTool().dimPt2 = self.dimPt2
      if self.getPointMapTool().dimPt1 is None: # in caso di selezione oggetto dimPt1 non era stato inizializzato
         self.getPointMapTool().dimPt1 = self.dimPt1
         self.getPointMapTool().dimCircle = self.dimCircle
      self.getPointMapTool().dimStyle = self.dimStyle      
      self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_ALIGNED_DIM_LINE_POS)                                
#.........这里部分代码省略.........

class QadDIVIDECommandClass(QadCommandClass):
    def instantiateNewCmd(self):
        """ istanzia un nuovo comando dello stesso tipo """
        return QadDIVIDECommandClass(self.plugIn)

    def getName(self):
        return QadMsg.translate("Command_list", "DIVIDE")

    def getEnglishName(self):
        return "DIVIDE"

    def connectQAction(self, action):
        QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runDIVIDECommand)

    def getIcon(self):
        return QIcon(":/plugins/qad/icons/divide.png")

    def getNote(self):
        # impostare le note esplicative del comando
        return QadMsg.translate(
            "Command_DIVIDE", "Creates evenly spaced punctual objects along the length or perimeter of an object."
        )

    def __init__(self, plugIn):
        QadCommandClass.__init__(self, plugIn)
        self.entSelClass = None
        self.objectAlignment = True
        self.nSegments = 1

    def __del__(self):
        QadCommandClass.__del__(self)
        if self.entSelClass is not None:
            self.entSelClass.entity.deselectOnLayer()
            del self.entSelClass

    # ============================================================================
    # waitForEntsel
    # ============================================================================
    def waitForEntsel(self, msgMapTool, msg):
        if self.entSelClass is not None:
            del self.entSelClass
        self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ENT
        self.entSelClass = QadEntSelClass(self.plugIn)
        self.entSelClass.msg = QadMsg.translate("Command_DIVIDE", "Select object to divide: ")
        # scarto la selezione di punti
        self.entSelClass.checkPointLayer = False
        self.entSelClass.checkLineLayer = True
        self.entSelClass.checkPolygonLayer = True
        self.entSelClass.checkDimLayers = False
        self.entSelClass.onlyEditableLayers = False

        self.entSelClass.run(msgMapTool, msg)

    # ============================================================================
    # waitForAlignmentObjs
    # ============================================================================
    def waitForAlignmentObjs(self):
        self.step = QadDIVIDECommandClassStepEnum.ASK_FOR_ALIGNMENT

        keyWords = QadMsg.translate("QAD", "Yes") + "/" + QadMsg.translate("QAD", "No")
        self.defaultValue = QadMsg.translate("QAD", "Yes")
        prompt = QadMsg.translate("Command_DIVIDE", "Align with object ? [{0}] <{1}>: ").format(
            keyWords, self.defaultValue
        )

        englishKeyWords = "Yes" + "/" + "No"
        keyWords += "_" + englishKeyWords

        # msg, inputType, default, keyWords, nessun controllo
        self.waitFor(prompt, QadInputTypeEnum.KEYWORDS, self.defaultValue, keyWords, QadInputModeEnum.NONE)

    # ============================================================================
    # waitForSegmentNumber
    # ============================================================================
    def waitForSegmentNumber(self):
        self.step = QadDIVIDECommandClassStepEnum.ASK_SEGMENT_NUMBER

        # si appresta ad attendere un numero intero
        msg = QadMsg.translate("Command_DIVIDE", "Enter the number of segments: ")
        # msg, inputType, default, keyWords, valori positivi
        self.waitFor(msg, QadInputTypeEnum.INT, None, "", QadInputModeEnum.NOT_ZERO | QadInputModeEnum.NOT_NEGATIVE)

    # ============================================================================
    # addFeature
    # ============================================================================
    def addFeature(self, layer, insPt, rot):
        transformedPoint = self.mapToLayerCoordinates(layer, insPt)
        g = QgsGeometry.fromPoint(transformedPoint)
        f = QgsFeature()
        f.setGeometry(g)
        # Add attribute fields to feature.
        fields = layer.pendingFields()
        f.setFields(fields)

        # assegno i valori di default
        provider = layer.dataProvider()
        for field in fields.toList():
            i = fields.indexFromName(field.name())
            f[field.name()] = provider.defaultValue(i)

#.........这里部分代码省略.........

#.........这里部分代码省略.........
            for simplifiedGeom in simplifiedGeoms:
               points = simplifiedGeom.asPolyline() # vettore di punti                     
               res = geom.addPart(points)
      
      f.setGeometry(geom)
      
      self.plugIn.beginEditCommand("Feature edited", layerList)
         
      # plugIn, layer, feature, refresh, check_validity
      if qad_layer.updateFeatureToLayer(self.plugIn, self.poligonEntity.layer, f, False, False) == False:
         self.plugIn.destroyEditCommand()
         return False

      if len(newfeatures) > 0:
         # plugIn, layer, features, coordTransform, refresh, check_validity
         if qad_layer.addFeaturesToLayer(self.plugIn, self.poligonEntity.layer, newfeatures, None, False, False) == False:
            self.plugIn.destroyEditCommand()
            return

      self.plugIn.endEditCommand()
      self.nOperationsToUndo = self.nOperationsToUndo + 1

      return True



   #============================================================================
   # waitForEntsel
   #============================================================================
   def waitForEntsel(self, msgMapTool, msg):
      if self.entSelClass is not None:
         del self.entSelClass
      self.step = 1
      self.entSelClass = QadEntSelClass(self.plugIn)
      self.entSelClass.msg = QadMsg.translate("Command_MAPMPEDIT", "Select polygon: ")
      # scarto la selezione di punti e polilinee
      self.entSelClass.checkPointLayer = False
      self.entSelClass.checkLineLayer = False
      self.entSelClass.checkPolygonLayer = True
      self.entSelClass.checkDimLayers = False     
      self.entSelClass.onlyEditableLayers = True

      self.entSelClass.run(msgMapTool, msg)
      

   #============================================================================
   # WaitForMainMenu
   #============================================================================
   def WaitForMainMenu(self):
      self.poligonEntity.selectOnLayer(False)
      keyWords = QadMsg.translate("Command_MAPMPEDIT", "Add") + "/" + \
                 QadMsg.translate("Command_MAPMPEDIT", "Delete") + "/" + \
                 QadMsg.translate("Command_MAPMPEDIT", "Union") + "/" + \
                 QadMsg.translate("Command_MAPMPEDIT", "Substract") + "/" + \
                 QadMsg.translate("Command_MAPMPEDIT", "Intersect") + "/" + \
                 QadMsg.translate("Command_MAPMPEDIT", "split Objects") + "/" + \
                 QadMsg.translate("Command_MAPMPEDIT", "split Parts") + "/" + \
                 QadMsg.translate("Command_MAPMPEDIT", "iNclude objs")
      englishKeyWords = "Add" + "/" + "Delete" + "/" + "Union" + "/" + "Substract" + "/" + "Intersect" "/" + \
                        "split Objects" + "/" + "split Parts" + "/" + "iNclude objs"

      if self.nOperationsToUndo > 0: # se c'è qualcosa che si può annullare
         keyWords = keyWords + "/" +  QadMsg.translate("Command_MAPMPEDIT", "Undo")
         englishKeyWords = englishKeyWords + "/" + "Undo"
      
      keyWords = keyWords + "/" + QadMsg.translate("Command_MAPMPEDIT", "eXit")

class QadSETCURRLAYERBYGRAPHCommandClass(QadCommandClass):

   def instantiateNewCmd(self):
      """ istanzia un nuovo comando dello stesso tipo """
      return QadSETCURRLAYERBYGRAPHCommandClass(self.plugIn)

   def getName(self):
      return QadMsg.translate("Command_list", "SETCURRLAYERBYGRAPH")

   def getEnglishName(self):
      return "SETCURRLAYERBYGRAPH"

   def connectQAction(self, action):
      QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runSETCURRLAYERBYGRAPHCommand)

   def getIcon(self):
      return QIcon(":/plugins/qad/icons/setcurrlayerbygraph.png")
   
   def getNote(self):
      # impostare le note esplicative del comando      
      return QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "Sets a layer of a graphical object as current.")
   
   def __init__(self, plugIn):
      QadCommandClass.__init__(self, plugIn)
      self.EntSelClass = None

   def __del__(self):
      QadCommandClass.__del__(self)
      
   def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):
      if self.step == 0 or self.step == 1: # quando si é in fase di selezione entità
         return self.EntSelClass.getPointMapTool(drawMode)
      else:
         return QadCommandClass.getPointMapTool(self, drawMode)
   
   def waitForEntsel(self, msgMapTool, msg):
      if self.EntSelClass is not None:
         del self.EntSelClass            
      self.EntSelClass = QadEntSelClass(self.plugIn)
      self.EntSelClass.msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "Select object whose layer will be the current layer: ")
      self.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)
      self.EntSelClass.run(msgMapTool, msg)
        
   def run(self, msgMapTool = False, msg = None):
      if self.plugIn.canvas.mapRenderer().destinationCrs().geographicFlag():
         self.showMsg(QadMsg.translate("QAD", "\nThe coordinate reference system of the project must be a projected coordinate system.\n"))
         return True # fine comando
      
      if self.step == 0:     
         self.waitForEntsel(msgMapTool, msg)
         self.step = 1
         return False # continua
      
      elif self.step == 1:
         if self.EntSelClass.run(msgMapTool, msg) == True:
            if self.EntSelClass.entity.isInitialized():
               layer = self.EntSelClass.entity.layer
               if self.plugIn.canvas.currentLayer() is None or \
                  self.plugIn.canvas.currentLayer() != layer:                              
                  self.plugIn.canvas.setCurrentLayer(layer)
                  self.plugIn.iface.setActiveLayer(layer) # lancia evento di deactivate e activate dei plugin
                  self.plugIn.iface.legendInterface().refreshLayerSymbology(layer)
                  msg = QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "\nThe current layer is {0}.")
                  self.showMsg(msg.format(layer.name()))
               del self.EntSelClass
               return True
            else:               
               self.showMsg(QadMsg.translate("Command_SETCURRLAYERBYGRAPH", "No geometries in this position."))
               self.waitForEntsel(msgMapTool, msg)
         return False # continua

#.........这里部分代码省略.........
      self.step = 1
      # imposto il map tool
      self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.NONE_KNOWN_ASK_FOR_FIRST_PT)                                

      msg = QadMsg.translate("Command_DIM", "Specificare l'origine della prima linea di estensione o <seleziona oggetto>: ")
      
      # si appresta ad attendere un punto o enter      
      # msg, inputType, default, keyWords, nessun controllo
      self.waitFor(msg, \
                   QadInputTypeEnum.POINT2D, \
                   None, \
                   "", QadInputModeEnum.NONE)

   
   #============================================================================
   # waitForSecondPt
   #============================================================================
   def waitForSecondPt(self):
      self.step = 3
      # imposto il map tool
      self.getPointMapTool().dimPt1 = self.dimPt1
      self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_PT)                                
      # si appresta ad attendere un punto
      self.waitForPoint(QadMsg.translate("Command_DIM", "Specificare l'origine della seconda linea di estensione: "))

   
   #============================================================================
   # waitForEntsel
   #============================================================================
   def waitForEntsel(self, msgMapTool, msg):
      if self.EntSelClass is not None:
         del self.EntSelClass
      self.step = 2         
      self.EntSelClass = QadEntSelClass(self.plugIn)
      self.EntSelClass.msg = QadMsg.translate("Command_DIM", "Selezionare l'oggetto da quotare: ")
      # scarto la selezione di punti
      self.EntSelClass.checkPointLayer = False
      self.EntSelClass.checkLineLayer = True
      self.EntSelClass.checkPolygonLayer = True
      self.EntSelClass.getPointMapTool().setSnapType(QadSnapTypeEnum.DISABLE)         
      self.EntSelClass.run(msgMapTool, msg)

   
   #============================================================================
   # waitForDimensionLinePos
   #============================================================================
   def waitForDimensionLinePos(self):
      self.step = 4
      # imposto il map tool      
      self.getPointMapTool().dimPt2 = self.dimPt2
      if self.getPointMapTool().dimPt1 is None: # in caso di selezione oggetto dimPt1 non era stato inizializzato
         self.getPointMapTool().dimPt1 = self.dimPt1
         self.getPointMapTool().dimCircle = self.dimCircle
      self.getPointMapTool().preferredAlignment = self.preferredAlignment
      self.getPointMapTool().forcedDimLineAlignment = self.forcedDimLineAlignment
      self.getPointMapTool().forcedDimLineRot = self.forcedDimLineRot      
      self.getPointMapTool().dimStyle = self.dimStyle      
      self.getPointMapTool().setMode(Qad_dim_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_LINEAR_DIM_LINE_POS)                                
      
      # si appresta ad attendere un punto o una parola chiave
      keyWords = QadMsg.translate("Command_DIM", "Testo") + "/" + \
                 QadMsg.translate("Command_DIM", "Angolo") + "/" + \
                 QadMsg.translate("Command_DIM", "Orizzontale") + "/" + \
                 QadMsg.translate("Command_DIM", "Verticale") + "/" + \
                 QadMsg.translate("Command_DIM", "Ruotato")      
      prompt = QadMsg.translate("Command_DIM", "Specificare la posizione della linea di quota o [{0}]: ").format(keyWords)