def setInfo(self, entity, point):
      # setta: self.layer, self.tmpLinearObjectList e self.move_startPt

      if self.tmpLinearObjectList is not None:
         del self.tmpLinearObjectList
         self.tmpLinearObjectList = None
      
      if entity.isInitialized() == False:
         return False
         
      self.layer = entity.layer
      transformedPt = self.canvas.mapSettings().mapToLayerCoordinates(self.layer, point)
      geom = entity.getGeometry()
                  
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      dummy = qad_utils.closestSegmentWithContext(transformedPt, geom)
      if dummy[2] is None:
         return False
      # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
      subGeom, atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])               
      self.tmpLinearObjectList = qad_utils.QadLinearObjectList()               
      self.tmpLinearObjectList.fromPolyline(subGeom.asPolyline())
      
      if qad_utils.getDistance(self.tmpLinearObjectList.getStartPt(), transformedPt) <= \
         qad_utils.getDistance(self.tmpLinearObjectList.getEndPt(), transformedPt):
         # si allunga/accorcia dal punto iniziale                 
         self.move_startPt = True
      else:
         # si allunga dal punto finale
         self.move_startPt = False
      return True

 def canvasMoveEvent(self, event):
    QadGetPoint.canvasMoveEvent(self, event)
    
    self.__rubberBand.reset()
       
    result = False
    arc = QadArc()    
     
    # noti il primo e il secondo punto dell'arco si richiede il terzo punto
    if self.mode == Qad_arc_maptool_ModeEnum.START_SECOND_PT_KNOWN_ASK_FOR_END_PT:
       result = arc.fromStartSecondEndPts(self.arcStartPt, self.arcSecondPt, self.tmpPoint)
    # noti il primo punto e il centro dell'arco si richiede il punto finale
    elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_END_PT:
       result = arc.fromStartCenterEndPts(self.arcStartPt, self.arcCenterPt, self.tmpPoint)
    # noti il primo punto e il centro dell'arco si richiede l'angolo inscritto
    elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_ANGLE:
       angle = qad_utils.getAngleBy2Pts(self.arcCenterPt, self.tmpPoint)
       result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.arcCenterPt, angle)
    # noti il primo punto e il centro dell'arco si richiede la lunghezza della corda
    elif self.mode == Qad_arc_maptool_ModeEnum.START_CENTER_PT_KNOWN_ASK_FOR_CHORD:     
       chord = qad_utils.getDistance(self.arcStartPt, self.tmpPoint)
       result = arc.fromStartCenterPtsChord(self.arcStartPt, self.arcCenterPt, chord)
    # noti il punto iniziale e finale dell'arco si richiede il centro
    elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_CENTER:     
       result = arc.fromStartCenterEndPts(self.arcStartPt, self.tmpPoint, self.arcEndPt)
    # noti il punto iniziale e finale dell'arco si richiede l'angolo inscritto
    elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_ANGLE:     
       angle = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
       result = arc.fromStartEndPtsAngle(self.arcStartPt, self.arcEndPt, angle)
    # noti il punto iniziale e finale dell'arco si richiede la direzione della tangente
    elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_TAN:     
       tan = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
       result = arc.fromStartEndPtsTan(self.arcStartPt, self.arcEndPt, tan)
    # noti il punto iniziale e finale dell'arco si richiede il raggio
    elif self.mode == Qad_arc_maptool_ModeEnum.START_END_PT_KNOWN_ASK_FOR_RADIUS:     
       radius = qad_utils.getDistance(self.arcEndPt, self.tmpPoint)
       result = arc.fromStartEndPtsRadius(self.arcStartPt, self.arcEndPt, radius)
    # noti il punto iniziale e la tangente al punto iniziale si richiede il punto finale
    elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_TAN_KNOWN_ASK_FOR_END_PT:     
       result = arc.fromStartEndPtsTan(self.arcStartPt, self.tmpPoint, self.arcTanOnStartPt)         
    # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il punto finale
    elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_END_PT:     
       result = arc.fromStartEndPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle)
    # noti il punto iniziale e l'angolo inscritto dell'arco si richiede il centro
    elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_KNOWN_ASK_FOR_CENTER_PT:     
       result = arc.fromStartCenterPtsAngle(self.arcStartPt, self.tmpPoint, self.arcAngle)
    # noti il punto iniziale, l'angolo inscritto e il raggio dell'arco si richiede la direzione della corda
    elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_ANGLE_RADIUS_KNOWN_ASK_FOR_CHORDDIRECTION:     
       chordDirection = qad_utils.getAngleBy2Pts(self.arcStartPt, self.tmpPoint)
       result = arc.fromStartPtAngleRadiusChordDirection(self.arcStartPt, self.arcAngle, \
                                                         self.arcRadius, chordDirection)
    # noti il punto iniziale e il raggio dell'arco si richiede il punto finale
    elif self.mode == Qad_arc_maptool_ModeEnum.START_PT_RADIUS_KNOWN_ASK_FOR_END_PT:     
       result = arc.fromStartEndPtsRadius(self.arcStartPt, self.tmpPoint, self.arcRadius)
    
    if result == True:
       points = arc.asPolyline()
    
       if points is not None:
          self.__rubberBand.setLine(points)

    def fromStartEndPtsTan(self, startPt, endPt, tan):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      punto finale
      direzione della tangente sul punto iniziale
      """
        if startPt == endPt:
            return False

        angleSegment = qad_utils.getAngleBy2Pts(startPt, endPt)
        if tan == angleSegment or tan == angleSegment - math.pi:
            return False

        chord = qad_utils.getDistance(startPt, endPt)
        half_chord = chord / 2
        ptMiddle = qad_utils.getMiddlePoint(startPt, endPt)

        angle = tan + (math.pi / 2)
        angle = angleSegment - angle
        distFromCenter = math.tan(angle) * half_chord
        self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment - (math.pi / 2), distFromCenter)
        pt = qad_utils.getPolarPointByPtAngle(startPt, tan, chord)

        if qad_utils.leftOfLine(endPt, startPt, pt) < 0:
            # arco si sviluppa a sinistra della tangente
            self.startAngle = qad_utils.getAngleBy2Pts(self.center, startPt)
            self.endAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
        else:
            # arco si sviluppa a destra della tangente
            self.startAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
            self.endAngle = qad_utils.getAngleBy2Pts(self.center, startPt)

        self.radius = qad_utils.getDistance(startPt, self.center)
        return True

   def setSelectedEntityGripPoints(self, entitySetGripPoints):
      # lista delle entityGripPoint con dei grip point selezionati
      # setta la prima entità con un grip selezionato
      self.entity = None
      for entityGripPoints in entitySetGripPoints.entityGripPoints:
         for gripPoint in entityGripPoints.gripPoints:
            # grip point selezionato
            if gripPoint.getStatus() == qad_grip.QadGripStatusEnum.SELECTED:
               # verifico se l'entità appartiene ad uno stile di quotatura
               if entityGripPoints.entity.isDimensionComponent():
                  return False
               if entityGripPoints.entity.getEntityType() != QadEntityGeomTypeEnum.ARC and \
                  entityGripPoints.entity.getEntityType() != QadEntityGeomTypeEnum.LINESTRING:
                  return False
               
               # setta: self.entity, self.linearObjectList, self.atSubGeom e self.move_startPt
               self.entity = entityGripPoints.entity
               
               if self.linearObjectList is not None:
                  del self.linearObjectList
                  self.linearObjectList = None

               # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
               geom = self.layerToMapCoordinates(self.entity.layer, self.entity.getGeometry())
               
               # ritorna una tupla (<The squared cartesian distance>,
               #                    <minDistPoint>
               #                    <afterVertex>
               #                    <leftOf>)
               res = False
               dummy = qad_utils.closestSegmentWithContext(gripPoint.getPoint(), geom)
               if dummy[2] is None:
                  return False
               # ritorna la sotto-geometria al vertice <atVertex> e la sua posizione nella geometria (0-based)
               subGeom, self.atSubGeom = qad_utils.getSubGeomAtVertex(geom, dummy[2])               
               self.linearObjectList = qad_utils.QadLinearObjectList()

               self.linearObjectList.fromPolyline(subGeom.asPolyline())
               
               if qad_utils.getDistance(self.linearObjectList.getStartPt(), gripPoint.getPoint()) <= \
                  qad_utils.getDistance(self.linearObjectList.getEndPt(), gripPoint.getPoint()):
                  # si allunga dal punto iniziale
                  self.move_startPt = True
               else:
                  # si allunga dal punto finale
                  self.move_startPt = False

               # imposto il map tool
               if self.getPointMapTool().setInfo(self.entity, gripPoint.getPoint()) == False:
                  return False
               
               return True
      return False

def arrayPolarEntity(plugIn, ent, basePt, centerPt, itemsNumber, angleBetween, rows, distanceBetweenRows, itemsRotation, \
                     addToLayer, highlightObj):
   """
   serie polare
   ent = entità QAD di cui fare la serie (QadEntity o QadDimEntity)
   basePt = punto base in map coordinate (QgsPoint)
   centerPt = punto centrale in map coordinate (QgsPoint)
   itemsNumber = numero di copie da fare
   angleBetween = angolo tra un elemento e l'altro (radianti)
   rows = numero di righe
   distanceBetweenRows = distanza tra le righe in map coordinate
   itemsRotation = True se si vuole ruotare gli elementi intorno al cerchio
   addToLayer = se è True aggiunge le nuove entità al layer
   highlightObj = se è diverso da None vengono aggiunge le geometrie all'oggetto QadHighlight
   """
   g = None
   coordTransform = None
   f = None
   if ent.whatIs() == "ENTITY":
      f = ent.getFeature()
      # trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy
      CRS = qgis.utils.iface.mapCanvas().mapSettings().destinationCrs() # CRS corrente
      coordTransform = QgsCoordinateTransform(ent.crs(), CRS)
      g = f.geometry()
      g.transform(coordTransform)
      coordTransform = QgsCoordinateTransform(CRS, ent.crs())

      rotFldName = ""
      if ent.getEntityType() == QadEntityGeomTypeEnum.TEXT:
         # se la rotazione dipende da un solo campo
         rotFldNames = qad_label.get_labelRotationFieldNames(ent.layer)
         if len(rotFldNames) == 1 and len(rotFldNames[0]) > 0:
            rotFldName = rotFldNames[0]         
      elif ent.getEntityType() == QadEntityGeomTypeEnum.SYMBOL:
         rotFldName = qad_layer.get_symbolRotationFieldName(ent.layer)

   firstAngle = qad_utils.getAngleBy2Pts(centerPt, basePt)
   dist = qad_utils.getDistance(centerPt, basePt)
   for row in range(0, rows):
      angle = firstAngle
      for i in range(0, itemsNumber):
         newBasePt = qad_utils.getPolarPointByPtAngle(centerPt, angle, dist)
         offSetX = newBasePt.x() - basePt.x()
         offSetY = newBasePt.y() - basePt.y()
      
         if g is not None: # se l'entità non è una quotatura
            if doMoveAndRotateGeom(plugIn, f, g, ent.layer, offSetX, offSetY, \
                                   i * angleBetween if itemsRotation else None, rotFldName, \
                                   newBasePt, coordTransform, addToLayer, highlightObj) == False:
               return False
         else: # se l'entità è una quotatura
            if doMoveAndRotateDimEntity(plugIn, ent, offSetX, offSetY, \
                                        i * angleBetween if itemsRotation else None, \
                                        newBasePt, addToLayer, highlightObj) == False:
               return False
         angle = angle + angleBetween 

      dist = dist + distanceBetweenRows

   return True

 def isPtOnArc(self, point):
     dist = qad_utils.getDistance(self.center, point)
     if qad_utils.doubleNear(self.radius, dist):
         angle = qad_utils.getAngleBy2Pts(self.center, point)
         return qad_utils.isAngleBetweenAngles(self.startAngle, self.endAngle, angle)
     else:
         return False

    def fromStartEndPtsAngle(self, startPt, endPt, angle):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      punto finale
      angolo inscritto
      """
        if startPt == endPt or angle == 0:
            return False

        chord = qad_utils.getDistance(startPt, endPt)
        half_chord = chord / 2
        # Teorema della corda
        self.radius = half_chord / math.sin(angle / 2)

        angleSegment = qad_utils.getAngleBy2Pts(startPt, endPt)
        ptMiddle = qad_utils.getMiddlePoint(startPt, endPt)

        # Pitagora
        distFromCenter = math.sqrt((self.radius * self.radius) - (half_chord * half_chord))
        if angle < math.pi:  # se angolo < 180 gradi
            # aggiungo 90 gradi per cercare il centro a sinistra del segmento
            self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment + (math.pi / 2), distFromCenter)
        else:
            # sottraggo 90 gradi per cercare il centro a destra del segmento
            self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment - (math.pi / 2), distFromCenter)
        self.startAngle = qad_utils.getAngleBy2Pts(self.center, startPt)
        self.endAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
        return True

   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)

      # noto il punto base si richiede il secondo punto per il raggio
      if self.mode == Qad_gripChangeArcRadius_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_RADIUS_PT:
         radius = qad_utils.getDistance(self.basePt, self.tmpPoint)
         self.changeRadius(radius)                           

   def canvasMoveEvent(self, event):
      QadGetPoint.canvasMoveEvent(self, event)
      
      self.__rubberBand.reset()

      result = False
      del self.vertices[:] # svuoto la lista
      
      if self.mode is not None:
         # noto il centro si richiede il raggio
         if self.mode == Qad_polygon_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:
            radius = qad_utils.getDistance(self.centerPt, self.tmpPoint)
      
            InscribedOption = True if self.constructionModeByCenter == QadMsg.translate("Command_POLYGON", "Inscribed in circle") else False            
            self.vertices.extend(qad_utils.getPolygonByNsidesCenterRadius(self.sideNumber, self.centerPt, radius, \
                                                                          InscribedOption, self.tmpPoint))
            result = True
         # si richiede il secondo punto dello spigolo
         elif self.mode == Qad_polygon_maptool_ModeEnum.FIRST_EDGE_PT_KNOWN_ASK_FOR_SECOND_EDGE_PT:
            self.vertices.extend(qad_utils.getPolygonByNsidesEdgePts(self.sideNumber, self.firstEdgePt, \
                                                                     self.tmpPoint))
            result = True
            
      if result == True:         
         if self.vertices is not None:
            if self.geomType == QGis.Polygon:
               self.__rubberBand.setPolygon(self.vertices)
            else:
               self.__rubberBand.setLine(self.vertices)            

    def fromStartEndPtsRadius(self, startPt, endPt, radius):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      punto finale
      raggio
      """
        if startPt == endPt or radius <= 0:
            return False

        chord = qad_utils.getDistance(startPt, endPt)
        half_chord = chord / 2
        if radius < half_chord:
            return False

        self.radius = radius
        angleSegment = qad_utils.getAngleBy2Pts(startPt, endPt)
        ptMiddle = qad_utils.getMiddlePoint(startPt, endPt)

        # Pitagora
        distFromCenter = math.sqrt((self.radius * self.radius) - (half_chord * half_chord))
        # aggiungo 90 gradi
        self.center = qad_utils.getPolarPointByPtAngle(ptMiddle, angleSegment + (math.pi / 2), distFromCenter)
        self.startAngle = qad_utils.getAngleBy2Pts(self.center, startPt)
        self.endAngle = qad_utils.getAngleBy2Pts(self.center, endPt)
        return True

def gripStretchCircle(circle, basePt, ptListToStretch, offSetX, offSetY, tolerance2ApproxCurve):
   """
   Stira i punti di grip di un cerchio che sono contenuti in ptListToStretch
   circle = cerchio da stirare
   basePt = punto base
   ptListToStretch = lista dei punti da stirare
   offSetX = spostamento X
   offSetY = spostamento Y
   """
   if tolerance2ApproxCurve == None:
      tolerance = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
   else:
      tolerance = tolerance2ApproxCurve
   
   newCenter = QgsPoint(circle.center)
   newRadius = circle.radius
   
   for ptToStretch in ptListToStretch:
      if qad_utils.ptNear(ptToStretch, circle.center): # se i punti sono sufficientemente vicini
         newCenter.set(circle.center.x() + offSetX, circle.center.y() + offSetY)
      elif circle.isPtOnCircle(ptToStretch):
         newPt = QgsPoint(basePt.x() + offSetX, basePt.y() + offSetY)
         newRadius = qad_utils.getDistance(circle.center, newPt)

   newCircle = qad_circle.QadCircle()
   if newCircle.set(newCenter, newRadius) == False:
      return None
   
   return newCircle

   def addFeatureCache(self, newPt):
      featureCacheLen = len(self.featureCache)
      layer = self.entity.layer
      f = self.entity.getFeature()
      transformedPt = self.mapToLayerCoordinates(layer, newPt)

      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      dummy = qad_utils.closestSegmentWithContext(transformedPt, self.subGeom)
      if self.offSet < 0:
         afterVertex = dummy[2]
         pt = qad_utils.getPerpendicularPointOnInfinityLine(self.subGeom.vertexAt(afterVertex - 1), \
                                                            self.subGeom.vertexAt(afterVertex), \
                                                            transformedPt)
         offSetDistance = qad_utils.getDistance(transformedPt, pt)
      else:        
         offSetDistance = qad_utils.distMapToLayerCoordinates(self.offSet, \
                                                              self.plugIn.canvas,\
                                                              layer)                     
         if self.multi == True:
            if dummy[3] < 0: # alla sinistra
               offSetDistance = offSetDistance + self.lastOffSetOnLeftSide
               self.lastOffSetOnLeftSide = offSetDistance
               self.getPointMapTool().lastOffSetOnLeftSide = self.lastOffSetOnLeftSide                     
            else: # alla destra
               offSetDistance = offSetDistance + self.lastOffSetOnRightSide
               self.lastOffSetOnRightSide = offSetDistance            
               self.getPointMapTool().lastOffSetOnRightSide = self.lastOffSetOnRightSide

      tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                  self.plugIn.canvas,\
                                                                  layer)
      epsg = layer.crs().authid()      
      lines = qad_utils.offSetPolyline(self.subGeom.asPolyline(), epsg, \
                                       offSetDistance, \
                                       "left" if dummy[3] < 0 else "right", \
                                       self.gapType, \
                                       tolerance2ApproxCurve)
      added = False
      for line in lines:        
         if layer.geometryType() == QGis.Polygon:
            if line[0] == line[-1]: # se é una linea chiusa
               offsetGeom = QgsGeometry.fromPolygon([line])
            else:
               offsetGeom = QgsGeometry.fromPolyline(line)
         else:
            offsetGeom = QgsGeometry.fromPolyline(line)

         if offsetGeom.type() == QGis.Line or offsetGeom.type() == QGis.Polygon:           
            offsetFeature = QgsFeature(f)                              
            offsetFeature.setGeometry(offsetGeom)
            self.featureCache.append([layer, offsetFeature])
            self.addFeatureToRubberBand(layer, offsetFeature)            
            added = True           

      if added:      
         self.undoFeatureCacheIndexes.append(featureCacheLen)

 def canvasMoveEvent(self, event):
    QadGetPoint.canvasMoveEvent(self, event)
                   
    # noto il punto base si richiede il secondo punto per la scala
    if self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_SCALE_PT:
       scale = qad_utils.getDistance(self.basePt, self.tmpPoint)
       self.addScaledGeometries(scale)                           
    # noto il primo punto si richiede il secondo punto per la lunghezza di riferimento
    elif self.mode == Qad_scale_maptool_ModeEnum.BASE_PT_KNOWN_ASK_FOR_NEW_LEN_PT:
       len = qad_utils.getDistance(self.basePt, self.tmpPoint)
       scale = len / self.ReferenceLen
       self.addScaledGeometries(scale)                           
    # noto il primo punto si richiede il secondo punto per la nuova lunghezza
    elif self.mode == Qad_scale_maptool_ModeEnum.FIRST_PT_KNOWN_ASK_FOR_SECOND_NEW_LEN_PT:
       len = qad_utils.getDistance(self.Pt1NewLen, self.tmpPoint)
       scale = len / self.ReferenceLen
       self.addScaledGeometries(scale)                           

 def canvasMoveEvent(self, event):
    QadGetPoint.canvasMoveEvent(self, event)
    
    self.__rubberBand.reset()
       
    result = False
    circle = QadCircle()    
    
    # noto il centro del cerchio si richiede il raggio
    if self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_RADIUS:
       radius = qad_utils.getDistance(self.centerPt, self.tmpPoint)
       circle.set(self.centerPt, radius)
       result = True
    # noto il centro del cerchio si richiede il diametro
    elif self.mode == Qad_circle_maptool_ModeEnum.CENTER_PT_KNOWN_ASK_FOR_DIAM:
       diam = qad_utils.getDistance(self.centerPt, self.tmpPoint)
       result = circle.set(self.centerPt, diam / 2)
       result = True
    # noto il primo e il secondo punto si richiede il terzo punto
    elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_PT_KNOWN_ASK_FOR_THIRD_PT:
       if (self.firstPt is not None) and (self.secondPt is not None):
          result = circle.from3Pts(self.firstPt, self.secondPt, self.tmpPoint)
    # noto il primo punto di estremità diam si richiede il secondo punto di estremità diam
    elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_DIAM_PT_KNOWN_ASK_FOR_SECOND_DIAM_PT:
       if self.firstDiamPt is not None:
          result = circle.fromDiamEnds(self.firstDiamPt, self.tmpPoint)
    # noto note la prima, la seconda entita dei punti di tangenza e il primo punto per misurare il raggio
    # si richiede il secondo punto per misurare il raggio
    elif self.mode == Qad_circle_maptool_ModeEnum.FIRST_SECOND_TAN_FIRSTPTRADIUS_KNOWN_ASK_FOR_SECONDPTRADIUS:
       radius = qad_utils.getDistance(self.startPtForRadius, self.tmpPoint)
       result = circle.from2TanPtsRadius(self.tanGeom1, self.tanPt1, \
                                         self.tanGeom2, self.tanPt2, radius)
    
    if result == True:
       points = circle.asPolyline()
    
       if points is not None:
          if self.geomType == QGis.Polygon:
             self.__rubberBand.setPolygon(points)
          else:
             self.__rubberBand.setLine(points)

    def fromStartCenterEndPts(self, startPt, centerPt, endPt):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      centro
      punto finale
      """
        if startPt == centerPt or startPt == endPt or endPt == centerPt:
            return False

        self.center = centerPt
        self.radius = qad_utils.getDistance(centerPt, startPt)
        self.startAngle = qad_utils.getAngleBy2Pts(centerPt, startPt)
        self.endAngle = qad_utils.getAngleBy2Pts(centerPt, endPt)
        return True

    def fromStartCenterPtsAngle(self, startPt, centerPt, angle):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      centro
      angolo inscritto
      """
        if startPt == centerPt or angle == 0:
            return False

        self.center = centerPt
        self.radius = qad_utils.getDistance(centerPt, startPt)
        self.startAngle = qad_utils.getAngleBy2Pts(centerPt, startPt)
        self.endAngle = self.startAngle + angle
        if self.endAngle > math.pi * 2:
            self.endAngle = self.endAngle % (math.pi * 2)  # modulo
        return True

   def addOffSetGeometries(self, newPt):
      self.__rubberBand.reset()            
            
      transformedPt = self.plugIn.canvas.mapRenderer().mapToLayerCoordinates(self.layer, newPt)
      
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      dummy = qad_utils.closestSegmentWithContext(transformedPt, self.subGeom)
      if self.offSet < 0:
         afterVertex = dummy[2]
         pt = qad_utils.getPerpendicularPointOnInfinityLine(self.subGeom.vertexAt(afterVertex - 1), \
                                                            self.subGeom.vertexAt(afterVertex), \
                                                            transformedPt)
         offSetDistance = qad_utils.getDistance(transformedPt, pt)
      else:           
         offSetDistance = qad_utils.distMapToLayerCoordinates(self.offSet, \
                                                              self.plugIn.canvas,\
                                                              self.layer)
         if dummy[3] < 0: # alla sinistra
            offSetDistance = offSetDistance + self.lastOffSetOnLeftSide
         else: # alla destra
            offSetDistance = offSetDistance + self.lastOffSetOnRightSide         
      
      tolerance2ApproxCurve = qad_utils.distMapToLayerCoordinates(QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE")), \
                                                                  self.plugIn.canvas,\
                                                                  self.layer)
      epsg = self.layer.crs().authid()      
      lines = qad_utils.offSetPolyline(self.subGeom.asPolyline(), epsg, \
                                       offSetDistance, \
                                       "left" if dummy[3] < 0 else "right", \
                                       self.gapType, \
                                       tolerance2ApproxCurve)

      for line in lines:
         if self.layer.geometryType() == QGis.Polygon:
            if line[0] == line[-1]: # se é una linea chiusa
               offsetGeom = QgsGeometry.fromPolygon([line])
            else:
               offsetGeom = QgsGeometry.fromPolyline(line)
         else:
            offsetGeom = QgsGeometry.fromPolyline(line)

         self.__rubberBand.addGeometry(offsetGeom, self.layer)

    def fromStartCenterPtsChord(self, startPt, centerPt, chord):
        """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      centro
      lunghezza dela corda tra punto iniziale e finale
      """
        if startPt == centerPt or chord == 0:
            return False

        self.center = centerPt
        self.radius = qad_utils.getDistance(centerPt, startPt)
        if chord > 2 * self.radius:
            return False
        self.startAngle = qad_utils.getAngleBy2Pts(centerPt, startPt)
        # Teorema della corda
        angle = 2 * math.asin(chord / (2 * self.radius))
        self.endAngle = self.startAngle + angle
        return True

   def addOffSetGeometries(self, newPt):
      self.__highlight.reset()            
      
      # ritorna una tupla (<The squared cartesian distance>,
      #                    <minDistPoint>
      #                    <afterVertex>
      #                    <leftOf>)
      dummy = qad_utils.closestSegmentWithContext(newPt, self.subGeom)
      if self.offSet < 0:
         afterVertex = dummy[2]
         pt = qad_utils.getPerpendicularPointOnInfinityLine(self.subGeom.vertexAt(afterVertex - 1), \
                                                            self.subGeom.vertexAt(afterVertex), \
                                                            newPt)
         offSetDistance = qad_utils.getDistance(newPt, pt)
      else:           
         offSetDistance = self.offSet

         if dummy[3] < 0: # alla sinistra
            offSetDistance = offSetDistance + self.lastOffSetOnLeftSide
         else: # alla destra
            offSetDistance = offSetDistance + self.lastOffSetOnRightSide         
      
      tolerance2ApproxCurve = QadVariables.get(QadMsg.translate("Environment variables", "TOLERANCE2APPROXCURVE"))
      # uso il crs del canvas per lavorare con coordinate piane xy
      epsg = self.canvas.mapSettings().destinationCrs().authid()
      lines = qad_utils.offSetPolyline(self.subGeom.asPolyline(), epsg, \
                                       offSetDistance, \
                                       "left" if dummy[3] < 0 else "right", \
                                       self.gapType, \
                                       tolerance2ApproxCurve)

      for line in lines:
         if self.layer.geometryType() == QGis.Polygon:
            if line[0] == line[-1]: # se é una linea chiusa
               offsetGeom = QgsGeometry.fromPolygon([line])
            else:
               offsetGeom = QgsGeometry.fromPolyline(line)
         else:
            offsetGeom = QgsGeometry.fromPolyline(line)

         self.__highlight.addGeometry(self.mapToLayerCoordinates(self.layer, offsetGeom), self.layer)

   def fromStartCenterPtsLength(self, startPt, centerPt, length):
      """
      setta le caratteristiche dell'arco attraverso:
      punto iniziale
      centro
      lunghezza dela corda tra punto iniziale e finale
      """
      if startPt == centerPt or chord == 0:
         return False

      self.center = centerPt
      self.radius = qad_utils.getDistance(centerPt, startPt)
      circumference = 2 * math.pi * self.radius
      if length >= circumference:
         return False
      self.startAngle = qad_utils.getAngleBy2Pts(centerPt, startPt)
      
      #circumference : math.pi * 2 = length : angle
      angle = (math.pi * 2) * length / circumference
      self.endAngle = self.startAngle + angle
      return True