def instantiateNewCmd(self):

""" istanzia un nuovo comando dello stesso tipo """

return QadMBUFFERCommandClass(self.plugIn)

def getName(self):

return QadMsg.translate("Command_list", "MBUFFER")

def getEnglishName(self):

return "MBUFFER"

def connectQAction(self, action):

QObject.connect(action, SIGNAL("triggered()"), self.plugIn.runMBUFFERCommand)

def getIcon(self):

return QIcon(":/plugins/qad/icons/mbuffer.png")

def getNote(self):

# impostare le note esplicative del comando

return QadMsg.translate("Command_MBUFFER", "Creates polygons by buffering selected objects.")

def __init__(self, plugIn):

QadCommandClass.__init__(self, plugIn)

# se questo flag = True il comando serve all'interno di un altro comando per disegnare un buffer

# che non verrà salvato su un layer

self.virtualCmd = False

self.rubberBandBorderColor = None

self.rubberBandFillColor = None

self.SSGetClass = QadSSGetClass(plugIn)

self.entitySet = QadEntitySet()

self.width = 0

self.segments = self.plugIn.segments # il numero di segmenti per l'approssimazione delle curve

def __del__(self):

QadCommandClass.__del__(self)

del SSGetClass

def getPointMapTool(self, drawMode = QadGetPointDrawModeEnum.NONE):

if self.step == 0: # quando si é in fase di selezione entità

return self.SSGetClass.getPointMapTool()

else:

if (self.plugIn is not None):

if self.PointMapTool is None:

self.PointMapTool = Qad_mbuffer_maptool(self.plugIn)

self.PointMapTool.setRubberBandColor(self.rubberBandBorderColor, self.rubberBandFillColor)

return self.PointMapTool

else:

return None

def getCurrentContextualMenu(self):

if self.step == 0: # quando si é in fase di selezione entità

return self.SSGetClass.getCurrentContextualMenu()

else:

return self.contextualMenu

def setRubberBandColor(self, rubberBandBorderColor, rubberBandFillColor):

self.rubberBandBorderColor = rubberBandBorderColor

self.rubberBandFillColor = rubberBandFillColor

if self.PointMapTool is not None:

self.PointMapTool.setRubberBandColor(self.rubberBandBorderColor, self.rubberBandFillColor)

def AddGeoms(self, currLayer):

bufferGeoms = []

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

for layerEntitySet in self.entitySet.layerEntitySetList:

layer = layerEntitySet.layer

geoms = layerEntitySet.getGeometryCollection()

for geom in geoms:

# trasformo la geometria nel crs del canvas per lavorare con coordinate piane xy

newGeom = self.layerToMapCoordinates(layer, geom)

g = qad_utils.ApproxCurvesOnGeom(newGeom.buffer(self.width, self.segments), \

self.segments, self.segments, \

tolerance)

# trasformo la geometria nel crs del layer

bufferGeoms.append(self.mapToLayerCoordinates(layer, g))

self.plugIn.beginEditCommand("Feature buffered", currLayer)

# filtro le features per tipo

pointGeoms, lineGeoms, polygonGeoms = qad_utils.filterGeomsByType(bufferGeoms, \

currLayer.geometryType())

# aggiungo le geometrie del tipo corretto

if currLayer.geometryType() == QGis.Line:

polygonToLines = []

# Riduco le geometrie in linee

for g in polygonGeoms:

lines = qad_utils.asPointOrPolyline(g)

for l in lines:

if l.type() == QGis.Line:

polygonToLines.append(l)

# plugIn, layer, geoms, coordTransform , refresh, check_validity

if qad_layer.addGeomsToLayer(self.plugIn, currLayer, polygonToLines, None, False, False) == False:

self.plugIn.destroyEditCommand()

return

del polygonGeoms[:] # svuoto la lista

# plugIn, layer, geoms, coordTransform , refresh, check_validity

if qad_layer.addGeomsToLayer(self.plugIn, currLayer, bufferGeoms, None, False, False) == False:

self.plugIn.destroyEditCommand()

return

if pointGeoms is not None and len(pointGeoms) > 0:

PointTempLayer = qad_layer.createQADTempLayer(self.plugIn, QGis.Point)

self.plugIn.addLayerToLastEditCommand("Feature buffered", PointTempLayer)

if lineGeoms is not None and len(lineGeoms) > 0:

LineTempLayer = qad_layer.createQADTempLayer(self.plugIn, QGis.Line)

self.plugIn.addLayerToLastEditCommand("Feature buffered", LineTempLayer)

if polygonGeoms is not None and len(polygonGeoms) > 0:

PolygonTempLayer = qad_layer.createQADTempLayer(self.plugIn, QGis.Polygon)

self.plugIn.addLayerToLastEditCommand("Feature buffered", PolygonTempLayer)

# aggiungo gli scarti nei layer temporanei di QAD

# trasformo la geometria in quella dei layer temporanei

# plugIn, pointGeoms, lineGeoms, polygonGeoms, coord, refresh

if qad_layer.addGeometriesToQADTempLayers(self.plugIn, pointGeoms, lineGeoms, polygonGeoms, \

None, False) == False:

self.plugIn.destroyEditCommand()

return

self.plugIn.endEditCommand()

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