def activate(self):
cursor = QCursor()
cursor.setShape(Qt.ArrowCursor)
self.iface.mapCanvas().setCursor(cursor)
myLayers = []
# Editing
layers = self.getLayers()
for layer in layers:
openedLayerPath = self.getLayerPath(layer)
for name in self.ownMainLayers:
layerPath = self.generatePath(self.ProjectDirectory, self.NetworkName + "_" + name + ".shp")
if openedLayerPath == layerPath:
myLayers.append(layer)
if not layer.isEditable():
layer.startEditing()
# Snapping
self.snapper = QgsMapCanvasSnappingUtils(self.iface.mapCanvas())
self.snapper.setMapSettings(self.iface.mapCanvas().mapSettings())
config = QgsSnappingConfig(QgsProject.instance())
config.setType(2) # Vertex
config.setMode(2) # All layers
config.setTolerance(1)
config.setUnits(2) # Pixels
config.setEnabled(True)
self.snapper.setConfig(config)
def __init__(self, iface: QgisInterface, layer):
QgepMapToolAddFeature.__init__(self, iface, layer)
self.snapping_marker = None
self.node_layer = QgepLayerManager.layer('vw_wastewater_node')
assert self.node_layer is not None
self.reach_layer = QgepLayerManager.layer('vw_qgep_reach')
assert self.reach_layer is not None
self.setAdvancedDigitizingAllowed(True)
self.setAutoSnapEnabled(True)
layer_snapping_configs = [{
'layer': self.node_layer,
'mode': QgsSnappingConfig.Vertex
}, {
'layer': self.reach_layer,
'mode': QgsSnappingConfig.VertexAndSegment
}]
self.snapping_configs = []
self.snapping_utils = QgsMapCanvasSnappingUtils(self.iface.mapCanvas())
for lsc in layer_snapping_configs:
config = QgsSnappingConfig()
config.setMode(QgsSnappingConfig.AdvancedConfiguration)
config.setEnabled(True)
settings = QgsSnappingConfig.IndividualLayerSettings(
True, lsc['mode'], 10, QgsTolerance.Pixels)
config.setIndividualLayerSettings(lsc['layer'], settings)
self.snapping_configs.append(config)
def resetSnapping(self):
self.unlink_mode = False
# disable previous snapping setting
proj = QgsProject.instance()
snapConfig = QgsSnappingConfig()
if self.settings[0] != '' and self.settings[0]:
# proj.writeEntry('Digitizing', 'SnappingMode', 'advanced')
layer = lfh.getLayerByName(self.settings[0])
if layer: # layer might have been removed
snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration)
layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(False, QgsSnappingConfig.Vertex,
self.settings[2], QgsTolerance.LayerUnits)
snapConfig.setIndividualLayerSettings(layer, layerSnapConfig)
proj.setAvoidIntersectionsLayers([layer])
if self.settings[1] != 'no unlinks' and self.settings[1]:
# proj.writeEntry('Digitizing', 'SnappingMode', 'advanced')
layer = lfh.getLayerByName(self.settings[1])
if layer:
snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration)
layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(False, QgsSnappingConfig.Vertex,
self.settings[2], QgsTolerance.LayerUnits)
snapConfig.setIndividualLayerSettings(layer, layerSnapConfig)
proj.setAvoidIntersectionsLayers([])
snapConfig.setIntersectionSnapping(False)
proj.setSnappingConfig(snapConfig)
return
def configure_snapping_settings():
my_snap_config = QgsSnappingConfig()
my_snap_config.setEnabled(True)
my_snap_config.setMode(QgsSnappingConfig.AllLayers)
my_snap_config.setType(QgsSnappingConfig.Vertex)
my_snap_config.setUnits(QgsTolerance.Pixels)
my_snap_config.setTolerance(10)
my_snap_config.setIntersectionSnapping(True)
QgsProject.instance().setSnappingConfig(my_snap_config)
def configSnapper(self, type):
# Snapping
self.snapper = QgsMapCanvasSnappingUtils(self.iface.mapCanvas())
self.snapper.setMapSettings(self.iface.mapCanvas().mapSettings())
config = QgsSnappingConfig(QgsProject.instance())
config.setType(type) # 1: Vertex; 2:Segment
config.setMode(2) # All layers
config.setTolerance(10)
config.setUnits(1) # Pixels
config.setEnabled(True)
self.snapper.setConfig(config)
def activate(self):
QgsMapTool.activate(self)
# Snapping
self.snapper = QgsMapCanvasSnappingUtils(self.iface.mapCanvas())
self.snapper.setMapSettings(self.iface.mapCanvas().mapSettings())
config = QgsSnappingConfig(QgsProject.instance())
config.setType(1) # Vertex
config.setMode(2) # All layers
config.setTolerance(2)
config.setUnits(2) # Pixels
config.setEnabled(True)
self.snapper.setConfig(config)
def setSnapLayers(self, snapper, layers):
config = QgsSnappingConfig()
config.setMode(QgsSnappingConfig.AdvancedConfiguration)
config.setEnabled(True)
for layer in layers:
if layer:
ils = QgsSnappingConfig.IndividualLayerSettings(
True, QgsSnappingConfig.VertexAndSegment, 16,
QgsTolerance.Pixels)
config.setIndividualLayerSettings(layer, ils)
snapper.setConfig(config)
def init_snapper(self):
"""
Initialize snapper
"""
if not self.snapper:
self.node_layer = self.network_analyzer.getNodeLayer()
self.snapper = QgsMapCanvasSnappingUtils(self.canvas)
config = QgsSnappingConfig()
config.setMode(QgsSnappingConfig.AdvancedConfiguration)
config.setEnabled(True)
ils = QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.VertexAndSegment,
16, QgsTolerance.Pixels)
config.setIndividualLayerSettings(self.node_layer, ils)
self.snapper.setConfig(config)
def setSnapLayers(self, snapper, layers):
config = QgsSnappingConfig()
config.setMode(QgsSnappingConfig.AdvancedConfiguration)
config.setEnabled(True)
for layer in layers:
if layer:
ils = QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.VertexAndSegment,
16, QgsTolerance.Pixels)
config.setIndividualLayerSettings(layer, ils)
layer.destroyed.connect(self.deactivate)
snapper.setConfig(config)
snapper.layer_priority = layers
def setAxialSnapping(self):
# keep button pressed
# un press other buttons
# disable previous snapping setting
self.resetSnapping()
# self.axialButton.setCheckable(True)
self.resetIcons()
axial_icon = QPixmap(os.path.dirname(__file__) + "/custom_icons/axial.png")
self.axialButton.setIcon(QIcon(axial_icon))
self.axialButton.setIconSize(QSize(40, 40))
# snap to nothing
if self.settings[0] != '':
proj = QgsProject.instance()
# fix_print_with_import
# fix_print_with_import
print(proj, 'ax')
proj.writeEntry('Digitizing', 'SnappingMode', 'advanced')
layer = lfh.getLayerByName(self.settings[0])
self.iface.setActiveLayer(layer)
# if layer.isEditable():
# layer.commitChanges()
# else:
# layer.startEditing()
snapConfig = QgsSnappingConfig()
snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration)
layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(False, QgsSnappingConfig.Vertex,
self.settings[2], QgsTolerance.LayerUnits)
snapConfig.setIndividualLayerSettings(layer, layerSnapConfig)
snapConfig.setEnabled(False)
proj.setAvoidIntersectionsLayers([layer])
proj.setSnappingConfig(snapConfig)
proj.setTopologicalEditing(False)
self.axial_mode = True
else:
self.iface.messageBar().pushMessage("Network layer not specified!", Qgis.Critical, duration=5)
self.axial_mode = False
return
def setUnlinkSnapping(self):
# disable previous snapping setting if segment
self.resetSnapping()
# snap to vertex
if self.settings[1] != 'no unlinks':
self.resetIcons()
unlink_icon = QPixmap(os.path.dirname(__file__) + "/custom_icons/unlink.png")
self.unlinksButton.setIcon(QIcon(unlink_icon))
self.unlinksButton.setIconSize(QSize(40, 40))
proj = QgsProject.instance()
# fix_print_with_import
# fix_print_with_import
print(proj, 'un')
proj.writeEntry('Digitizing', 'SnappingMode', 'advanced')
layer = lfh.getLayerByName(self.settings[0])
unlinks_layer = lfh.getLayerByName(self.settings[1])
# if unlinks_layer.isEditable():
# unlinks_layer.commitChanges()
# else:
# unlinks_layer.startEditing()
self.iface.setActiveLayer(unlinks_layer)
snapConfig = QgsSnappingConfig()
snapConfig.setMode(QgsSnappingConfig.AdvancedConfiguration)
layerSnapConfig = QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex,
self.settings[2], QgsTolerance.LayerUnits)
snapConfig.setIndividualLayerSettings(layer, layerSnapConfig)
proj.setAvoidIntersectionsLayers([layer])
snapConfig.setIntersectionSnapping(True)
snapConfig.setEnabled(True)
QgsProject.instance().setSnappingConfig(snapConfig)
proj.setTopologicalEditing(False)
self.unlink_mode = True
else:
self.iface.messageBar().pushMessage("Unlinks layer not specified!", Qgis.Critical, duration=5)
self.unlink_mode = False
return
class TOMsNodeTool(MapToolMixin, RestrictionTypeUtilsMixin, NodeTool):
def __init__(self, iface, proposalsManager, restrictionTransaction):
#def __init__(self, iface, proposalsManager, restrictionTransaction, currFeature, currLayer):
QgsMessageLog.logMessage("In TOMsNodeTool:initialising .... ", tag="TOMs panel")
self.iface = iface
canvas = self.iface.mapCanvas()
cadDock = self.iface.cadDockWidget()
NodeTool.__init__(self, canvas, cadDock)
# set current layer to active layer to avoid any issues in NodeTools cadCanvasReleaseEvent
#canvas.setCurrentLayer(self.iface.activeLayer())
self.proposalsManager = proposalsManager
self.restrictionTransaction = restrictionTransaction
#self.constants = TOMsConstants()
#self.origFeature = self.originalFeature()
# taken from mapTools.CreateRestrictionTool (not sure if they will make a difference ...)
# self.setMode(TOMsNodeTool.CaptureLine)
self.snappingConfig = QgsSnappingConfig()
self.snappingConfig.setMode(QgsSnappingConfig.AdvancedConfiguration)
#RoadCasementLayer = QgsProject.instance().mapLayersByName("rc_nsg_sideofstreet")[0]
# get details of the selected feature
self.selectedRestriction = self.iface.activeLayer().selectedFeatures()[0]
QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... saving original feature + " + self.selectedRestriction.attribute("GeometryID"), tag="TOMs panel")
# Create a copy of the feature
self.origFeature = originalFeature()
self.origFeature.setFeature(self.selectedRestriction)
self.origLayer = self.iface.activeLayer()
QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... original layer + " + self.origLayer.name(), tag="TOMs panel")
#self.origLayer.startEditing()
self.origFeature.printFeature()
self.origLayer.geometryChanged.connect(self.on_cached_geometry_changed)
self.origLayer.featureDeleted.connect(self.on_cached_geometry_deleted)
#*** New
#RestInProp = self.constants.RESTRICTIONS_IN_PROPOSALS_LAYER()
#QgsMessageLog.logMessage("In init: RestInProp: " + str(RestInProp.name()), tag="TOMs panel")
#RestInProp.editCommandEnded.connect(self.proposalsManager.updateMapCanvas())
advancedDigitizingPanel = iface.mainWindow().findChild(QDockWidget, 'AdvancedDigitizingTools')
advancedDigitizingPanel.setVisible(True)
self.setupPanelTabs(self.iface, advancedDigitizingPanel)
self.setAdvancedDigitizingAllowed(True)
self. setAutoSnapEnabled(True)
#QgsMapToolAdvancedDigitizing.deactivate(self)
#QgsMapToolAdvancedDigitizing.activate(self)
#self.newFeature = None
self.finishEdit = False
self.iface.mapCanvas().mapToolSet.connect(self.setUnCheck)
self.proposalsManager.TOMsToolChanged.connect(functools.partial(self.onGeometryChanged, self.origFeature.getFeature()))
# get details of the selected feature
#self.selectedRestriction = self.iface.activeLayer().selectedFeatures()[0]
#QgsMessageLog.logMessage("In TOMsNodeTool:initialising ... saving original feature + " + self.selectedRestriction.attribute("GeometryID"), tag="TOMs panel")
#self.origFeature.setFeature(self.selectedRestriction)
#self.currFeature = currFeature
#self.currLayer = currLayer
#self.origLayer = self.iface.activeLayer()
#self.origLayer.startEditing()
#self.origFeature.printFeature()
#cache = self.cached_geometry(self.currLayer, self.currFeature.id())
#newFeature = self.prepareRestrictionForEdit(self.selectedRestriction, self.origLayer)
#QgsMessageLog.logMessage("In TOMsNodeTool:init - fid: " + str(self.newFid), tag="TOMs panel")
#self.origLayer.selectByIds([self.newFid])
#self.origLayer.selectByIds([self.newFid])
def setUnCheck(self):
pass
def deactivate(self):
QgsMessageLog.logMessage("In TOMsNodeTool:deactivate .... ", tag="TOMs panel")
NodeTool.deactivate(self)
def shutDownNodeTool(self):
QgsMessageLog.logMessage("In TOMsNodeTool:shutDownNodeTool .... ", tag="TOMs panel")
# TODO: May need to disconnect geometryChange and featureDeleted signals
self.origLayer.geometryChanged.disconnect(self.on_cached_geometry_changed)
self.origLayer.featureDeleted.disconnect(self.on_cached_geometry_deleted)
self.proposalsManager.TOMsToolChanged.disconnect()
self.set_highlighted_nodes([])
self.remove_temporary_rubber_bands()
#currAction = self.iface.mapCanvas().mapTool().action()
#currAction.setChecked(False)
self.proposalPanel = self.iface.mainWindow().findChild(QDockWidget, 'ProposalPanelDockWidgetBase')
self.setupPanelTabs(self.iface, self.proposalPanel)
#self.iface.mapCanvas().unsetMapTool(self.mapTool)
#NodeTool.deactivate()
def onGeometryChanged(self, currRestriction):
# Added by TH to deal with RestrictionsInProposals
# When a geometry is changed; we need to check whether or not the feature is part of the current proposal
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. fid: " + str(currRestriction.id()) + " GeometryID: " + str(currRestriction.attribute("GeometryID")), tag="TOMs panel")
# disconnect signal for geometryChanged
#self.origLayer.geometryChanged.disconnect(self.on_cached_geometry_changed)
#self.proposalsManager.TOMsToolChanged.disconnect()
#self.currLayer = self.iface.activeLayer()
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. Layer: " + str(self.origLayer.name()), tag="TOMs panel")
#currLayer.geometryChanged.disconnect(self.onGeometryChanged)
#QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. geometryChange signal disconnected.", tag="TOMs panel")
idxRestrictionID = self.origLayer.fields().indexFromName("RestrictionID")
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. currProposal: " + str(self.proposalsManager.currentProposal()), tag="TOMs panel")
# Now obtain the changed feature (not sure which geometry)
#currFeature = self.THgetFeature(fid, currLayer)
#self.origFeature.printFeature()
#currFeature = currRestriction
newGeometry = QgsGeometry(self.feature_band.asGeometry())
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom incoming: " + newGeometry.asWkt(),
tag="TOMs panel")
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. currRestrictionID: " + str(currRestriction[idxRestrictionID]), tag="TOMs panel")
if not self.restrictionInProposal(currRestriction[idxRestrictionID], self.getRestrictionLayerTableID(self.origLayer), self.proposalsManager.currentProposal()):
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - adding details to RestrictionsInProposal", tag="TOMs panel")
# This one is not in the current Proposal, so now we need to:
# - generate a new ID and assign it to the feature for which the geometry has changed
# - switch the geometries arround so that the original feature has the original geometry and the new feature has the new geometry
# - add the details to RestrictionsInProposal
originalfeature = self.origFeature.getFeature()
newFeature = QgsFeature(self.origLayer.fields())
newFeature.setAttributes(currRestriction.attributes())
newFeature.setGeometry(newGeometry)
newRestrictionID = str(uuid.uuid4())
newFeature[idxRestrictionID] = newRestrictionID
idxOpenDate = self.origLayer.fields().indexFromName("OpenDate")
idxGeometryID = self.origLayer.fields().indexFromName("GeometryID")
newFeature[idxOpenDate] = None
newFeature[idxGeometryID] = None
#currLayer.addFeature(newFeature)
self.origLayer.addFeatures([newFeature])
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - attributes: " + str(newFeature.attributes()), tag="TOMs panel")
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom: " + newFeature.geometry().asWkt(), tag="TOMs panel")
originalGeomBuffer = QgsGeometry(originalfeature.geometry())
QgsMessageLog.logMessage(
"In TOMsNodeTool:onGeometryChanged - originalGeom: " + originalGeomBuffer.asWkt(),
tag="TOMs panel")
self.origLayer.changeGeometry(currRestriction.id(), originalGeomBuffer)
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - geometries switched.", tag="TOMs panel")
self.addRestrictionToProposal(currRestriction[idxRestrictionID], self.getRestrictionLayerTableID(self.origLayer), self.proposalsManager.currentProposal(), RestrictionAction.OPEN) # close the original feature
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - feature closed.", tag="TOMs panel")
self.addRestrictionToProposal(newRestrictionID, self.getRestrictionLayerTableID(self.origLayer), self.proposalsManager.currentProposal(), RestrictionAction.OPEN) # open the new one
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - feature opened.", tag="TOMs panel")
#self.proposalsManager.updateMapCanvas()
else:
# assign the changed geometry to the current feature
#currRestriction.setGeometry(newGeometry)
pass
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom (2): " + currRestriction.geometry().asWkt(),
tag="TOMs panel")
# Trying to unset map tool to force updates ...
#self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool())
#currMapTool = self.iface.mapCanvas().mapTool()
#currAction = currMapTool.action()
#currMapToolAction = self.iface.mapCanvas().mapTool().action().setChecked(False)
# uncheck current tool
self.restrictionTransaction.commitTransactionGroup(self.origLayer)
#self.restrictionTransaction.deleteTransactionGroup()
self.origLayer.deselect(self.origFeature.getFeature().id())
self.shutDownNodeTool()
# **** New
""""#currRestrictionRestrictionID = currFeature[idxRestrictionID]
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged. currRestrictionID: " + str(self.currFeature[idxRestrictionID]), tag="TOMs panel")
self.currFeature.setGeometry(newGeometry)
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - attributes: " + str(self.currFeature.attributes()),
tag="TOMs panel")
QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - newGeom: " + self.currFeature.geometry().asWkt(),
tag="TOMs panel")
# Trying to unset map tool to force updates ...
#self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool())
# change active layer
status = self.iface.setActiveLayer(None)
self.restrictionTransaction.commitTransactionGroup(self.currLayer)
#self.restrictionTransaction.deleteTransactionGroup()
#QTimer.singleShot(0, functools.partial(RestrictionTypeUtils.commitRestrictionChanges, origLayer))
#QgsMessageLog.logMessage("In TOMsNodeTool:onGeometryChanged - geometry saved.", tag="TOMs panel")"""
return
def cadCanvasPressEvent(self, e):
QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent", tag="TOMs panel")
NodeTool.cadCanvasPressEvent(self, e)
QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent: after NodeTool.cadCanvasPressEvent", tag="TOMs panel")
#currLayer = self.iface.activeLayer()
if e.button() == Qt.RightButton:
QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent: right button pressed",
tag="TOMs panel")
self.finishEdit = True
if self.origLayer.isModified():
QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasPressEvent: orig layer modified",
tag="TOMs panel")
self.onGeometryChanged(self.selectedRestriction)
#RestrictionTypeUtils.commitRestrictionChanges(self.origLayer)
#self.iface.setActiveLayer(None) # returns bool
pass
return
def cadCanvasReleaseEvent(self, e):
QgsMessageLog.logMessage("In TOMsNodeTool:cadCanvasReleaseEvent", tag="TOMs panel")
if self.finishEdit == True:
# unset Tool ??
self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool())
return
NodeTool.cadCanvasReleaseEvent(self, e)
def snap_to_editable_layer(self, e):
""" Temporarily override snapping config and snap to vertices and edges
of any editable vector layer, to allow selection of node for editing
(if snapped to edge, it would offer creation of a new vertex there).
"""
QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer", tag="TOMs panel")
map_point = self.toMapCoordinates(e.pos())
tol = QgsTolerance.vertexSearchRadius(self.canvas().mapSettings())
snap_type = QgsPointLocator.Type(QgsPointLocator.Vertex|QgsPointLocator.Edge)
#snap_layers = []
### TH: Amend to choose only from selected feature (and layer)
"""snap_layers.append(QgsSnappingUtils.LayerConfig(
self.origLayer, snap_type, tol, QgsTolerance.ProjectUnits))"""
"""for layer in self.canvas().layers():
if not isinstance(layer, QgsVectorLayer) or not layer.isEditable():
continue
snap_layers.append(QgsSnappingUtils.LayerConfig(
layer, snap_type, tol, QgsTolerance.ProjectUnits))"""
snap_util = self.canvas().snappingUtils()
old_snap_util = snap_util
snap_config = snap_util.config()
#snap_util = QgsSnappingUtils()
#snap_config = snap_util.config()
# old_layers = snap_util.layers()
# old_mode = snap_util.mode()
# old_intersections = old_snap_config.intersectionSnapping()
"""
for layer in snap_config.individualLayerSettings().keys():
snap_config.removeLayers([layer])
"""
snap_util.setCurrentLayer(self.origLayer)
snap_config.setMode(QgsSnappingConfig.ActiveLayer)
snap_config.setIntersectionSnapping(False) # only snap to layers
#m = snap_util.snapToMap(map_point)
snap_config.setTolerance(tol)
snap_config.setUnits(QgsTolerance.ProjectUnits)
snap_config.setType(QgsSnappingConfig.VertexAndSegment)
snap_config.setEnabled(True)
"""snap_config.setMode(QgsSnappingConfig.AdvancedConfiguration)
currLayerSnapSettings = snap_config.individualLayerSettings(self.origLayer)
currLayerSnapSettings.setTolerance(tol)
currLayerSnapSettings.setUnits(QgsTolerance.ProjectUnits)
currLayerSnapSettings.setType(QgsSnappingConfig.VertexAndSegment)
currLayerSnapSettings.setEnabled(True)
snap_config.setIndividualLayerSettings(self.origLayer, currLayerSnapSettings)"""
# try to stay snapped to previously used feature
# so the highlight does not jump around at nodes where features are joined
### TH: Amend to choose only from selected feature (and layer)
filter_last = OneFeatureFilter(self.origLayer, self.origFeature.getFeature().id())
# m = snap_util.snapToMap(map_point, filter_last)
"""if m_last.isValid() and m_last.distance() <= m.distance():
m = m_last"""
self.origFeature.printFeature()
QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer: origLayer " + self.origLayer.name(), tag="TOMs panel")
""" v3 try to use some other elements of snap_config
- snapToCurrentLayer
- setCurrentLayer
"""
QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer: pos " + str(e.pos().x()) + "|" + str(e.pos().y()),
tag="TOMs panel")
m = snap_util.snapToCurrentLayer(e.pos(), snap_type, filter_last)
"""self.canvas().setSnappingUtils(snap_util)
m = snap_util.snapToMap(e.pos(), filter_last)"""
#snap_util.setLayers(old_layers)
#snap_config.setMode(old_mode)
#snap_config.setIntersectionSnapping(old_intersections)
self.canvas().setSnappingUtils(old_snap_util)
#self.last_snap = m
# TODO: Tidy up ...
QgsMessageLog.logMessage("In TOMsNodeTool:snap_to_editable_layer: snap point " + str(m.type()) +";" + str(m.isValid()) + "; ", tag="TOMs panel")
return m
def keyPressEvent(self, e):
QgsMessageLog.logMessage("In TOMsNodeTool:keyPressEvent", tag="TOMs panel")
# want to pick up "esc" and exit tool
if e.key() == Qt.Key_Escape:
self.iface.mapCanvas().unsetMapTool(self.iface.mapCanvas().mapTool())
self.restrictionTransaction.rollBackTransactionGroup()
self.shutDownNodeTool()
return
NodeTool.keyPressEvent(self, e)
def run(id, gtotool, config, debug):
try:
#common tool objects
iface = gtotool.iface
info = gtotool.info
gtomain = gtotool.gtomain
#tool data
activelayer = config.get('active_layer', None)
active_tool = config['active_tool']
snapmode = config['snap_mode']
topologicalediting = config['topologicalediting']
snapping_on_intersection = config['snapping_on_intersection']
#default snappings
default_snap_type = config['default_snap_type']
default_snap_tolerance = config['default_snap_tolerance']
default_snap_tolerance_unit = config['default_snap_tolerance_unit']
#layers for advanced setting
layers = config['layers']
# needed objects
prj = QgsProject.instance()
snapconfig = QgsSnappingConfig(prj)
avoidIntersectLayers = []
if snapmode == 0:
snapconfig.setEnabled(False)
else:
# set default snapping
snapconfig.setMode(snapmode)
snapconfig.setIntersectionSnapping(snapping_on_intersection)
snapconfig.setType(default_snap_type)
snapconfig.setUnits(default_snap_tolerance_unit)
snapconfig.setTolerance(default_snap_tolerance)
if snapmode == QgsSnappingConfig.AdvancedConfiguration:
#disable snapping for all layers
for maplayername, layer in prj.mapLayers().items():
if isinstance(layer, QgsVectorLayer):
snaplayer = snapconfig.individualLayerSettings(layer)
if layer.name() in layers:
snaplayer.setEnabled(True)
else:
snaplayer.setEnabled(False)
snapconfig.setIndividualLayerSettings(layer, snaplayer)
#set settings for layers
for setting in layers:
if debug: info.log("settings:", setting)
maplayer = prj.mapLayersByName(setting['name'])[0]
snaplayer = snapconfig.individualLayerSettings(maplayer)
snaplayer.setEnabled(
setting.get('snap', snaplayer.enabled()))
snaplayer.setUnits(setting.get('units', snaplayer.units()))
snaplayer.setTolerance(
setting.get('tolerance', snaplayer.tolerance()))
snaplayer.setType(
setting.get('mode',
setting.get('snap_type',
snaplayer.type())))
snapconfig.setIndividualLayerSettings(maplayer, snaplayer)
if setting.get('avoidintersection', True):
avoidIntersectLayers.append(maplayer)
prj.avoidIntersectionsLayers = avoidIntersectLayers
#enable the settings (snapping)
snapconfig.setEnabled(True)
#set topology editing for project
prj.setTopologicalEditing(topologicalediting)
#set snappingconfig to project
prj.setSnappingConfig(snapconfig)
except IndexError as e:
info.err(e)
try:
#set activelayer
activelayer = prj.mapLayersByName(activelayer)
if activelayer: activelayer = activelayer[0]
if isinstance(activelayer, QgsVectorLayer):
iface.setActiveLayer(activelayer)
except IndexError as e:
info.err(e)
try:
#start editing
layer = iface.activeLayer()
if not layer.isEditable():
layer.startEditing()
# run active tool
if active_tool:
gtomain.runcmd(active_tool)
except IndexError as e:
info.err(e)
