def testMapToolChange(self):
if isinstance(IFACE, QgisStubInterface):
advDigitizeWidget = QgsAdvancedDigitizingDockWidget(CANVAS, CANVAS)
if (version.parse(QtCore.qVersion()) < version.parse("5.11.0")):
toolMode = QgsMapToolCapture.CaptureLine
else:
toolMode = QgsMapToolCapture.CaptureMode.CaptureLine
captureMapTool = QgsMapToolCapture(CANVAS, advDigitizeWidget,
toolMode)
self.coordinator.reset()
CANVAS.setMapTool(QgsMapToolPan(CANVAS))
self.assertFalse(self.dw.addFeatureButton.isEnabled())
QTest.keyClicks(self.dw.inLeft, "8")
self.assertFalse(self.dw.addFeatureButton.isEnabled())
CANVAS.setMapTool(captureMapTool)
self.assertTrue(self.dw.addFeatureButton.isEnabled())
CANVAS.setMapTool(QgsMapToolPan(CANVAS))
self.assertFalse(self.dw.addFeatureButton.isEnabled())
self.coordinator.reset()
self.assertFalse(self.dw.addFeatureButton.isEnabled())
CANVAS.setMapTool(captureMapTool)
# add Feature Button should not be enabled when there is no input
self.assertFalse(self.dw.addFeatureButton.isEnabled())
else:
self.skipTest("not yet implemented for QGIS GUI tests")
def unload(self):
if self.prevTool and self.prevTool != self.swipe_tool:
self.map_canvas.setMapTool(self.prevTool)
else:
self.map_canvas.setMapTool(QgsMapToolPan(self.iface.mapCanvas()))
del self.tool_bar
def load_inputs(self):
if 'soil_layer' in self.input_layers:
QgsMapLayerRegistry.instance().removeMapLayer(
self.input_layers['soil_layer'])
if 'lulc_layer' in self.input_layers:
QgsMapLayerRegistry.instance().removeMapLayer(
self.input_layers['lulc_layer'])
if 'slope_layer' in self.input_layers:
QgsMapLayerRegistry.instance().removeMapLayer(
self.input_layers['slope_layer'])
path = self.folder_path.text()
self.input_layers['soil_layer'] = self.iface.addVectorLayer(
os.path.join(path, 'Soil.shp'), 'Soil Cover', 'ogr')
self.input_layers['lulc_layer'] = self.iface.addVectorLayer(
os.path.join(path, 'LULC.shp'), 'Land-Use-Land-Cover', 'ogr')
self.input_layers['slope_layer'] = self.iface.addRasterLayer(
os.path.join(path, 'Slope.tif'), 'Slope')
self.iface.mapCanvas().setExtent(
self.input_layers['slope_layer'].extent())
if os.path.exists(os.path.join(path, 'Rainfall.csv')):
self.rainfall_csv_filepath.setText(
os.path.join(path, 'Rainfall.csv'))
et0_dict = list(csv.DictReader(open(os.path.join(path, 'ET0.csv'))))[0]
for month, i in zip([
'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan', 'Feb',
'Mar', 'Apr', 'May'
], range(12)):
self.ET0.setItem(i, 0, QtGui.QTableWidgetItem(et0_dict[month]))
#Reset picking mode for any newly loaded dataset
self.picking_mode = False
self.pick_point_button.setText('Pick a Point')
self.iface.mapCanvas().setMapTool(QgsMapToolPan(
self.iface.mapCanvas()))
def __init__(self, geogiglayer, fid):
super(VersionViewerDialog, self).__init__(iface.mainWindow())
self.geogiglayer = geogiglayer
self.fid = fid
self.layer = None
self.setupUi(self)
self.listWidget.itemClicked.connect(self.commitClicked)
horizontalLayout = QHBoxLayout()
horizontalLayout.setSpacing(0)
horizontalLayout.setMargin(0)
self.mapCanvas = QgsMapCanvas()
self.mapCanvas.setCanvasColor(Qt.white)
horizontalLayout.addWidget(self.mapCanvas)
self.mapWidget.setLayout(horizontalLayout)
self.panTool = QgsMapToolPan(self.mapCanvas)
self.mapCanvas.setMapTool(self.panTool)
path = geogiglayer.layername + "/" + fid
ids, commits = geogiglayer.server.log(geogiglayer.user,
geogiglayer.repo, "master", path)
if commits:
for commit in commits.values():
item = CommitListItem(commit, geogiglayer, fid)
self.listWidget.addItem(item)
else:
raise GeogigError("The selected feature is not versioned yet")
def connectButtons(self):
"""
Connect the default buttons in the interface. Zoom, pan, etc
"""
def connectAction(action, tool):
action.toggled.connect(partial(self.setMapTool, tool))
def cursor(name):
pix = QPixmap(name)
pix = pix.scaled(QSize(24, 24))
return QCursor(pix)
self.zoomInTool = QgsMapToolZoom(self.canvas, False)
self.zoomOutTool = QgsMapToolZoom(self.canvas, True)
self.panTool = QgsMapToolPan(self.canvas)
self.infoTool = InfoTool(self.canvas)
self.infoTool.setAction(self.actionInfo)
self.zoomInTool.setAction(self.actionZoom_In)
self.zoomOutTool.setAction(self.actionZoom_Out)
self.panTool.setAction(self.actionPan)
connectAction(self.actionZoom_In, self.zoomInTool)
connectAction(self.actionZoom_Out, self.zoomOutTool)
connectAction(self.actionPan, self.panTool)
connectAction(self.actionInfo, self.infoTool)
self.zoomInTool.setCursor(cursor(':/icons/in'))
self.zoomOutTool.setCursor(cursor(':/icons/out'))
self.infoTool.setCursor(cursor(':/icons/select'))
self.actionRaster.triggered.connect(self.toggle_raster_layers)
self.actionHome.triggered.connect(self.homeview)
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.thematic_file_classes = None
self.map_tool_pan = QgsMapToolPan(self.render_widget.canvas)
self.render_widget.canvas.setMapTool(self.map_tool_pan, clean=True)
def unload(self):
if self.prevTool and self.prevTool != self.tool:
self.canvas.setMapTool(self.prevTool)
else:
self.canvas.setMapTool(QgsMapToolPan(self.iface.mapCanvas()))
self.iface.removeToolBarIcon(self.widget_action)
del self.widget_action
def initGui(self):
layout = QVBoxLayout()
self.tab = QTabWidget()
self.table = QTableView()
self.setLayout(layout)
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
settings = QSettings()
self.canvas.enableAntiAliasing(
settings.value("/qgis/enable_anti_aliasing", False, type=bool))
self.canvas.useImageToRender(
settings.value("/qgis/use_qimage_to_render", False, type=bool))
self.canvas.mapSettings().setDestinationCrs(self.crs)
action = settings.value("/qgis/wheel_action", 0, type=float)
zoomFactor = settings.value("/qgis/zoom_factor", 2, type=float)
self.canvas.setWheelAction(QgsMapCanvas.WheelAction(action),
zoomFactor)
self.panTool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.panTool)
execute(self.createLayers)
model = GeomDiffTableModel(self.data)
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.table.resizeRowsToContents()
self.tab.addTab(self.canvas, "Map view")
self.tab.addTab(self.table, "Table view")
layout.addWidget(self.tab)
self.resize(600, 500)
self.setWindowTitle("Geometry comparison")
def reject(self):
scene = define._canvas.scene()
scene.removeItem(self.CaptureTHRCoordTool.rubberBand)
scene.removeItem(self.CaptureENDCoordTool.rubberBand)
# self.CaptureTHRCoordTool.rubberBand.hide()
# self.CaptureENDCoordTool.rubberBand.hide()
define._canvas.setMapTool(QgsMapToolPan(define._canvas))
self.reject()
def __init__(self, parent=None, iface=None):
"""Constructor for import dialog.
:param parent: Optional widget to use as parent
:type parent: QWidget
:param iface: An instance of QGisInterface
:type iface: QGisInterface
"""
QDialog.__init__(self, parent)
self.parent = parent
self.setupUi(self)
self.setWindowTitle(self.tr('InaSAFE OpenStreetMap Downloader'))
self.iface = iface
self.buildings_url = 'http://osm.linfiniti.com/buildings-shp'
self.building_points_url = \
'http://osm.linfiniti.com/building-points-shp'
self.roads_url = 'http://osm.linfiniti.com/roads-shp'
self.help_context = 'openstreetmap_downloader'
# creating progress dialog for download
self.progress_dialog = QProgressDialog(self)
self.progress_dialog.setAutoClose(False)
title = self.tr('InaSAFE OpenStreetMap Downloader')
self.progress_dialog.setWindowTitle(title)
# Set up context help
help_button = self.button_box.button(QtGui.QDialogButtonBox.Help)
help_button.clicked.connect(self.show_help)
self.show_info()
# set up the validator for the file name prefix
expression = QRegExp('^[A-Za-z0-9-_]*$')
validator = QRegExpValidator(expression, self.filename_prefix)
self.filename_prefix.setValidator(validator)
# Set Proxy in webpage
proxy = get_proxy()
self.network_manager = QNetworkAccessManager(self)
if proxy is not None:
self.network_manager.setProxy(proxy)
self.restore_state()
# Setup the rectangle map tool
self.canvas = iface.mapCanvas()
self.rectangle_map_tool = \
RectangleMapTool(self.canvas)
self.rectangle_map_tool.rectangle_created.connect(
self.update_extent_from_rectangle)
self.button_extent_rectangle.clicked.connect(
self.drag_rectangle_on_map_canvas)
# Setup pan tool
self.pan_tool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.pan_tool)
self.update_extent_from_map_canvas()
def close(self):
scene = define._canvas.scene()
scene.removeItem(self.CaptureTHRCoordTool.rubberBandClick)
scene.removeItem(self.CaptureENDCoordTool.rubberBandClick)
scene.removeItem(self.bearingTool.rubberBand)
scene.removeItem(self.distanceMeasureTool.rubberBand)
# self.CaptureTHRCoordTool.rubberBand.hide()
# self.CaptureENDCoordTool.rubberBand.hide()
define._canvas.setMapTool(QgsMapToolPan(define._canvas))
def savePatrolAreaLayer(self):
name = "patrol_area"
CanvasLayerSaver(
name,
[self.patrolArea],
crs=self.canvas.mapSettings().destinationCrs(),
color=PATROL_AREA_COLOR,
style=PATROL_AREA_STYLE,
)
iface.mapCanvas().setMapTool(QgsMapToolPan(iface.mapCanvas()))
def manualEvent(self, index):
QgisHelper.ClearRubberBandInCanvas(define._canvas)
self.manualPolygon = None
if index != 0:
self.toolSelectByPolygon = RubberBandPolygon(define._canvas)
define._canvas.setMapTool(self.toolSelectByPolygon)
self.connect(self.toolSelectByPolygon, SIGNAL("outputResult"), self.outputResultMethod)
else:
self.mapToolPan = QgsMapToolPan(define._canvas)
define._canvas.setMapTool(self.mapToolPan )
def saveCanvasAreasToAvoidLayer(self):
name = "avoid_areas"
CanvasLayerSaver(
name,
self.areasToAvoid,
crs=self.canvas.mapSettings().destinationCrs(),
color=AVOID_AREA_COLOR,
style=AVOID_AREA_STYLE,
)
iface.mapCanvas().setMapTool(QgsMapToolPan(iface.mapCanvas()))
def __init__(self, conflicts):
super(ConflictDialog,
self).__init__(None,
Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
self.solved = False
self.resolvedConflicts = {}
self.conflicts = conflicts
self.setupUi(self)
self.setWindowFlags(self.windowFlags() | Qt.WindowSystemMenuHint
| Qt.WindowMinMaxButtonsHint)
self.zoomButton.clicked.connect(self.zoomToFullExtent)
self.solveButton.clicked.connect(self.solve)
self.conflictsTree.itemClicked.connect(self.treeItemClicked)
self.attributesTable.cellClicked.connect(self.cellClicked)
self.solveAllLocalButton.clicked.connect(self.solveAllLocal)
self.solveAllRemoteButton.clicked.connect(self.solveAllRemote)
self.solveLocalButton.clicked.connect(self.solveLocal)
self.solveRemoteButton.clicked.connect(self.solveRemote)
self.showRemoteCheck.stateChanged.connect(self.showGeoms)
self.showLocalCheck.stateChanged.connect(self.showGeoms)
self.lastSelectedItem = None
self.currentPath = None
self.currentConflict = None
self.theirsLayer = None
self.oursLayer = None
settings = QSettings()
horizontalLayout = QHBoxLayout()
horizontalLayout.setSpacing(0)
horizontalLayout.setMargin(0)
self.mapCanvas = QgsMapCanvas()
self.mapCanvas.setCanvasColor(Qt.white)
self.mapCanvas.enableAntiAliasing(
settings.value("/qgis/enable_anti_aliasing", False, type=bool))
self.mapCanvas.useImageToRender(
settings.value("/qgis/use_qimage_to_render", False, type=bool))
self.mapCanvas.mapRenderer().setProjectionsEnabled(True)
action = settings.value("/qgis/wheel_action", 0, type=float)
zoomFactor = settings.value("/qgis/zoom_factor", 2, type=float)
self.mapCanvas.setWheelAction(QgsMapCanvas.WheelAction(action),
zoomFactor)
horizontalLayout.addWidget(self.mapCanvas)
self.canvasWidget.setLayout(horizontalLayout)
self.panTool = QgsMapToolPan(self.mapCanvas)
self.mapCanvas.setMapTool(self.panTool)
self.solveButton.setEnabled(False)
self.solveLocalButton.setEnabled(False)
self.solveRemoteButton.setEnabled(False)
self.fillConflictsTree()
def __init__(self):
QMainWindow.__init__(self)
# creating map canvas, which draws the maplayers
# setting up features like canvas color
self.canvas = QgsMapCanvas()
self.canvas.setMinimumSize(550, 700)
self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
# Qmainwindow requires a central widget. Canvas is placed
self.setCentralWidget(self.canvas)
# creating each desired action
self.actionGet = QAction("Return polygon and close", self)
self.actionPan = QAction("Pan tool", self)
self.actionDraw = QAction("Polygon tool", self)
self.actionConnect = QAction("Connect polygon", self)
self.actionClear = QAction("Clear", self)
self.actionCancel = QAction("Cancel and close", self)
# these two function as on/off. the rest are clickable
self.actionPan.setCheckable(True)
self.actionDraw.setCheckable(True)
# when actions are clicked, do corresponding function
self.actionPan.triggered.connect(self.pan)
self.actionDraw.triggered.connect(self.draw)
self.actionClear.triggered.connect(self.clear)
self.actionGet.triggered.connect(self.finishedSelection)
self.actionConnect.triggered.connect(self.connect)
self.actionCancel.triggered.connect(self.cancel)
# toolbar at the top of the screen: houses actions as buttons
# change order here to change their placement on toolbar
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
self.toolbar.setMovable(False)
self.toolbar.addAction(self.actionGet)
self.toolbar.addAction(self.actionPan)
self.toolbar.addAction(self.actionDraw)
self.toolbar.addAction(self.actionConnect)
self.toolbar.addAction(self.actionClear)
self.toolbar.addAction(self.actionCancel)
# link actions to premade map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(self.actionPan)
self.toolDraw = PolygonMapTool(self.canvas)
self.toolDraw.setAction(self.actionDraw)
# set draw tool by default
self.draw()
def set_point_coords(self, point, button):
log("Set point coords")
#TODO: Show a messagebar while tool is active, and then remove the bar when a point is chosen.
self.point = point
# Disable the choose point tool
self.canvas.setMapTool(QgsMapToolPan(self.canvas))
self.show()
self.point = self.canvas.getCoordinateTransform().toMapCoordinates(self.canvas.mouseLastXY())
log("Chose point: {}, {}.".format(self.point.x(), self.point.y()))
self.point_x.setText("{:.8f}".format(self.point.x()))
self.point_y.setText("{:.8f}".format(self.point.y()))
def __init__(self, inp_sparql, triplestoreconf, endpointIndex):
super(QDialog, self).__init__()
self.setupUi(self)
self.inp_sparql = inp_sparql
self.triplestoreconf = triplestoreconf
self.endpointIndex = endpointIndex
self.vl = QgsVectorLayer("Point", "temporary_points", "memory")
self.map_canvas = QgsMapCanvas(self)
self.layerExtentOrBBOX = False
self.map_canvas.setMinimumSize(500, 475)
self.map_canvas.move(0, 30)
self.nominatimmap = {}
actionPan = QAction("Pan", self)
actionPan.setCheckable(True)
actionPan.triggered.connect(self.pan)
self.toolPan = QgsMapToolPan(self.map_canvas)
self.toolPan.setAction(actionPan)
uri = "url=http://a.tile.openstreetmap.org/{z}/{x}/{y}.png&zmin=0&type=xyz"
self.mts_layer = QgsRasterLayer(uri, 'OSM', 'wms')
if not self.mts_layer.isValid():
print("Layer failed to load!")
self.rect_tool = RectangleMapTool(self.map_canvas)
self.circ_tool = CircleMapTool(self.map_canvas, 1)
self.poly_tool = PolygonMapTool(self.map_canvas)
self.map_canvas.setMapTool(self.rect_tool)
self.map_canvas.setExtent(self.mts_layer.extent())
self.map_canvas.setLayers([self.vl, self.mts_layer])
self.map_canvas.setCurrentLayer(self.mts_layer)
self.pan()
self.selectCircle.hide()
self.geocodeSearch = NominatimText(self, self.nominatimmap,
self.map_canvas)
self.move(120, 0)
self.crsdialog = QgsProjectionSelectionWidget(self)
self.crsdialog.move(160, 540)
self.crsdialog.resize(331, 30)
self.crsdialog.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.crsdialog.show()
self.nominatimurl = 'https://nominatim.openstreetmap.org/search?format=json&q={address}'
self.panButton.clicked.connect(self.pan)
self.selectCircle.clicked.connect(self.selectcircle)
self.selectPolygon.clicked.connect(self.selectpolygon)
self.selectButton.clicked.connect(self.selectarea)
self.zoomIn.clicked.connect(self.map_canvas.zoomIn)
self.zoomOut.clicked.connect(self.map_canvas.zoomOut)
self.b2.clicked.connect(self.setBBOXExtentQuery)
self.searchButton.hide()
self.searchPlace.hide()
self.geocodeSearch.hide()
layers = QgsProject.instance().layerTreeRoot().children()
for layer in layers:
self.chooseBBOXLayer.addItem(layer.name())
self.searchButton.clicked.connect(self.geocode)
self.b1.clicked.connect(self.setBBOXInQuery)
def initGui(self):
layout = QVBoxLayout()
splitter = QSplitter()
splitter.setOrientation(Qt.Vertical)
self.history = HistoryTree(self.dialog)
self.history.updateContent(self.server, self.user, self.repo, self.graph, self.layer)
self.historyWithFilter = HistoryTreeWrapper(self.history)
if self.simplifyLog:
self.historyWithFilter.simplify(True)
splitter.addWidget(self.historyWithFilter)
self.tabWidget = QTabWidget()
self.tabCanvas = QWidget()
tabLayout = QVBoxLayout()
tabLayout.setMargin(0)
self.canvas = QgsMapCanvas(self.tabCanvas)
self.canvas.setCanvasColor(Qt.white)
self.panTool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.panTool)
tabLayout.addWidget(self.canvas)
self.labelNoChanges = QLabel("This commit doesn't change any geometry")
self.labelNoChanges.setAlignment(Qt.AlignCenter)
self.labelNoChanges.setVisible(False)
tabLayout.addWidget(self.labelNoChanges)
self.tabCanvas.setLayout(tabLayout)
self.summaryTextBrowser = QTextBrowser()
self.summaryTextBrowser.setOpenLinks(False)
self.summaryTextBrowser.anchorClicked.connect(self.summaryTextBrowserAnchorClicked)
self.tabWidget.addTab(self.summaryTextBrowser, "Commit Summary")
self.tabWidget.addTab(self.tabCanvas, "Map")
tabLayout = QVBoxLayout()
tabLayout.setMargin(0)
self.tabDiffViewer = QWidget()
self.diffViewer = DiffViewerWidget({})
tabLayout.addWidget(self.diffViewer)
self.tabDiffViewer.setLayout(tabLayout)
self.tabWidget.addTab(self.tabDiffViewer, "Attributes")
splitter.addWidget(self.tabWidget)
self.label = QTextBrowser()
self.label.setVisible(False)
splitter.addWidget(self.label)
self.tabWidget.setCurrentWidget(self.tabDiffViewer)
layout.addWidget(splitter)
self.setLayout(layout)
exportDiffButton = QPushButton("Export this commit's DIFF for all layers")
exportDiffButton.clicked.connect(self.exportDiffAllLayers)
layout.addWidget(exportDiffButton)
self.label.setMinimumHeight(self.tabWidget.height())
self.setWindowTitle("Repository history")
def setupUi(self):
self.setObjectName("mirrormap")
gridLayout = QGridLayout(self)
gridLayout.setContentsMargins(0, 0, gridLayout.verticalSpacing(),
gridLayout.verticalSpacing())
self.canvas = QgsMapCanvas(self)
self.canvas.setCanvasColor(QColor(255, 255, 255))
settings = QSettings()
gridLayout.addWidget(self.canvas, 0, 0, 1, 5)
self.addLayerBtn = QToolButton(self)
# self.addLayerBtn.setToolButtonStyle( Qt.ToolButtonTextBesideIcon )
# self.addLayerBtn.setText("Add current layer")
self.addLayerBtn.setIcon(GuiUtils.get_icon("add.png"))
self.addLayerBtn.clicked.connect(self.tool_add_layer)
gridLayout.addWidget(self.addLayerBtn, 1, 0, 1, 1)
self.delLayerBtn = QToolButton(self)
# self.delLayerBtn.setToolButtonStyle( Qt.ToolButtonTextBesideIcon )
# self.delLayerBtn.setText("Remove current layer")
self.delLayerBtn.setIcon(GuiUtils.get_icon("remove.png"))
self.delLayerBtn.clicked.connect(self.tool_remove_layer)
gridLayout.addWidget(self.delLayerBtn, 1, 1, 1, 1)
self.renderCheck = QCheckBox("Render", self)
self.renderCheck.toggled.connect(self.toggleRender)
self.renderCheck.setChecked(True)
gridLayout.addWidget(self.renderCheck, 1, 2, 1, 1)
self.scaleFactorLabel = QLabel(self)
self.scaleFactorLabel.setText("Scale factor:")
self.scaleFactorLabel.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
gridLayout.addWidget(self.scaleFactorLabel, 1, 3, 1, 1)
self.scaleFactor = QDoubleSpinBox(self)
self.scaleFactor.setMinimum(0.0)
self.scaleFactor.setMaximum(1000.0)
self.scaleFactor.setDecimals(3)
self.scaleFactor.setValue(1)
self.scaleFactor.setObjectName("scaleFactor")
self.scaleFactor.setSingleStep(.05)
gridLayout.addWidget(self.scaleFactor, 1, 4, 1, 1)
self.scaleFactor.valueChanged.connect(self.onExtentsChanged)
# Add a default pan tool
self.toolPan = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.toolPan)
self.scaleFactor.valueChanged.connect(self.onExtentsChanged)
self.set_iface(self.iface)
def setPolygonDrawingMapTool(self, checked):
if checked:
self.prevMapTool = iface.mapCanvas().mapTool()
self.mapToolDrawPolygon = DrawPolygonMapTool(iface.mapCanvas())
self.mapToolDrawPolygon.polygonSelected.connect(
self.setAreasToAvoidFromPolygon)
iface.mapCanvas().setMapTool(self.mapToolDrawPolygon)
else:
try:
iface.mapCanvas().setMapTool(self.prevMapTool)
except Exception as e:
logging.error(e)
iface.mapCanvas().setMapTool(QgsMapToolPan(iface.mapCanvas()))
def setupUi(self):
gridLayout = QGridLayout(self)
gridLayout.setContentsMargins(0, 0, 0, 0)
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(QColor(255, 255, 255))
self.canvas.setStyleSheet("border: 0px;")
settings = QSettings()
self.canvas.enableAntiAliasing(
settings.value("/qgis/enable_anti_aliasing", False, type=bool))
self.setMinimumSize(15, 15)
# action pan and zoom
self.default_point_tool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.default_point_tool, clean=True)
gridLayout.addWidget(self.canvas)
def set_point_coords(self, point, button):
log("Set point coords")
#TODO: Show a messagebar while tool is active, and then remove the bar when a point is chosen.
self.point = point
# Disable the choose point tool
self.canvas.setMapTool(QgsMapToolPan(self.canvas))
# Don't reset_tab_on_show as it would lead to return to first tab after
# using the point chooser
self.reset_tab_on_showEvent = False
self.show()
self.reset_tab_on_showEvent = True
self.point = self.canvas.getCoordinateTransform().toMapCoordinates(self.canvas.mouseLastXY())
log("Chose point: {}, {}.".format(self.point.x(), self.point.y()))
self.point_widget.point_x.setText("{:.8f}".format(self.point.x()))
self.point_widget.point_y.setText("{:.8f}".format(self.point.y()))
def activate_mapTool(self):
if self.picking_mode:
self.iface.mapCanvas().setMapTool(
QgsMapToolPan(self.iface.mapCanvas()))
self.pick_point_button.setText('Pick a Point')
self.picking_mode = False
else:
if (self.input_layers['soil_layer'] is None
or self.input_layers['lulc_layer'] is None
or self.input_layers['slope_layer'] is None):
return
self.pointTool = PointTool(self.iface.mapCanvas(), self)
self.iface.mapCanvas().setMapTool(self.pointTool)
self.pick_point_button.setText('Disable picking')
self.picking_mode = True
def _radioButtonsPatrolChanged(self):
self.populatePatrolLayerSelector()
self.comboPatrolAreaLayers.setEnabled(
self.radioPatrolAreaLayer.isChecked())
self.btnPatrolAreaCanvas.setEnabled(
self.radioPatrolAreaPolygon.isChecked())
self.btnPatrolAreaClear.setEnabled(
self.radioPatrolAreaPolygon.isChecked())
self.btnPatrolAreaSave.setEnabled(
self.radioPatrolAreaPolygon.isChecked())
if self.radioPatrolAreaPolygon.isChecked():
if self.patrolArea is not None:
self.patrolFootprint.setToGeometry(self.patrolArea)
else:
iface.mapCanvas().setMapTool(QgsMapToolPan(iface.mapCanvas()))
self.patrolFootprint.reset(QgsWkbTypes.PolygonGeometry)
def onRightClick(self, position): # used to quit the current action
# print "right click", position
mapPos = self.canvas.getCoordinateTransform().toMapCoordinates(
position["x"], position["y"])
newPoints = [[mapPos.x(), mapPos.y()]]
# if newPoints == self.lastClicked: return # sometimes a strange "double click" is given
# self.rubberband.reset(self.polygon)
# self.rubberband.reset(QGis.Point)
# print "setting rubberband", mapPos.x(),mapPos.y()
self.rubberband.addPoint(QgsPoint(mapPos.x(), mapPos.y()))
self.toolPan = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.toolPan)
# create new vlayer ???
self.angles(mapPos.x(), mapPos.y())
self.tool = None
def _radioButtonsChanged(self):
self.populateLayerSelector()
self.comboAreasToAvoidLayers.setEnabled(self.radioAreasToAvoidLayer.isChecked())
self.btnAreasToAvoidFromCanvas.setEnabled(
self.radioAreasToAvoidPolygon.isChecked()
)
self.btnAreasToAvoidClear.setEnabled(self.radioAreasToAvoidPolygon.isChecked())
self.btnAreasToAvoidSave.setEnabled(self.radioAreasToAvoidPolygon.isChecked())
if self.radioAreasToAvoidPolygon.isChecked():
if self.areasToAvoid:
for geometry in self.areasToAvoid:
footprint = self.createFootprintArea()
footprint.setToGeometry(geometry)
self.areasToAvoidFootprint.append(footprint)
else:
iface.mapCanvas().setMapTool(QgsMapToolPan(iface.mapCanvas()))
for footprint in self.areasToAvoidFootprint:
footprint.reset(QgsWkbTypes.PolygonGeometry)
def __init__(self, layerSet):
QMainWindow.__init__(self)
self.showFullScreen()
self._canvas = GMapCanvas()
self._canvas.setCanvasColor(Qt.white)
self.setCentralWidget(self._canvas)
self._layerSet = layerSet
self._canvas.setLayerSet(layerSet)
self._extent = self._layerSet.rawLayers[len(self._layerSet.rawLayers) -
1].extent()
self._canvas.setExtent(self._extent)
self._toolPan = QgsMapToolPan(self._canvas)
self.pan()
self._layerDock = GAppLayerDocker(self.centralWidget(), layerSet,
self._canvas)
self.addDockWidget(Qt.LeftDockWidgetArea, self._layerDock)
def __init__(self, parent=None, layer_to_edit=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.layer_to_edit = layer_to_edit
self.aoi_drawn = []
self.highlight_tile = None
self.setup_gui()
# init render widget
self.render_widget.canvas.setDestinationCrs(
self.layer_to_edit.qgs_layer.crs())
self.render_widget.canvas.setLayers([self.layer_to_edit.qgs_layer])
self.render_widget.canvas.setExtent(self.layer_to_edit.extent())
self.render_widget.refresh()
self.map_tool_pan = QgsMapToolPan(self.render_widget.canvas)
self.render_widget.canvas.setMapTool(self.map_tool_pan, clean=True)
# flags
self.setWindowFlags(self.windowFlags() | Qt.WindowMinimizeButtonHint)
def __init__(self, server, user, repo, graph, layername):
super(LayerExplorer, self).__init__(None)
self.user = user
self.server = server
self.repo = repo
self.layername = layername
self.layer = None
self.extent = None
self.renderer = None
self.graph = graph
self.setupUi(self)
self.history = HistoryTree(self)
self.history.updateContent(self.server, self.user, self.repo,
self.graph, self.layername)
historyTreeWrapper = HistoryTreeWrapper(self.history)
layout = QVBoxLayout()
layout.setMargin(0)
layout.addWidget(historyTreeWrapper)
self.historyWidget.setLayout(layout)
layout = QVBoxLayout()
layout.setMargin(0)
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
self.panTool = QgsMapToolPan(self.canvas)
self.canvas.setMapTool(self.panTool)
layout.addWidget(self.canvas)
self.mapWidget.setLayout(layout)
self.canvas.extentsChanged.connect(self.refreshLayer)
self.history.currentItemChanged.connect(self.itemChanged)
self.resize(900, 500)
self.setWindowTitle("Layer Explorer [{}]".format(layername))
self.setWindowFlags(Qt.Window)
setCurrentWindow(self)
self.bar = MessageBar(self.canvas)
