def designer_opened(self, designer: QgsLayoutDesignerInterface): """ Called whenever a new layout designer window is opened """ toggle_unplaced_labels_action = QAction( self.tr('Show Unplaced Labels on Maps'), parent=designer) toggle_unplaced_labels_action.setCheckable(True) toggle_unplaced_labels_action.setIcon( GuiUtils.get_icon('show_unplaced_labels.svg')) # determine initial check state layout = designer.layout() maps = [ item for item in layout.items() if isinstance(item, QgsLayoutItemMap) ] initial_checked = bool(maps) and all( m.mapFlags() & QgsLayoutItemMap.ShowUnplacedLabels for m in maps) toggle_unplaced_labels_action.setChecked(initial_checked) toggle_unplaced_labels_action.toggled.connect( partial(self.toggle_unplaced_labels, designer)) toggle_unplaced_labels_action.setShortcut(QKeySequence('Ctrl+Shift+U')) tb = designer.actionsToolbar() tb.addSeparator() tb.addAction(toggle_unplaced_labels_action) designer.viewMenu().addSeparator() designer.viewMenu().addAction(toggle_unplaced_labels_action)
def add_action( self, icon_name, callback=None, text="", enabled=True, add_to_menu=False, add_to_toolbar=None, status_tip=None, whats_this=None, checkable=False, checked=False, always_on=True, ): icon = QIcon(icon_path(icon_name)) action = QAction(icon, text, self.iface.mainWindow()) action.triggered.connect(callback) action.setCheckable(checkable) action.setChecked(checked) action.setEnabled(enabled) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar is not None: add_to_toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu(self.menu, action) self.actions.append(action) if always_on: self.actions_always_on.append(text) return action
class NetworkActivityDock(QgsDockWidget): """ The Dock holding the actual treeview. Also having some buttons to clear/pause and filter the requests. """ def __init__(self, logger): super().__init__() self.setWindowTitle('Network Activity') self.view = ActivityView(logger) font = QFont() font.setFamily('Courier') font.setPointSize(font.pointSize() - 1) self.view.setFont(font) self.logger = logger self.l = QVBoxLayout() self.l.setContentsMargins(0, 0, 0, 0) self.clear_action = QAction('Clear') self.pause_action = QAction('Pause') self.pause_action.setCheckable(True) self.toolbar = QToolBar() self.toolbar.setIconSize(iface.iconSize(True)) self.toolbar.addAction(self.clear_action) self.toolbar.addAction(self.pause_action) self.clear_action.triggered.connect(self.view.clear) self.pause_action.toggled.connect(self.view.pause) self.show_success_action = QAction('Show successful requests') self.show_success_action.setCheckable(True) self.show_success_action.setChecked(True) self.show_success_action.toggled.connect(self.view.show_successful) self.show_timeouts_action = QAction('Show timeouts') self.show_timeouts_action.setCheckable(True) self.show_timeouts_action.setChecked(True) self.show_timeouts_action.toggled.connect(self.view.show_timeouts) self.toolbar.addSeparator() self.toolbar.addAction(self.show_success_action) self.toolbar.addAction(self.show_timeouts_action) self.filter_line_edit = QgsFilterLineEdit() self.filter_line_edit.setShowSearchIcon(True) self.filter_line_edit.setPlaceholderText('Filter requests') self.filter_line_edit.textChanged.connect(self.view.set_filter_string) self.l.addWidget(self.toolbar) self.l.addWidget(self.filter_line_edit) self.l.addWidget(self.view) self.w = QWidget() self.w.setLayout(self.l) self.setWidget(self.w)
class GimpSelectionFeaturePlugin(QObject): def __init__(self, iface): super().__init__() self.iface = iface self.name = u"&Gimp Selection Feature" self.dock = None self.translate = Translate('gimpselectionfeature') def initGui(self): name = "Gimp Selection Feature" about = QCoreApplication.translate( 'GimpSelectionFeature', 'Adding selected area in GIMP how a feature') icon = QIcon( os.path.join(os.path.dirname(__file__), 'gimpselectionfeature.svg')) self.action = QAction(icon, name, self.iface.mainWindow()) self.action.setObjectName(name.replace(' ', '')) self.action.setWhatsThis(about) self.action.setStatusTip(about) self.action.setCheckable(True) self.action.triggered.connect(self.run) self.iface.addRasterToolBarIcon(self.action) self.iface.addPluginToRasterMenu(self.name, self.action) self.dock = DockWidgetGimpSelectionFeature(self.iface) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock) self.dock.visibilityChanged.connect(self.dockVisibilityChanged) def unload(self): self.iface.removeRasterToolBarIcon(self.action) self.iface.removePluginRasterMenu(self.name, self.action) self.dock.close() self.dock.clean() self.dock = None del self.action @pyqtSlot() def run(self): if self.dock.isVisible(): self.dock.hide() else: self.dock.show() @pyqtSlot(bool) def dockVisibilityChanged(self, visible): self.action.setChecked(visible)
def onContextMenu(self, pos): # row = self.selectionModel().selectedRows()[0] menu = QMenu(self) copyAction = QAction("Copy value", self) copyAction.triggered.connect(self.onCopyItemValue) copyXPathAction = QAction("Copy XPath", self) copyXPathAction.triggered.connect(self.onCopyXPath) menu.addAction(copyAction) menu.addAction(copyXPathAction) item = self.currentItem() if (item.text(0) == "@xlink:href" and item.data(1, Qt.UserRole) and item.data(1, Qt.UserRole).startswith("http")): resolveMenu = QMenu("Resolve external", menu) swap_xy_menu_action = QAction("Swap X/Y", self) swap_xy_menu_action.setCheckable(True) swap_xy_menu_action.setChecked(self.swap_xy) swap_xy_menu_action.triggered.connect(self.onSwapXY) resolveMenu.addAction(swap_xy_menu_action) resolveEmbeddedAction = QAction("Embedded", self) resolveEmbeddedAction.triggered.connect(self.onResolveEmbedded) resolveMenu.addAction(resolveEmbeddedAction) resolveNewLayerAction = QAction("As a new layer", self) resolveNewLayerAction.triggered.connect(self.onResolveNewLayer) resolveMenu.addAction(resolveNewLayerAction) addToMenu = QMenu("Add to layer", menu) addToEmpty = True for id, l in QgsProject.instance().mapLayers().items(): if is_layer_gml_xml(l): action = QAction(l.name(), addToMenu) action.triggered.connect(lambda checked, layer=l: self. onResolveAddToLayer(layer)) addToMenu.addAction(action) addToEmpty = False if not addToEmpty: resolveMenu.addMenu(addToMenu) menu.addMenu(resolveMenu) menu.popup(self.mapToGlobal(pos))
class FeatureSelectMultiLayersSample: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface self.canvas = self.iface.mapCanvas() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # プラグインの登録場所 self.menu_pos = 'サンプル フューチャー選択' # キャンバス上のマウスイベント設定 self.mouseEventSample = RectangleMapTool(self.iface.mapCanvas()) def initGui(self): icon = QIcon(self.plugin_dir + '/icon.png') self.action = QAction(icon, '複数レイヤ一括選択', self.iface.mainWindow()) self.action.triggered.connect( self.execSample) # アイコンを押下した時に実行されるメソッドを登録 self.action.setCheckable(True) # Trueだとアイコンを押下したら次に押下するまで凹んだままになる。 #self.iface.addToolBarIcon(self.action) # ツールバーにアイコンを表示させたいなら#外して self.iface.addPluginToMenu(self.menu_pos, self.action) def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" self.iface.removePluginMenu(self.menu_pos, self.action) self.iface.removeToolBarIcon(self.action) def unsetTool(self, tool): if not isinstance(tool, FeatureSelectMultiLayersSample): self.canvas.mapToolSet.disconnect(self.unsetTool) self.iface.mapCanvas().unsetMapTool(self.mouseEventSample) self.action.setChecked(False) def execSample(self): if self.action.isChecked(): self.previousMapTool = self.iface.mapCanvas().mapTool() self.iface.mapCanvas().setMapTool(self.mouseEventSample) self.canvas.mapToolSet.connect(self.unsetTool) else: self.canvas.mapToolSet.disconnect(self.unsetTool) self.iface.mapCanvas().unsetMapTool(self.mouseEventSample) self.iface.mapCanvas().setMapTool(self.previousMapTool)
class ProcessingPlugin: def __init__(self, iface): self.iface = iface self.options_factory = ProcessingOptionsFactory() self.options_factory.setTitle(self.tr('Processing')) iface.registerOptionsWidgetFactory(self.options_factory) self.drop_handler = ProcessingDropHandler() iface.registerCustomDropHandler(self.drop_handler) self.item_provider = ProcessingDataItemProvider() QgsApplication.dataItemProviderRegistry().addProvider( self.item_provider) self.locator_filter = AlgorithmLocatorFilter() iface.registerLocatorFilter(self.locator_filter) Processing.initialize() def initGui(self): self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged) self.resultsDock = ResultsDock() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock) self.resultsDock.hide() self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow()) self.toolboxAction.setCheckable(True) self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QgsApplication.getThemeIcon("/processingAlgorithm.svg")) self.iface.registerMainWindowAction( self.toolboxAction, QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText)) self.toolboxAction.toggled.connect(self.openToolbox) self.iface.attributesToolBar().insertAction( self.iface.actionOpenStatisticalSummary(), self.toolboxAction) self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QgsApplication.getThemeIcon("/processingModel.svg"), QCoreApplication.translate('ProcessingPlugin', 'Graphical &Modeler…'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction( self.modelerAction, QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText)) self.menu.addAction(self.modelerAction) self.historyAction = QAction( QIcon(os.path.join(pluginPath, 'images', 'history.svg')), QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction( self.historyAction, QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText)) self.menu.addAction(self.historyAction) self.toolbox.processingToolbar.addAction(self.historyAction) self.resultsAction = QAction( QgsApplication.getThemeIcon("/processingResult.svg"), self.tr('&Results Viewer'), self.iface.mainWindow()) self.resultsAction.setCheckable(True) self.iface.registerMainWindowAction( self.resultsAction, QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText)) self.menu.addAction(self.resultsAction) self.toolbox.processingToolbar.addAction(self.resultsAction) self.resultsDock.visibilityChanged.connect( self.resultsAction.setChecked) self.resultsAction.toggled.connect(self.resultsDock.setUserVisible) self.optionsAction = QAction( QgsApplication.getThemeIcon("/mActionOptions.svg"), self.tr('Options'), self.iface.mainWindow()) self.optionsAction.setObjectName('optionsAction') self.optionsAction.triggered.connect(self.openProcessingOptions) self.toolbox.processingToolbar.addAction(self.optionsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(), self.menu) self.menu.addSeparator() initializeMenus() createMenus() def openProcessingOptions(self): self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions') def unload(self): self.toolbox.setVisible(False) self.iface.removeDockWidget(self.toolbox) self.iface.attributesToolBar().removeAction(self.toolboxAction) self.resultsDock.setVisible(False) self.iface.removeDockWidget(self.resultsDock) self.toolbox.deleteLater() self.menu.deleteLater() # delete temporary output files folder = QgsProcessingUtils.tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) # also delete temporary help files folder = tempHelpFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.toolboxAction) self.iface.unregisterMainWindowAction(self.modelerAction) self.iface.unregisterMainWindowAction(self.historyAction) self.iface.unregisterMainWindowAction(self.resultsAction) self.iface.unregisterOptionsWidgetFactory(self.options_factory) self.iface.deregisterLocatorFilter(self.locator_filter) self.iface.unregisterCustomDropHandler(self.drop_handler) QgsApplication.dataItemProviderRegistry().removeProvider( self.item_provider) removeMenus() Processing.deinitialize() def openToolbox(self, show): self.toolbox.setUserVisible(show) def toolboxVisibilityChanged(self, visible): self.toolboxAction.setChecked(visible) def openModeler(self): dlg = ModelerDialog() dlg.update_model.connect(self.updateModel) dlg.show() def updateModel(self): model_provider = QgsApplication.processingRegistry().providerById( 'model') model_provider.refreshAlgorithms() def openResults(self): if self.resultsDock.isVisible(): self.resultsDock.hide() else: self.resultsDock.show() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def tr(self, message): return QCoreApplication.translate('ProcessingPlugin', message)
class GeoGigPlugin(object): def __init__(self, iface): self.iface = iface readSettings() self.initConfigParams() sys.excepthook = self.excepthook self.askToSaveMemoryLayers = QgsSettings().value( "askToSaveMemoryLayers", True, section=QgsSettings.App) QgsSettings().setValue("askToSaveMemoryLayers", False, section=QgsSettings.App) def initConfigParams(self): folder = pluginSetting("gpkgfolder") if folder.strip() == "": setPluginSetting( "gpkgfolder", os.path.join(os.path.expanduser('~'), 'geogig', 'repos')) folder = pluginSetting("difffolder") if folder.strip() == "": setPluginSetting( "difffolder", os.path.join(os.path.expanduser('~'), 'geogig', 'diff')) def unload(self): navigatorInstance.setVisible(False) self.iface.removePluginMenu("&GeoGig", self.explorerAction) removeHelpMenu("GeoGig") removeAboutMenu("GeoGig") removeSettingsMenu("GeoGig") #removeTempFolder() clearDiffFiles() self.iface.mapCanvas().extentsChanged.disconnect(refreshGeogigLayers) QgsProject.instance().layersWillBeRemoved.disconnect(layersRemoved) QgsProject.instance().legendLayersAdded.disconnect(onLayersLoaded) sys.excepthook = utils.qgis_excepthook QgsSettings().setValue("askToSaveMemoryLayers", self.askToSaveMemoryLayers, section=QgsSettings.App) def initGui(self): icon = QIcon(os.path.dirname(__file__) + "/ui/resources/geogig.png") self.explorerAction = navigatorInstance.toggleViewAction() self.explorerAction.setIcon(icon) self.explorerAction.setText("GeoGig Navigator") self.iface.addPluginToMenu("&GeoGig", self.explorerAction) icon = QIcon(os.path.dirname(__file__) + "/ui/resources/identify.png") self.toolAction = QAction(icon, "GeoGig Feature Info Tool", self.iface.mainWindow()) self.toolAction.setCheckable(True) self.toolAction.triggered.connect(self.setTool) self.iface.addPluginToMenu("&GeoGig", self.toolAction) addSettingsMenu("GeoGig") addHelpMenu("GeoGig") addAboutMenu("GeoGig") self.mapTool = MapToolGeoGigInfo(self.iface.mapCanvas()) self.iface.addDockWidget(Qt.RightDockWidgetArea, navigatorInstance) self.iface.mapCanvas().extentsChanged.connect(refreshGeogigLayers) QgsProject.instance().layersWillBeRemoved.connect(layersRemoved) QgsProject.instance().legendLayersAdded.connect(onLayersLoaded) def setTool(self): self.toolAction.setChecked(True) self.iface.mapCanvas().setMapTool(self.mapTool) def excepthook(self, extype, value, tb): currentWindow().messageBar().clearWidgets() QApplication.restoreOverrideCursor() if extype == GeogigAuthException: currentWindow().messageBar().pushMessage( "Geogig", "Wrong or missing credentials", level=Qgis.Warning, duration=5) elif extype == GeogigError: currentWindow().messageBar().pushMessage("Geogig", str(value), level=Qgis.Warning, duration=5) if value.details is not None: QgsMessageLog.logMessage("{}:{}".format( str(value), value.details), level=Qgis.Critical) else: utils.qgis_excepthook(extype, value, tb)
def addMenus(self): if self.profilesMenu is not None: self.profilesMenu.clear() self.actions = defaultdict(list) settings = QSettings() defaultProfile = settings.value('profilesplugin/LastProfile', 'Default', str) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) for k, v in profiles.items(): action = QAction(k, self.iface.mainWindow()) action.setCheckable(True) if k == defaultProfile and autoLoad: action.setChecked(True) action.triggered.connect(lambda _, menuName=k: self.applyProfile(menuName)) action.setObjectName('mProfilesPlugin_' + k) self.actions[v.group].append(action) actions = self.iface.mainWindow().menuBar().actions() settingsMenu = None self.profilesGroup = QActionGroup(self.iface.mainWindow()) if self.profilesMenu is None: for action in actions: if action.menu().objectName() == 'mSettingsMenu': settingsMenu = action.menu() self.profilesMenu = QMenu(settingsMenu) self.profilesMenu.setObjectName('mProfilesPlugin') self.profilesMenu.setTitle(self.tr('Profiles')) settingsMenu.addMenu(self.profilesMenu) break if self.profilesMenu is not None: for k,v in self.actions.items(): submenu = QMenu(self.profilesMenu) submenu.setObjectName('mProfilesPlugin_submenu_' + k) submenu.setTitle(k) for action in v: self.profilesGroup.addAction(action) submenu.addAction(action) self.profilesMenu.addMenu(submenu) self.profilesMenu.addSeparator() settings = QSettings() def _setAutoLoad(): settings.setValue('profilesplugin/AutoLoad', self.autoloadAction.isChecked()) self.autoloadAction = QAction(self.tr('Auto-load last profile on QGIS start'), iface.mainWindow()) self.autoloadAction.setCheckable(True) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) self.autoloadAction.setChecked(autoLoad) self.autoloadAction.setObjectName('mProfilesPluginAutoLoad') self.autoloadAction.triggered.connect(_setAutoLoad) self.profilesMenu.addAction(self.autoloadAction) self.saveProfileAction = QAction(self.tr('Profiles manager...'), self.iface.mainWindow()) self.saveProfileAction.setObjectName('mProfilesPluginProfilesManager') self.saveProfileAction.triggered.connect(self.saveProfile) self.profilesMenu.addAction(self.saveProfileAction) self.showHelpAction = QAction(self.tr('Help'), self.iface.mainWindow()) self.showHelpAction.setIcon(QgsApplication.getThemeIcon('/mActionHelpContents.svg')) self.showHelpAction.setObjectName('mProfilesPluginShowHelp') self.showHelpAction.triggered.connect(self.showHelp) self.profilesMenu.addAction(self.showHelpAction)
class W3WTools(object): def __init__(self, iface): self.iface = iface try: from what3words.tests import testerplugin from qgistester.tests import addTestModule addTestModule(testerplugin, "what3words") except: pass self.mapTool = None if processingOk: self.provider = W3WProvider() readSettings() def initGui(self): mapToolIcon = QIcon(os.path.join(os.path.dirname(__file__), "icons", "w3w.png")) self.toolAction = QAction(mapToolIcon, "what3words map tool", self.iface.mainWindow()) self.toolAction.triggered.connect(self.setTool) self.toolAction.setCheckable(True) self.iface.addToolBarIcon(self.toolAction) self.iface.addPluginToMenu("what3words", self.toolAction) zoomToIcon = QIcon(':/images/themes/default/mActionZoomIn.svg') self.zoomToAction = QAction(zoomToIcon, "Zoom to 3 word address", self.iface.mainWindow()) self.zoomToAction.triggered.connect(self.zoomTo) self.iface.addPluginToMenu("what3words", self.zoomToAction) addSettingsMenu( "what3words", self.iface.addPluginToMenu) addHelpMenu( "what3words", self.iface.addPluginToMenu) addAboutMenu( "what3words", self.iface.addPluginToMenu) self.iface.mapCanvas().mapToolSet.connect(self.unsetTool) self.zoomToDialog = W3WCoordInputDialog(self.iface.mapCanvas(), self.iface.mainWindow()) self.iface.addDockWidget(Qt.TopDockWidgetArea, self.zoomToDialog) self.zoomToDialog.hide() if processingOk: Processing.addProvider(self.provider) try: from lessons import addLessonsFolder, addGroup folder = os.path.join(os.path.dirname(__file__), "_lessons") addLessonsFolder(folder, "what3words") except: pass def zoomTo(self): apikey = pluginSetting("apiKey") if apikey is None or apikey == "": self._showMessage('what3words API key is not set. Please set it and try again.', QgsMessageBar.WARNING) return self.zoomToDialog.setApiKey(apikey) self.zoomToDialog.show() def unsetTool(self, tool): try: if not isinstance(tool, W3WMapTool): self.toolAction.setChecked(False) except: # ignore exceptions thrown when unloading plugin, since # map tool class might not exist already pass def setTool(self): apikey = pluginSetting("apiKey") if apikey is None or apikey == "": self._showMessage('what3words API key is not set. Please set it and try again.', QgsMessageBar.WARNING) return if self.mapTool is None: self.mapTool = W3WMapTool(self.iface.mapCanvas()) self.toolAction.setChecked(True) self.iface.mapCanvas().setMapTool(self.mapTool) def unload(self): self.iface.mapCanvas().unsetMapTool(self.mapTool) self.iface.removeToolBarIcon(self.toolAction) self.iface.removePluginMenu("what3words", self.toolAction) self.iface.removePluginMenu("what3words", self.zoomToAction) removeSettingsMenu("what3words") removeHelpMenu("what3words") removeAboutMenu("what3words") self.iface.removeDockWidget(self.zoomToDialog) if processingOk: Processing.removeProvider(self.provider) try: from what3words.tests import testerplugin from qgistester.tests import removeTestModule removeTestModule(testerplugin, "what3words") except: pass try: from lessons import removeLessonsFolder folder = os.path.join(pluginPath, '_lessons') removeLessonsFolder(folder) except: pass def _showMessage(self, message, level=QgsMessageBar.INFO): iface.messageBar().pushMessage( message, level, iface.messageTimeout())
class BulkNominatim(object): def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() def initGui(self): """Initialize BulkNominatim GUI.""" # Initialize the Dialog Boxes self.settingsDialog = SettingsWidget(self.iface.mainWindow()) self.reverseGeocodeTool = ReverseGeocodeTool(self.iface, self.settingsDialog) self.bulkNominatimDialog = BulkNominatimDialog(self.iface, self.iface.mainWindow(), self.settingsDialog) self.canvas.mapToolSet.connect(self.unsetTool) # Initialize the bulk nominatim dialog box icon = QIcon(os.path.dirname(__file__) + "/images/icon.png") self.nominatimAction = QAction(icon, u"Bulk GeoCoding", self.iface.mainWindow()) self.nominatimAction.triggered.connect(self.nominatimTool) self.iface.addToolBarIcon(self.nominatimAction) self.iface.addPluginToMenu(u"Nominatim GeoCoding", self.nominatimAction) # Add Interface for Reverse GeoCoding icon = QIcon(os.path.dirname(__file__) + "/images/reverse.png") self.reverseGeocodeAction = QAction(icon, u"Reverse Point GeoCoding", self.iface.mainWindow()) self.reverseGeocodeAction.triggered.connect(self.setReverseGeocodeTool) self.reverseGeocodeAction.setCheckable(True) self.iface.addToolBarIcon(self.reverseGeocodeAction) self.iface.addPluginToMenu(u"Nominatim GeoCoding", self.reverseGeocodeAction) # Initialize the Settings Menu settingsicon = QIcon( os.path.dirname(__file__) + '/images/settings.png') self.settingsAction = QAction(settingsicon, u"Settings", self.iface.mainWindow()) self.settingsAction.triggered.connect(self.settings) self.iface.addPluginToMenu(u"Nominatim GeoCoding", self.settingsAction) # Help helpicon = QIcon(os.path.dirname(__file__) + '/images/help.png') self.helpAction = QAction(helpicon, u"Help", self.iface.mainWindow()) self.helpAction.triggered.connect(self.help) self.iface.addPluginToMenu(u"Nominatim GeoCoding", self.helpAction) def unsetTool(self, tool): '''Uncheck the Reverse Geocoding tool''' try: if not isinstance(tool, ReverseGeocodeTool): self.reverseGeocodeAction.setChecked(False) self.reverseGeocodeTool.clearSelection() except: pass def unload(self): """Unload BulkNominatim from the QGIS interface.""" self.canvas.unsetMapTool(self.reverseGeocodeTool) self.iface.removePluginMenu(u"Nominatim GeoCoding", self.nominatimAction) self.iface.removePluginMenu(u"Nominatim GeoCoding", self.reverseGeocodeAction) self.iface.removePluginMenu(u"Nominatim GeoCoding", self.settingsAction) self.iface.removePluginMenu(u"Nominatim GeoCoding", self.helpAction) self.iface.removeToolBarIcon(self.nominatimAction) self.iface.removeToolBarIcon(self.reverseGeocodeAction) self.reverseGeocodeTool.unload() def setReverseGeocodeTool(self): self.reverseGeocodeAction.setChecked(True) self.canvas.setMapTool(self.reverseGeocodeTool) def nominatimTool(self): """Display the dialog window.""" self.bulkNominatimDialog.show() def settings(self): self.settingsDialog.show() def help(self): '''Display a help page''' url = QUrl.fromLocalFile(os.path.dirname(__file__) + "/index.html").toString() webbrowser.open(url, new=2)
class OpenlayersPlugin: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # Keep a reference to all OL layers to avoid GC self._ol_layers = [] # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, "i18n", "openlayers_{}.qm".format(locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self._olLayerTypeRegistry = WebLayerTypeRegistry(self) self.olOverview = OLOverview(iface, self._olLayerTypeRegistry) self.dlgAbout = AboutDialog() self.pluginLayerRegistry = QgsPluginLayerRegistry() def initGui(self): self._olMenu = QMenu("TMS for Korea") self._olMenu.setIcon(QIcon(":/plugins/openlayers/openlayers.png")) # Overview self.overviewAddAction = QAction( QApplication.translate("OpenlayersPlugin", "OpenLayers Overview"), self.iface.mainWindow()) self.overviewAddAction.setCheckable(True) self.overviewAddAction.setChecked(False) self.overviewAddAction.toggled.connect(self.olOverview.setVisible) self._olMenu.addAction(self.overviewAddAction) self._actionAbout = QAction( QApplication.translate("dlgAbout", "About OpenLayers Plugin"), self.iface.mainWindow()) self._actionAbout.triggered.connect(self.dlgAbout.show) self._olMenu.addAction(self._actionAbout) self.dlgAbout.finished.connect(self._publicationInfoClosed) # Daum self._olLayerTypeRegistry.register(OlDaumStreetLayer()) self._olLayerTypeRegistry.register(OlDaumHybridLayer()) self._olLayerTypeRegistry.register(OlDaumSatelliteLayer()) self._olLayerTypeRegistry.register(OlDaumPhysicalLayer()) self._olLayerTypeRegistry.register(OlDaumCadstralLayer()) # Naver self._olLayerTypeRegistry.register(OlNaverStreetLayer()) self._olLayerTypeRegistry.register(OlNaverHybridLayer()) self._olLayerTypeRegistry.register(OlNaverSatelliteLayer()) self._olLayerTypeRegistry.register(OlNaverPhysicalLayer()) self._olLayerTypeRegistry.register(OlNaverCadastralLayer()) # VWorld self._olLayerTypeRegistry.register(OlVWorldStreetLayer()) self._olLayerTypeRegistry.register(OlVWorldSatelliteLayer()) self._olLayerTypeRegistry.register(OlVWorldGrayLayer()) self._olLayerTypeRegistry.register(OlVWorldHybridLayer()) # NGII self._olLayerTypeRegistry.register(OlNgiiStreetLayer()) self._olLayerTypeRegistry.register(OlNgiiBlankLayer()) self._olLayerTypeRegistry.register(OlNgiiEnglishLayer()) self._olLayerTypeRegistry.register(OlNgiiHighDensityLayer()) self._olLayerTypeRegistry.register(OlNgiiColorBlindLayer()) # Mango #self._olLayerTypeRegistry.register(OlMangoBaseMapLayer()) #self._olLayerTypeRegistry.register(OlMangoBaseMapGrayLayer()) #self._olLayerTypeRegistry.register(OlMangoHiDPIMapLayer()) #self._olLayerTypeRegistry.register(OlMangoHiDPIMapGrayLayer()) for group in self._olLayerTypeRegistry.groups(): groupMenu = group.menu() for layer in self._olLayerTypeRegistry.groupLayerTypes(group): layer.addMenuEntry(groupMenu, self.iface.mainWindow()) self._olMenu.addMenu(groupMenu) # Create Web menu, if it doesn't exist yet self.iface.addPluginToWebMenu("_tmp", self._actionAbout) self._menu = self.iface.webMenu() self._menu.addMenu(self._olMenu) self.iface.removePluginWebMenu("_tmp", self._actionAbout) # Register plugin layer type self.pluginLayerType = OpenlayersPluginLayerType( self.iface, self.setReferenceLayer, self._olLayerTypeRegistry) self.pluginLayerRegistry.addPluginLayerType(self.pluginLayerType) QgsProject.instance().readProject.connect(self.projectLoaded) QgsProject.instance().projectSaved.connect(self.projectSaved) def unload(self): self.iface.webMenu().removeAction(self._olMenu.menuAction()) self.olOverview.setVisible(False) del self.olOverview # Unregister plugin layer type self.pluginLayerRegistry.removePluginLayerType( OpenlayersLayer.LAYER_TYPE) QgsProject.instance().readProject.disconnect(self.projectLoaded) QgsProject.instance().projectSaved.disconnect(self.projectSaved) def addLayer(self, layerType): if layerType.hasXYZUrl(): # create XYZ layer layer, url = self.createXYZLayer(layerType, layerType.displayName) else: # create OpenlayersLayer layer = OpenlayersLayer(self.iface, self._olLayerTypeRegistry) layer.setName(layerType.displayName) layer.setLayerType(layerType) if layer.isValid(): coordRefSys = layerType.coordRefSys(self.canvasCrs()) self.setMapCrs(coordRefSys) QgsProject.instance().addMapLayer(layer) # store xyz config into qgis settings if layerType.hasXYZUrl(): settings = QSettings() settings.beginGroup('qgis/connections-xyz') settings.setValue("%s/authcfg" % (layer.name()), '') settings.setValue("%s/password" % (layer.name()), '') settings.setValue("%s/referer" % (layer.name()), '') settings.setValue("%s/url" % (layer.name()), url) settings.setValue("%s/username" % (layer.name()), '') # specify max/min or else only a picture of the map is saved # in settings settings.setValue("%s/zmax" % (layer.name()), '18') settings.setValue("%s/zmin" % (layer.name()), '0') settings.endGroup() # reload connections to update Browser Panel content self.iface.reloadConnections() self._ol_layers += [layer] # last added layer is new reference self.setReferenceLayer(layer) if not layerType.hasXYZUrl(): msg = "Printing and rotating of Javascript API " \ "based layers is currently not supported!" self.iface.messageBar().pushMessage("OpenLayers Plugin", msg, level=Qgis.MessageLevel(1), duration=5) def setReferenceLayer(self, layer): self.layer = layer def removeLayer(self, layerId): if self.layer is not None: if self.layer.id() == layerId: self.layer = None # TODO: switch to next available OpenLayers layer? def canvasCrs(self): mapCanvas = self.iface.mapCanvas() crs = mapCanvas.mapSettings().destinationCrs() return crs def setMapCrs(self, targetCRS): mapCanvas = self.iface.mapCanvas() mapExtent = mapCanvas.extent() sourceCRS = self.canvasCrs() QgsProject.instance().setCrs(targetCRS) mapCanvas.freeze(False) try: coordTrans = QgsCoordinateTransform(sourceCRS, targetCRS, QgsProject.instance()) mapExtent = coordTrans.transform( mapExtent, QgsCoordinateTransform.ForwardTransform) mapCanvas.setExtent(mapExtent) except: pass def projectLoaded(self): # replace old OpenlayersLayer with XYZ layer(OL plugin <= 1.3.6) rootGroup = self.iface.layerTreeView().layerTreeModel().rootGroup() for layer in QgsProject.instance().mapLayers().values(): if layer.type( ) == QgsMapLayer.PluginLayer and layer.pluginLayerType( ) == OpenlayersLayer.LAYER_TYPE: if layer.layerType.hasXYZUrl(): # replace layer xyzLayer, url = self.createXYZLayer( layer.layerType, layer.name()) if xyzLayer.isValid(): self.replaceLayer(rootGroup, layer, xyzLayer) def _hasOlLayer(self): for layer in QgsProject.instance().mapLayers().values(): if layer.customProperty('ol_layer_type'): return True return False def _publicationInfo(self): cloud_info_off = QSettings().value("Plugin-OpenLayers/cloud_info_off", defaultValue=False, type=bool) day = 3600 * 24 now = time.time() lastInfo = QSettings().value("Plugin-OpenLayers/cloud_info_ts", defaultValue=0.0, type=float) if lastInfo == 0.0: lastInfo = now - 20 * day # Show first time after 10 days QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", lastInfo) days = (now - lastInfo) / day if days >= 30 and not cloud_info_off: self.dlgAbout.tabWidget.setCurrentWidget( self.dlgAbout.tab_publishing) self.dlgAbout.show() QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", now) def _publicationInfoClosed(self): QSettings().setValue("Plugin-OpenLayers/cloud_info_off", self.dlgAbout.cb_publishing.isChecked()) def projectSaved(self): if self._hasOlLayer(): self._publicationInfo() def createXYZLayer(self, layerType, name): # create XYZ layer with tms url as uri provider = 'wms' url = "type=xyz&url=" + layerType.xyzUrlConfig() layer = QgsRasterLayer(url, name, provider, QgsRasterLayer.LayerOptions()) layer.setCustomProperty('ol_layer_type', layerType.layerTypeName) return layer, layerType.xyzUrlConfig() def replaceLayer(self, group, oldLayer, newLayer): index = 0 for child in group.children(): if QgsLayerTree.isLayer(child): if child.layerId() == oldLayer.id(): # insert new layer QgsProject.instance().addMapLayer(newLayer, False) newLayerNode = group.insertLayer(index, newLayer) newLayerNode.setVisible(child.isVisible()) # remove old layer QgsProject.instance().removeMapLayer(oldLayer.id()) msg = "Updated layer '%s' from old \ OpenLayers Plugin version" % newLayer.name() self.iface.messageBar().pushMessage( "OpenLayers Plugin", msg, level=Qgis.MessageLevel(0)) QgsMessageLog.logMessage(msg, "OpenLayers Plugin", QgsMessageLog.INFO) # layer replaced return True else: if self.replaceLayer(child, oldLayer, newLayer): # layer replaced in child group return True index += 1 # layer not in this group return False
class OpenlayersPlugin: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # Keep a reference to all OL layers to avoid GC self._ol_layers = [] # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, "i18n", "openlayers_{}.qm".format(locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > "4.3.3": QCoreApplication.installTranslator(self.translator) self._olLayerTypeRegistry = WebLayerTypeRegistry(self) self.olOverview = OLOverview(iface, self._olLayerTypeRegistry) self.dlgAbout = AboutDialog() self.pluginLayerRegistry = QgsPluginLayerRegistry() def initGui(self): self._olMenu = QMenu("TMS for Korea") self._olMenu.setIcon(QIcon(":/plugins/openlayers/openlayers.png")) # Overview self.overviewAddAction = QAction( QApplication.translate("OpenlayersPlugin", "OpenLayers Overview"), self.iface.mainWindow()) self.overviewAddAction.setCheckable(True) self.overviewAddAction.setChecked(False) self.overviewAddAction.toggled.connect(self.olOverview.setVisible) self._olMenu.addAction(self.overviewAddAction) self._actionAbout = QAction( QApplication.translate("dlgAbout", "About OpenLayers Plugin"), self.iface.mainWindow()) self._actionAbout.triggered.connect(self.dlgAbout.show) self._olMenu.addAction(self._actionAbout) self.dlgAbout.finished.connect(self._publicationInfoClosed) # Kakao Maps - 5181 self._olLayerTypeRegistry.register(OlDaumStreetLayer()) self._olLayerTypeRegistry.register(OlDaumHybridLayer()) self._olLayerTypeRegistry.register(OlDaumSatelliteLayer()) self._olLayerTypeRegistry.register(OlDaumPhysicalLayer()) self._olLayerTypeRegistry.register(OlDaumCadstralLayer()) # Naver Maps - 3857(New) self._olLayerTypeRegistry.register(OlNaverStreetLayer()) self._olLayerTypeRegistry.register(OlNaverHybridLayer()) self._olLayerTypeRegistry.register(OlNaverSatelliteLayer()) self._olLayerTypeRegistry.register(OlNaverPhysicalLayer()) self._olLayerTypeRegistry.register(OlNaverCadastralLayer()) # Naver Maps - 5179(Old) self._olLayerTypeRegistry.register(OlNaverStreet5179Layer()) self._olLayerTypeRegistry.register(OlNaverHybrid5179Layer()) self._olLayerTypeRegistry.register(OlNaverSatellite5179Layer()) self._olLayerTypeRegistry.register(OlNaverPhysical5179Layer()) self._olLayerTypeRegistry.register(OlNaverCadastral5179Layer()) # VWorld - 3857 self._olLayerTypeRegistry.register(OlVWorldStreetLayer()) self._olLayerTypeRegistry.register(OlVWorldSatelliteLayer()) self._olLayerTypeRegistry.register(OlVWorldGrayLayer()) self._olLayerTypeRegistry.register(OlVWorldHybridLayer()) # NGII - 5179 self._olLayerTypeRegistry.register(OlNgiiStreetLayer()) self._olLayerTypeRegistry.register(OlNgiiBlankLayer()) self._olLayerTypeRegistry.register(OlNgiiEnglishLayer()) self._olLayerTypeRegistry.register(OlNgiiHighDensityLayer()) self._olLayerTypeRegistry.register(OlNgiiColorBlindLayer()) # Mango - 3857 #self._olLayerTypeRegistry.register(OlMangoBaseMapLayer()) #self._olLayerTypeRegistry.register(OlMangoBaseMapGrayLayer()) #self._olLayerTypeRegistry.register(OlMangoHiDPIMapLayer()) #self._olLayerTypeRegistry.register(OlMangoHiDPIMapGrayLayer()) for group in self._olLayerTypeRegistry.groups(): groupMenu = group.menu() for layer in self._olLayerTypeRegistry.groupLayerTypes(group): layer.addMenuEntry(groupMenu, self.iface.mainWindow()) self._olMenu.addMenu(groupMenu) # Create Web menu, if it doesn't exist yet self.iface.addPluginToWebMenu("_tmp", self._actionAbout) self._menu = self.iface.webMenu() self._menu.addMenu(self._olMenu) self.iface.removePluginWebMenu("_tmp", self._actionAbout) # Register plugin layer type self.pluginLayerType = OpenlayersPluginLayerType( self.iface, self.setReferenceLayer, self._olLayerTypeRegistry) self.pluginLayerRegistry.addPluginLayerType(self.pluginLayerType) QgsProject.instance().readProject.connect(self.projectLoaded) QgsProject.instance().projectSaved.connect(self.projectSaved) def unload(self): self.iface.webMenu().removeAction(self._olMenu.menuAction()) self.olOverview.setVisible(False) del self.olOverview # Unregister plugin layer type self.pluginLayerRegistry.removePluginLayerType( OpenlayersLayer.LAYER_TYPE) QgsProject.instance().readProject.disconnect(self.projectLoaded) QgsProject.instance().projectSaved.disconnect(self.projectSaved) def addLayer(self, layerType): if layerType.hasXYZUrl(): # create XYZ layer layer, url = self.createXYZLayer(layerType, layerType.displayName) else: # create OpenlayersLayer layer = OpenlayersLayer(self.iface, self._olLayerTypeRegistry) layer.setName(layerType.displayName) layer.setLayerType(layerType) if layer.isValid(): coordRefSys = layerType.coordRefSys(self.canvasCrs()) self.setMapCrs(coordRefSys) QgsProject.instance().addMapLayer(layer) self._ol_layers += [layer] # last added layer is new reference self.setReferenceLayer(layer) def setReferenceLayer(self, layer): self.layer = layer def removeLayer(self, layerId): if self.layer is not None: if self.layer.id() == layerId: self.layer = None # TODO: switch to next available OpenLayers layer? def canvasCrs(self): mapCanvas = self.iface.mapCanvas() crs = mapCanvas.mapSettings().destinationCrs() return crs def setMapCrs(self, targetCRS): mapCanvas = self.iface.mapCanvas() mapExtent = mapCanvas.extent() sourceCRS = self.canvasCrs() QgsProject.instance().setCrs(targetCRS) mapCanvas.freeze(False) try: coordTrans = QgsCoordinateTransform(sourceCRS, targetCRS, QgsProject.instance()) mapExtent = coordTrans.transform( mapExtent, QgsCoordinateTransform.ForwardTransform) mapCanvas.setExtent(mapExtent) except: pass def projectLoaded(self): # replace old OpenlayersLayer with XYZ layer(OL plugin <= 1.3.6) rootGroup = self.iface.layerTreeView().layerTreeModel().rootGroup() for layer in QgsProject.instance().mapLayers().values(): if layer.type( ) == QgsMapLayer.PluginLayer and layer.pluginLayerType( ) == OpenlayersLayer.LAYER_TYPE: if layer.layerType.hasXYZUrl(): # replace layer xyzLayer, url = self.createXYZLayer( layer.layerType, layer.name()) if xyzLayer.isValid(): self.replaceLayer(rootGroup, layer, xyzLayer) def _hasOlLayer(self): for layer in QgsProject.instance().mapLayers().values(): if layer.customProperty("ol_layer_type"): return True return False def _publicationInfo(self): cloud_info_off = QSettings().value("Plugin-OpenLayers/cloud_info_off", defaultValue=False, type=bool) day = 3600 * 24 now = time.time() lastInfo = QSettings().value("Plugin-OpenLayers/cloud_info_ts", defaultValue=0.0, type=float) if lastInfo == 0.0: lastInfo = now - 20 * day # Show first time after 10 days QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", lastInfo) days = (now - lastInfo) / day if days >= 30 and not cloud_info_off: self.dlgAbout.tabWidget.setCurrentWidget( self.dlgAbout.tab_publishing) self.dlgAbout.show() QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", now) def _publicationInfoClosed(self): QSettings().setValue("Plugin-OpenLayers/cloud_info_off", self.dlgAbout.cb_publishing.isChecked()) def projectSaved(self): if self._hasOlLayer(): self._publicationInfo() def createXYZLayer(self, layerType, name): # create XYZ layer with tms url as uri provider = "wms" # isinstance(P, (list, tuple, np.ndarray)) xyzUrls = layerType.xyzUrlConfig() layerName = name tilePixelRatio = layerType.tilePixelRatio coordRefSys = layerType.coordRefSys(self.canvasCrs()) self.setMapCrs(coordRefSys) if isinstance(xyzUrls, (list)): # create group layer root = QgsProject.instance().layerTreeRoot() layer = root.addGroup(layerType.groupName) i = 0 for xyzUrl in xyzUrls: tmsLayerName = layerName # https://github.com/qgis/QGIS/blob/master/src/providers/wms/qgsxyzconnectiondialog.cpp uri = "url=" + xyzUrl + "&zmax=18&zmin=0&type=xyz" if (tilePixelRatio > 0): uri = uri + "&tilePixelRatio=" + str(tilePixelRatio) if i > 0: tmsLayerName = layerName + " Label" tmsLayer = QgsRasterLayer(uri, tmsLayerName, provider, QgsRasterLayer.LayerOptions()) tmsLayer.setCustomProperty("ol_layer_type", tmsLayerName) layer.insertChildNode(0, QgsLayerTreeLayer(tmsLayer)) i = i + 1 if tmsLayer.isValid(): QgsProject.instance().addMapLayer(tmsLayer, False) self._ol_layers += [tmsLayer] # last added layer is new reference self.setReferenceLayer(tmsLayer) # add to XYT Tiles self.addToXYZTiles(tmsLayerName, xyzUrl, tilePixelRatio) else: uri = "url=" + xyzUrls + "&zmax=18&zmin=0&type=xyz" if (tilePixelRatio > 0): uri = uri + "&tilePixelRatio=" + str(tilePixelRatio) layer = QgsRasterLayer(uri, layerName, provider, QgsRasterLayer.LayerOptions()) layer.setCustomProperty("ol_layer_type", layerName) if layer.isValid(): QgsProject.instance().addMapLayer(layer) self._ol_layers += [layer] # last added layer is new reference self.setReferenceLayer(layer) # add to XYT Tiles self.addToXYZTiles(layerName, xyzUrls, tilePixelRatio) # reload connections to update Browser Panel content self.iface.reloadConnections() return layer, xyzUrls def addToXYZTiles(self, name, url, tilePixelRatio): # store xyz config into qgis settings settings = QSettings() settings.beginGroup("qgis/connections-xyz") settings.setValue("%s/authcfg" % (name), "") settings.setValue("%s/password" % (name), "") settings.setValue("%s/referer" % (name), "") settings.setValue("%s/url" % (name), url) settings.setValue("%s/username" % (name), "") # specify max/min or else only a picture of the map is saved in settings settings.setValue("%s/zmax" % (name), "18") settings.setValue("%s/zmin" % (name), "0") if tilePixelRatio >= 0 and tilePixelRatio <= 2: settings.setValue("%s/tilePixelRatio" % (name), str(tilePixelRatio)) settings.endGroup() def replaceLayer(self, group, oldLayer, newLayer): index = 0 for child in group.children(): if QgsLayerTree.isLayer(child): if child.layerId() == oldLayer.id(): # insert new layer QgsProject.instance().addMapLayer(newLayer, False) newLayerNode = group.insertLayer(index, newLayer) newLayerNode.setVisible(child.isVisible()) # remove old layer QgsProject.instance().removeMapLayer(oldLayer.id()) msg = "Updated layer '%s' from old OpenLayers Plugin version" % newLayer.name( ) self.iface.messageBar().pushMessage( "OpenLayers Plugin", msg, level=Qgis.MessageLevel(0)) QgsMessageLog.logMessage(msg, "OpenLayers Plugin", QgsMessageLog.INFO) # layer replaced return True else: if self.replaceLayer(child, oldLayer, newLayer): # layer replaced in child group return True index += 1 # layer not in this group return False
class GimpSelectionFeaturePlugin(QObject): def __init__(self, iface): super().__init__() self.iface = iface self.name = u"&Gimp Selection Feature" self.dock = self.exitsPluginGimp = None self.translate = Translate( 'gimpselectionfeature' ) def initGui(self): def setExistsPluginGimp(): def getDirPluginGimp(): dirPlugin = None mask = r".*gimp.[0-9]+.[0-9]+/%s" % nameDirPlugin # Linux Format for root, dirs, files in os.walk( dirHome ): if re.match( mask, root.replace('\\', '/'), re.IGNORECASE ): dirPlugin = root break return dirPlugin def copyNewPlugin(): shutil.copy2( gimpPlugin, gimpPluginInstall ) if sys.platform != 'win32': # Add executable st = os.stat( gimpPluginInstall ) os.chmod( gimpPluginInstall, st.st_mode | stat.S_IEXEC ) dirHome = os.path.expanduser('~') nameDirPlugin = "plug-ins" dirPluginGimp = getDirPluginGimp() if dirPluginGimp is None: msg = "Not found diretory 'GIMP' or 'GIMP {}' in '{}'".format( nameDirPlugin, dirHome ) self.exitsPluginGimp = { 'isOk': False, 'msg': msg } return namePlugin = 'socket_server_selection.py' gimpPlugin = os.path.join( os.path.dirname(__file__), namePlugin ) gimpPluginInstall = os.path.join( dirPluginGimp, namePlugin ) if not os.path.exists( gimpPluginInstall ) or not filecmp.cmp( gimpPlugin, gimpPluginInstall ): copyNewPlugin() self.exitsPluginGimp = { 'isOk': True } name = "Gimp Selection Feature" about = QCoreApplication.translate('GimpSelectionFeature', 'Adding selected area in GIMP how a feature in shapefile') icon = QIcon( os.path.join( os.path.dirname(__file__), 'gimpselectionfeature.svg' ) ) self.action = QAction( icon, name, self.iface.mainWindow() ) self.action.setObjectName( name.replace(' ', '') ) self.action.setWhatsThis( about ) self.action.setStatusTip( about ) self.action.setCheckable( True ) self.action.triggered.connect( self.run ) self.iface.addRasterToolBarIcon( self.action ) self.iface.addPluginToRasterMenu( self.name, self.action ) setExistsPluginGimp() if not self.exitsPluginGimp['isOk']: return self.dock = DockWidgetGimpSelectionFeature( self.iface ) self.iface.addDockWidget( Qt.RightDockWidgetArea , self.dock ) self.dock.visibilityChanged.connect( self.dockVisibilityChanged ) def unload(self): self.iface.removeRasterToolBarIcon( self.action ) self.iface.removePluginRasterMenu( self.name, self.action ) if self.exitsPluginGimp['isOk']: self.dock.close() del self.dock self.dock = None del self.action @pyqtSlot() def run(self): if not self.exitsPluginGimp['isOk']: ( t, m ) = ( GimpSelectionFeature.nameModulus, self.exitsPluginGimp['msg'] ) self.iface.messageBar().pushMessage( t, m, Qgis.Critical, 5 ) self.action.setChecked( False ) return if self.dock.isVisible(): self.dock.hide() else: self.dock.show() @pyqtSlot(bool) def dockVisibilityChanged(self, visible): self.action.setChecked( visible )
class WebGisPlugin(object): dialog = None project = None ws = None def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, 'i18n', 'gisquick_{}.qm'.format(locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) def initGui(self): # Create action that will start plugin configuration self.action = QAction(QIcon(":/plugins/gisquick2/img/icon.svg"), u"Publish in Gisquick", self.iface.mainWindow()) self.action.setCheckable(True) # connect the action to the run method self.action.triggered.connect(self.toggle_tool) self.settings_action = QAction( QIcon(":/plugins/gisquick2/img/settings.svg"), u"Configure", self.iface.mainWindow()) # connect the action to the run method self.settings_action.triggered.connect(self.show_settings) # Add toolbar button and menu item # self.iface.addToolBarIcon(self.action) self.iface.addWebToolBarIcon(self.action) self.iface.addPluginToWebMenu(u"&Gisquick2", self.action) self.iface.addPluginToWebMenu(u"&Gisquick2", self.settings_action) def unload(self): if self.ws: gisquick_ws.stop() self.ws = None # Remove the plugin menu item and icon self.iface.removePluginWebMenu(u"&Gisquick2", self.action) self.iface.removePluginWebMenu(u"&Gisquick2", self.settings_action) self.iface.removeWebToolBarIcon(self.action) def is_overlay_layer_for_publish(self, layer): """Checks whether layer can be published as an overlay layer. Args: layer (qgis.core.QgsMapLayer): project layer Returns: bool: True if a layer can be published as an overlay layer """ return (layer.type() == QgsMapLayer.VectorLayer or (layer.type() == QgsMapLayer.RasterLayer and layer.providerType() != "wms")) def is_base_layer_for_publish(self, layer): """Checks whether layer could be published as a base layer. Args: layer (qgis.core.QgsMapLayer): project layer Returns: bool: True if a layer can be published as a base layer """ return layer.type() == QgsMapLayer.RasterLayer and layer.providerType( ) == "wms" def map_units(self): """Returns units name of the project (map). Returns: str: map units name ('meters', 'feet', 'degrees', 'miles' or 'unknown') """ return { 0: 'meters', 1: 'feet', 2: 'degrees', 3: 'unknown', 7: 'miles' }[self.iface.mapCanvas().mapUnits()] def scales_to_resolutions(self, scales): """Converts map scales to tile resolutions (with fixed DPI=96). Args: scales (List[int]): array of map scales Returns: List[Decimal]: array of computed tile resolutions """ return scales_to_resolutions(scales, self.map_units()) def resolutions_to_scales(self, resolutions): """Converts tile resolutions to map scales (with fixed DPI=96). Args: resolutions (List[Decimal]): array of tile resolutions Returns: List[int]: array of computed map scales """ return resolutions_to_scales(resolutions, self.map_units()) def filter_visible_resolutions(self, resolutions, layer): """Filters given tile resolutions by layer's visibility settings. Args: resolutions (List[Decimal]): array of tile resolutions layer (qgis.core.QgsMapLayer): map layer Returns: List[Decimal]: array of visible tile resolutions """ if layer.hasScaleBasedVisibility(): max_scale_exclusive = layer.maximumScale() min_scale_inclusive = layer.minimumScale() max_res_exclusive, min_res_inclusive = self.scales_to_resolutions( [max_scale_exclusive, min_scale_inclusive]) return [ res for res in resolutions if res >= min_res_inclusive and res < max_res_exclusive ] return resolutions def wmsc_layer_resolutions(self, layer): """Returns visible resolutions of given WMSC layer. Args: layer (qgis.core.QgsRasterLayer): raster layer (WMSC) Returns: List[Decimal]: array of layer's visible tile resolutions """ layer_resolutions = layer.dataProvider().property('resolutions') if layer_resolutions: layer_resolutions = to_decimal_array(layer_resolutions) if layer.hasScaleBasedVisibility(): layer_resolutions = self.filter_visible_resolutions( layer_resolutions, layer) if layer_resolutions: return sorted(layer_resolutions, reverse=True) return [] return None def project_layers_resolutions(self): """Returns list of possible tile resolutions for current project. Returns: List[Decimal]: project tile resolutions """ # compute resolutions as an union of resolutions calculated from project's # map scales and resolutions of all WMSC layers. project_tile_resolutions = set() # collect set of all resolutions from WMSC base layers base_layers = { layer.id(): layer for layer in QgsProject.instance().mapLayers().values() if self.is_base_layer_for_publish(layer) } for layer in list(base_layers.values()): layer_resolutions = self.wmsc_layer_resolutions(layer) if layer_resolutions: project_tile_resolutions.update(layer_resolutions) wmsc_layers_scales = self.resolutions_to_scales( project_tile_resolutions) scales, ok = self.project.readListEntry("Scales", "/ScalesList") if ok and scales: scales = [int(scale.split(":")[-1]) for scale in scales] # filter duplicit scales scales = [ scale for scale in scales if scale not in wmsc_layers_scales ] project_tile_resolutions.update( self.scales_to_resolutions(sorted(scales, reverse=True))) project_tile_resolutions = sorted(project_tile_resolutions, reverse=True) return project_tile_resolutions def layers_list(self): """Returns array of all project's layers. Returns: List[qgis.core.QgsMapLayer]: project's layers """ # legend_iface = self.iface.legendInterface().layers() return [ tree_layer.layer() for tree_layer in QgsProject.instance().layerTreeRoot().findLayers() ] def get_layer_attributes(self, layer): fields = layer.fields() attributes_data = [] excluded_attributes = layer.excludeAttributesWfs() conversion_types = { 'BIGINT': 'INTEGER', 'INTEGER64': 'INTEGER', 'REAL': 'DOUBLE', 'STRING': 'TEXT', 'INT2': 'INTEGER', 'INT4': 'INTEGER', 'INT8': 'INTEGER', 'NUMERIC': 'DOUBLE', 'FLOAT8': 'DOUBLE', 'VARCHAR': 'TEXT', 'CHARACTER': 'TEXT' } for field in fields: if field.name() in excluded_attributes: continue field_type = field.typeName().upper() if field_type in conversion_types: field_type = conversion_types[field_type] attribute_data = { 'name': field.name(), 'type': field_type, #'length': field.length(), #'precision': field.precision() } if field.comment(): attribute_data['comment'] = field.comment() alias = layer.attributeAlias(fields.indexFromName(field.name())) if alias: attribute_data['alias'] = alias attributes_data.append(attribute_data) return attributes_data def get_project_layers(self, skip_layers_with_error=False): dbname_pattern = re.compile("dbname='([^']+)'") project = QgsProject.instance() project_dir = project.absolutePath() + os.path.sep non_identifiable_layers = project.readListEntry( "Identify", "/disabledLayers")[0] or [] wfs_layers = project.readListEntry("WFSLayers", "/")[0] or [] map_canvas = self.iface.mapCanvas() map_settings = map_canvas.mapSettings() if project.layerTreeRoot().hasCustomLayerOrder(): layers_order = project.layerTreeRoot().customLayerOrder() else: layers_order = self.layers_list() def visit_node(tree_node): if isinstance(tree_node, QgsLayerTreeLayer): layer = tree_node.layer() layer_type = { 0: "vector", 1: "raster", # 2: PluginLayer # 3: MeshLayer }[layer.type()] source = layer.source() provider_type = layer.providerType() uri = "" if provider_type == "wms": source_params = parse_qs(source) uri = source_params["url"][0] elif provider_type == "postgres": dp = layer.dataProvider() uri = "postgresql://%s:%s" % (dp.uri().host(), dp.uri().port()) elif provider_type in ("ogr", "gdal"): uri = "file://%s" % source.split("|")[0] elif provider_type == "spatialite": match = dbname_pattern.search(source) if match: uri = "file://%s" % match.group(1) else: uri = source extent = layer.extent() if not extent.isEmpty(): extent = map_settings.layerExtentToOutputExtent( layer, layer.extent()).toRectF().getCoords() else: extent = None info = { "id": layer.id(), "name": layer.name(), "serverName": layer.shortName() if hasattr(layer, "shortName") else layer.name(), "wfs": layer.id() in wfs_layers, "provider_type": provider_type, "projection": layer.crs().authid(), "type": layer_type, "source": uri, "extent": extent, "visible": project.layerTreeRoot().findLayer(layer.id()).isVisible(), "metadata": { "title": layer.title(), "abstract": layer.abstract(), "keyword_list": layer.keywordList() } } legend_url = layer.legendUrl() if legend_url: info["legend_url"] = legend_url # if layer.isSpatial() if layer_type == "vector": info["geom_type"] = ('POINT', 'LINE', 'POLYGON', None, None)[layer.geometryType()] info["wkb_type"] = QgsWkbTypes.displayString( layer.wkbType()) info["labels"] = layer.labelsEnabled() info["attributes"] = self.get_layer_attributes(layer) info["queryable"] = bool(info["attributes"]) and layer.id( ) not in non_identifiable_layers and layer.id( ) in wfs_layers if info["attributes"]: fields = layer.fields() info["pk_attributes"] = [ fields.at(index).name() for index in layer.dataProvider().pkAttributeIndexes() ] if provider_type == "wms": info["url"] = source_params["url"][0] img_format = source_params.get("format", [None])[0] if not img_format: img_format = os.path.splitext(info["url"])[1].replace( ".", "image/") info["format"] = img_format info["dpi"] = layer.dataProvider().dpi() if "layers" in source_params: info["wms_layers"] = source_params["layers"] if layer in layers_order: info["drawing_order"] = layers_order.index(layer) if layer.attribution(): info["attribution"] = { "title": layer.attribution(), "url": layer.attributionUrl() } return info else: children = [] for child_tree_node in tree_node.children(): try: info = visit_node(child_tree_node) if info: children.append(info) except Exception as e: if not skip_layers_with_error: msg = "Failed to gather info from layer: '%s'" % child_tree_node.name( ) raise WsError(msg, 405) from e return {"name": tree_node.name(), "layers": children} root_node = self.iface.layerTreeView().layerTreeModel().rootGroup() return visit_node(root_node)["layers"] def get_print_templates(self): composer_templates = [] project_layout_manager = QgsProject.instance().layoutManager() for layout in project_layout_manager.layouts(): map = layout.referenceMap() units_conversion = map.mapUnitsToLayoutUnits() composer_data = { 'name': layout.name(), 'width': layout.layoutBounds().width(), 'height': layout.layoutBounds().height(), 'map': { 'name': 'map0', 'x': map.pagePos().x(), 'y': map.pagePos().y(), 'width': map.extent().width() * units_conversion, 'height': map.extent().height() * units_conversion }, 'labels': [ item.id() for item in list(layout.items()) if isinstance(item, QgsLayoutItemLabel) and item.id() ] } grid = map.grid() if grid.enabled(): composer_data['map']['grid'] = { 'intervalX': grid.intervalX(), 'intervalY': grid.intervalY(), } composer_templates.append(composer_data) return composer_templates def get_project_info(self, skip_layers_with_error=False): project = QgsProject.instance() project_crs = project.crs() map_canvas = self.iface.mapCanvas() # scales, _ = project.readListEntry("Scales", "/ScalesList") # scales = [int(s.split(":")[1]) for s in scales] view_settings = project.viewSettings() scales = view_settings.mapScales() projections = {} crs_list = [project_crs ] + [l.crs() for l in project.mapLayers().values()] for crs in crs_list: if crs.authid() not in projections: projections[crs.authid()] = { "is_geographic": crs.isGeographic(), "proj4": crs.toProj4() } data = { "file": project.absoluteFilePath(), "directory": project.absolutePath(), "title": project.title() or project.readEntry("WMSServiceTitle", "/")[0], "layers": self.get_project_layers(skip_layers_with_error), "composer_templates": self.get_print_templates(), "projection": { "code": project_crs.authid(), "is_geographic": project_crs.isGeographic(), "proj4": project_crs.toProj4() }, "units": self.map_units(), "scales": scales, "position_precision": { "automatic": project.readBoolEntry("PositionPrecision", "/Automatic")[0], "decimal_places": project.readNumEntry("PositionPrecision", "/DecimalPlaces")[0] }, "extent": map_canvas.fullExtent().toRectF().getCoords(), # "default_view_extent": view_settings.defaultViewExtent(), "server": { "wms_add_geometry": project.readBoolEntry("WMSAddWktGeometry", "")[0] }, "projections": projections } return data def get_settings(self): return QSettings(QSettings.IniFormat, QSettings.UserScope, "Gisquick", "gisquick2") def show_settings(self): settings = self.get_settings() dialog_filename = os.path.join(self.plugin_dir, "ui", "settings.ui") dialog = PyQt5.uic.loadUi(dialog_filename) dialog.server_url.setText(settings.value("server_url", "")) dialog.username.setText(settings.value("username", "")) dialog.password.setText(settings.value("password", "")) dialog.show() res = dialog.exec_() if res == 1: settings.setValue("server_url", dialog.server_url.text().rstrip("/")) settings.setValue("username", dialog.username.text()) settings.setValue("password", dialog.password.text()) def on_project_change(self, *args): gisquick_ws.send("ProjectChanged") def on_project_closed(self, *args): def debounced(): # filter events caused by switching between projects if not QgsProject.instance().absoluteFilePath(): gisquick_ws.send("ProjectChanged") QTimer.singleShot(300, debounced) def toggle_tool(self, active): """Display dialog window for publishing current project. During a configuration process (wizard setup), plugin will hold actual metadata object in 'WebGisPlugin.metadata' property. If metadata from previous publishing still exist, they will be loaded and stored in 'WebGisPlugin.last_metadata' property. """ def callback(msg): msg_type = msg["type"] data = msg.get("data") if msg_type == "ProjectInfo": if QgsProject.instance().absolutePath(): if data: skip_layers_with_error = data.get( "skip_layers_with_error", False) return self.get_project_info( skip_layers_with_error=skip_layers_with_error) raise WsError("Project is not opened", 404) elif msg_type == "ProjectDirectory": dir_path = QgsProject.instance().absolutePath() if dir_path: return dir_path raise WsError("Project is not opened", 404) else: raise ValueError("Unknown message type: %s" % msg_type) def on_connection_estabilished(): # self.iface.messageBar().pushMessage("Gisquick", "plugin is connected to server: %s" % server_url, level=Qgis.Success) def open_browser(): import webbrowser webbrowser.open(urljoin(server_url, '/user/')) widget = self.iface.messageBar().createMessage( "Gisquick", "successfully connected to server: %s" % server_url) button = QPushButton(widget) button.setText("Open Browser") button.pressed.connect(open_browser) widget.layout().addWidget(button) self.iface.messageBar().pushWidget(widget, Qgis.Success) self.active_notification_widget = widget project = QgsProject.instance() if active: self.active_notification_widget = None settings = self.get_settings() server_url = settings.value("server_url") username = settings.value("username") password = settings.value("password") if not server_url or not username or not password: self.show_settings() server_url = settings.value("server_url") username = settings.value("username") password = settings.value("password") plugin_ver = __metadata__["general"].get("version") client_info = "GisquickPlugin/%s (%s %s; QGIS %s)" % ( plugin_ver, platform.system(), platform.machine(), Qgis.QGIS_VERSION) class WebsocketServer(QThread): finished = QtCore.pyqtSignal(int) success = QtCore.pyqtSignal() def run(self): # print("Starting WS", "server:", server_url, "user:", username) def on_success(): self.success.emit() res = gisquick_ws.start(server_url, username, password, client_info, callback, on_success) self.finished.emit(res) def on_finished(res): self.ws = None if self.action.isChecked(): self.action.setChecked(False) if res != 0: QMessageBox.warning(None, 'Warning', 'Failed to connect!') else: if self.iface.messageBar().currentItem( ) == self.active_notification_widget: self.iface.messageBar().popWidget( self.active_notification_widget) self.active_notification_widget = None self.ws = WebsocketServer() self.ws.finished.connect(on_finished) self.ws.success.connect(on_connection_estabilished) r = self.ws.start() # project.isDirtyChanged.connect(self.on_project_change) project.readProject.connect(self.on_project_change) project.projectSaved.connect(self.on_project_change) project.cleared.connect(self.on_project_closed) else: gisquick_ws.stop() project.readProject.disconnect(self.on_project_change) project.projectSaved.disconnect(self.on_project_change) project.cleared.disconnect(self.on_project_closed)
class cadastre_menu(object): def __init__(self, iface): self.iface = iface self.mapCanvas = iface.mapCanvas() self.cadastre_search_dialog = None self.provider = CadastreProvider() def cadastre_add_submenu(self, submenu): self.iface.addPluginToMenu("&Cadastre", submenu.menuAction()) def initGui(self): # Add procesing provider QgsApplication.processingRegistry().addProvider(self.provider) # Import Submenu plugin_dir = str(Path(__file__).resolve().parent) icon = QIcon(plugin_dir + "/icons/database.png") self.import_action = QAction(icon, "Importer des données", self.iface.mainWindow()) self.import_action.triggered.connect(self.open_import_dialog) # Search Submenu icon = QIcon(plugin_dir + "/icons/search.png") self.search_action = QAction(icon, "Outils de recherche", self.iface.mainWindow()) self.search_action.triggered.connect(self.toggle_search_dialog) if not self.cadastre_search_dialog: dialog = cadastre_search_dialog(self.iface) self.cadastre_search_dialog = dialog # Load Submenu icon = QIcon(plugin_dir + "/icons/output.png") self.load_action = QAction(icon, "Charger des données", self.iface.mainWindow()) self.load_action.triggered.connect(self.open_load_dialog) # Composer Submenu icon = QIcon(plugin_dir + "/icons/mActionSaveAsPDF.png") self.export_action = QAction(icon, "Exporter la vue", self.iface.mainWindow()) self.export_action.triggered.connect(self.export_view) # Options Submenu icon = QIcon(plugin_dir + "/icons/config.png") self.option_action = QAction(icon, "Configurer le plugin", self.iface.mainWindow()) self.option_action.triggered.connect(self.open_option_dialog) # About Submenu icon = QIcon(plugin_dir + "/icons/about.png") self.about_action = QAction(icon, "À propos", self.iface.mainWindow()) self.about_action.triggered.connect(self.open_about_dialog) # Help Submenu icon = QIcon(plugin_dir + "/icons/about.png") self.help_action = QAction(icon, "Aide", self.iface.mainWindow()) self.help_action.triggered.connect(self.open_help) # version Submenu icon = QIcon(plugin_dir + "/icons/about.png") self.version_action = QAction(icon, "Notes de version", self.iface.mainWindow()) self.version_action.triggered.connect(self.open_message_dialog) # Add Cadastre to Extension menu self.iface.addPluginToMenu("&Cadastre", self.import_action) self.iface.addPluginToMenu("&Cadastre", self.load_action) self.iface.addPluginToMenu("&Cadastre", self.search_action) self.iface.addPluginToMenu("&Cadastre", self.export_action) self.iface.addPluginToMenu("&Cadastre", self.option_action) self.iface.addPluginToMenu("&Cadastre", self.about_action) self.iface.addPluginToMenu("&Cadastre", self.version_action) self.iface.addPluginToMenu("&Cadastre", self.help_action) # Add cadastre toolbar self.toolbar = self.iface.addToolBar('&Cadastre'); # open import dialog self.openImportAction = QAction( QIcon(plugin_dir +"/icons/database.png"), "Importer des données", self.iface.mainWindow() ) self.openImportAction.triggered.connect(self.open_import_dialog) self.toolbar.addAction(self.openImportAction) self.toolbar.setObjectName("cadastreToolbar"); # open load dialog self.openLoadAction = QAction( QIcon(plugin_dir +"/icons/output.png"), "Charger des données", self.iface.mainWindow() ) self.openLoadAction.triggered.connect(self.open_load_dialog) self.toolbar.addAction(self.openLoadAction) # open search dialog self.openSearchAction = QAction( QIcon(plugin_dir +"/icons/search.png"), "Outils de recherche", self.iface.mainWindow() ) self.openSearchAction.triggered.connect(self.toggle_search_dialog) #~ self.openSearchAction.setCheckable(True) self.toolbar.addAction(self.openSearchAction) # export composer self.runExportAction = QAction( QIcon(plugin_dir +"/icons/mActionSaveAsPDF.png"), "Exporter la vue", self.iface.mainWindow() ) self.runExportAction.triggered.connect(self.export_view) self.toolbar.addAction(self.runExportAction) # open Option dialog self.openOptionAction = QAction( QIcon(plugin_dir +"/icons/config.png"), "Configurer le plugin", self.iface.mainWindow() ) self.openOptionAction.triggered.connect(self.open_option_dialog) self.toolbar.addAction(self.openOptionAction) # open About dialog self.openAboutAction = QAction( QIcon(plugin_dir +"/icons/about.png"), "À propos", self.iface.mainWindow() ) self.openAboutAction.triggered.connect(self.open_about_dialog) self.toolbar.addAction(self.openAboutAction) # Create action for "Parcelle information" self.identifyParcelleAction = QAction( QIcon(plugin_dir +"/icons/toolbar/get-parcelle-info.png"), "Infos parcelle", self.iface.mainWindow() ) self.identifyParcelleAction.setCheckable(True) self.identifyParcelleAction.triggered.connect( self.setIndentifyParcelleTool ) self.toolbar.addAction( self.identifyParcelleAction ) self.setActionsExclusive() # Display About window on first use s = QSettings() firstUse = s.value("cadastre/isFirstUse" , 1, type=int) if firstUse == 1: s.setValue("cadastre/isFirstUse", 0) self.open_about_dialog() # Display some messages depending on version number mConfig = configparser.ConfigParser() metadataFile = plugin_dir + "/metadata.txt" mConfig.read( metadataFile, encoding='utf-8' ) self.mConfig = mConfig myVersion = mConfig.get('general', 'version').replace('.', '_') myVersionMsg = s.value("cadastre/version_%s" % myVersion , 1, type=int) if myVersionMsg == 1: s.setValue("cadastre/version_%s" % myVersion , 0) self.open_message_dialog() # Project load or create : refresh search and identify tool self.iface.projectRead.connect(self.onProjectRead) self.iface.newProjectCreated.connect(self.onNewProjectCreated) # Delete layers from table when deleted from registry lr = QgsProject.instance() lr.layersRemoved.connect( self.checkIdentifyParcelleTool ) def open_import_dialog(self): ''' Import dialog ''' dialog = cadastre_import_dialog(self.iface) dialog.exec_() def open_load_dialog(self): ''' Load dialog ''' dialog = cadastre_load_dialog( self.iface, self.cadastre_search_dialog ) dialog.exec_() def toggle_search_dialog(self): ''' Search dock widget ''' if self.cadastre_search_dialog.isVisible(): self.cadastre_search_dialog.hide() else: self.cadastre_search_dialog.show() def export_view(self): ''' Export current view to PDF ''' # Load template from file s = QSettings() f = s.value("cadastre/composerTemplateFile", '', type=str) if not os.path.exists(f): f = os.path.join(str(Path(__file__).resolve().parent), 'composers', 'paysage_a4.qpt') s.setValue("cadastre/composerTemplateFile", f) QApplication.setOverrideCursor(Qt.WaitCursor) template_content = None with open(f, 'rt', encoding="utf-8") as ff: template_content = ff.read() if not template_content: return d = QDomDocument() d.setContent(template_content) c = QgsPrintLayout(QgsProject.instance()) c.loadFromTemplate(d, QgsReadWriteContext() ) # Set scale and extent cm=c.referenceMap() canvas = self.iface.mapCanvas() extent = canvas.extent() scale = canvas.scale() if extent: cm.zoomToExtent(extent) if scale: cm.setScale(scale) # Export tempDir = s.value("cadastre/tempDir", '%s' % tempfile.gettempdir(), type=str) self.targetDir = tempfile.mkdtemp('', 'cad_export_', tempDir) temp = int(time()*100) temppath = os.path.join(tempDir, 'export_cadastre_%s.pdf' % temp) exporter = QgsLayoutExporter(c) exportersettings = QgsLayoutExporter.PdfExportSettings() exportersettings.dpi = 300 exportersettings.forceVectorOutput = True exportersettings.rasterizeWholeImage = False #rasterizeWholeImage = false exporter.exportToPdf(temppath, exportersettings ) QApplication.restoreOverrideCursor() if os.path.exists(temppath): cadastre_common.openFile(temppath) def open_option_dialog(self): ''' Config dialog ''' dialog = cadastre_option_dialog(self.iface) dialog.exec_() def open_about_dialog(self): ''' About dialog ''' dialog = cadastre_about_dialog(self.iface) dialog.exec_() def setActionsExclusive(self): # Build an action list from QGIS navigation toolbar actionList = self.iface.mapNavToolToolBar().actions() # Add actions from QGIS attributes toolbar (handling QWidgetActions) tmpActionList = self.iface.attributesToolBar().actions() for action in tmpActionList: if isinstance(action, QWidgetAction): actionList.extend( action.defaultWidget().actions() ) else: actionList.append( action ) # ... add other toolbars' action lists... # Build a group with actions from actionList and add your own action group = QActionGroup( self.iface.mainWindow() ) group.setExclusive(True) for action in actionList: group.addAction( action ) group.addAction( self.identifyParcelleAction ) def checkIdentifyParcelleTool(self, layerIds=None): ''' When layers are removed from the project Check if the layer Parcelle remains If not deactivate Identify parcelle tool ''' # Find parcelle layer parcelleLayer = None try: from .cadastre_dialogs import cadastre_common parcelleLayer = cadastre_common.getLayerFromLegendByTableProps('parcelle_info') except: parcelleLayer = None if not parcelleLayer: self.identifyParcelleAction.setChecked(False) self.iface.actionPan().trigger() return def setIndentifyParcelleTool(self): ''' Activite the identify tool for the layer geo_parcelle ''' # Find parcelle layer parcelleLayer = cadastre_common.getLayerFromLegendByTableProps('parcelle_info') if not parcelleLayer: QMessageBox.warning( self.cadastre_search_dialog, "Cadastre", "La couche de parcelles n'a pas été trouvée dans le projet" ) self.identifyParcelleAction.setChecked(False) self.iface.actionPan().trigger() return self.identyParcelleTool = IdentifyParcelle( self.mapCanvas, parcelleLayer ) self.identyParcelleTool.cadastreGeomIdentified.connect(self.getParcelleInfo) # The activate identify tool self.mapCanvas.setMapTool(self.identyParcelleTool) def getParcelleInfo(self, layer, feature): ''' Return information of the identified parcelle ''' parcelleDialog = cadastre_parcelle_dialog( self.iface, layer, feature, self.cadastre_search_dialog ) parcelleDialog.show() def onProjectRead(self): ''' Refresh search dialog when new data has been loaded ''' if self.cadastre_search_dialog: self.cadastre_search_dialog.checkMajicContent() self.cadastre_search_dialog.clearComboboxes() self.cadastre_search_dialog.setupSearchCombobox('commune', None, 'sql') self.cadastre_search_dialog.setupSearchCombobox('section', None, 'sql') self.checkIdentifyParcelleTool() def onNewProjectCreated(self): ''' Refresh search dialog when new data has been loaded ''' self.checkIdentifyParcelleTool() if self.cadastre_search_dialog: self.cadastre_search_dialog.checkMajicContent() self.cadastre_search_dialog.clearComboboxes() def open_help(self): '''Opens the html help file content with default browser''' #~ localHelpUrl = "https://github.com/3liz/QgisCadastrePlugin/blob/master/doc/index.rst" localHelpUrl = os.path.join(str(Path(__file__).resolve().parent), 'doc', 'index.html') QDesktopServices.openUrl( QUrl(localHelpUrl) ) def open_message_dialog(self): ''' Display a message to the user ''' versionMessages = { '1.1.0': [ [ 'Compatibilité avec QGIS 2.6', 'La compatibilité n\'est pas assurée à 100 % avec la dernière version 2.6 de QGIS, notamment pour la création d\'une base Spatialite vide. Vous pouvez utiliser les outils de QGIS pour le faire.' ] , [ 'Lien entre les parcelles EDIGEO et MAJIC', 'Pour cette nouvelle version du plugin, la structure de la base de données a été légèrement modifiée. Pour pouvoir utiliser les fonctions du plugin Cadastre, vous devez donc impérativement <b>réimporter les données dans une base vide</b>' ] , [ 'Validation des géométries', 'Certaines données EDIGEO contiennent des géométries invalides (polygones croisés dit "papillons", polygones non fermés, etc.). Cette version utilise une fonction de PostGIS qui tente de corriger ces invalidités. Il faut impérativement <b>utiliser une version récente de PostGIS</b> : 2.0.4 minimum pour la version 2, ou les version ultérieures (2.1 par exemple)' ] ] , '1.4.0': [ [ 'Modification de la structure', 'Pour cette nouvelle version 1.4.0 du plugin, la structure de la base de données a été légèrement modifiée par rapport à la 1.4.0. Pour pouvoir utiliser les fonctions du plugin Cadastre, vous devez donc impérativement <b>réimporter les données dans une base vide</b>. Les changements concernent les identifiants des tables parcelle, geo_parcelle, commune, local00, local10, pev, pevexoneration, pevtaxation, pevprincipale, pevprofessionnelle, pevdependances, ainsi que la création d\'une table parcelle_info pour consolider EDIGEO et MAJIC.' ] ] } mConfig = self.mConfig version = mConfig.get('general', 'version') changelog = mConfig.get('general', 'changelog') message = '<h2>Version %s - notes concernant cette version</h2>' % version if version in versionMessages: message+='<ul>' for item in versionMessages[version]: message+='<li><b>%s</b> - %s</li>' % (item[0], item[1]) message+='</ul>' message+= '<h3>Changelog</h3>' message+= '<p>' i = 0 for item in changelog.split('*'): if i == 0: message+= '<b>%s</b><ul>' % item else: message+= '<li>%s</li>' % item i+=1 message+='</ul>' message+= '</p>' dialog = cadastre_message_dialog(self.iface, message) dialog.exec_() def unload(self): self.iface.removePluginMenu("&Cadastre", self.import_action) self.iface.removePluginMenu("&Cadastre", self.load_action) self.iface.removePluginMenu("&Cadastre", self.search_action) self.iface.removePluginMenu("&Cadastre", self.export_action) self.iface.removePluginMenu("&Cadastre", self.option_action) self.iface.removePluginMenu("&Cadastre", self.about_action) self.iface.removePluginMenu("&Cadastre", self.version_action) self.iface.removePluginMenu("&Cadastre", self.help_action) self.iface.mainWindow().removeToolBar(self.toolbar) if self.cadastre_search_dialog: self.iface.removeDockWidget(self.cadastre_search_dialog) # Remove processing provider QgsApplication.processingRegistry().removeProvider(self.provider)
class GeoGigPlugin(object): def __init__(self, iface): self.iface = iface config.iface = iface readSettings() config.initConfigParams() layers = list(QgsMapLayerRegistry.instance().mapLayers().values()) for layer in layers: trackLayer(layer) try: from qgistester.tests import addTestModule from geogig.tests import testplugin addTestModule(testplugin, "GeoGig Light") except Exception as e: pass QSettings().setValue("/qgis/walForSqlite3", False) def unload(self): navigatorInstance.setVisible(False) try: QgsMapLayerRegistry.instance().layerWasAdded.disconnect(trackLayer) QgsMapLayerRegistry.instance().layerRemoved.disconnect(layerRemoved) except: pass self.menu.deleteLater() self.toolButton.deleteLater() self.iface.removePluginMenu("&GeoGig", self.explorerAction) self.iface.removePluginMenu("&GeoGig", self.toolAction) layers = list(QgsMapLayerRegistry.instance().mapLayers().values()) for layer in layers: removeLayerActions(layer) removeNonexistentTrackedLayers() removeTempFolder() try: from qgistester.tests import removeTestModule from geogig.tests import testplugin removeTestModule(testplugin, "GeoGig Light") except Exception as e: pass try: from lessons import removeLessonsFolder removeLessonsFolder(folder, "geogig") except: pass removeHelpMenu("GeoGig") removeAboutMenu("GeoGig") removeSettingsMenu("GeoGig") def initGui(self): readTrackedLayers() QgsMapLayerRegistry.instance().layerWasAdded.connect(trackLayer) QgsMapLayerRegistry.instance().layerRemoved.connect(layerRemoved) icon = QIcon(os.path.dirname(__file__) + "/ui/resources/geogig.png") self.explorerAction = navigatorInstance.toggleViewAction() self.explorerAction.setIcon(icon) self.explorerAction.setText("GeoGig Navigator") icon = QIcon(os.path.dirname(__file__) + "/ui/resources/identify.png") self.toolAction = QAction(icon, "GeoGig Feature Info Tool", self.iface.mainWindow()) self.toolAction.setCheckable(True) self.toolAction.triggered.connect(self.setTool) self.menu = QMenu(self.iface.mainWindow()) self.menu.setTitle("GeoGig") self.menu.addAction(self.explorerAction) self.menu.addAction(self.toolAction) bar = self.iface.layerToolBar() self.toolButton = QToolButton() self.toolButton.setMenu(self.menu) self.toolButton.setPopupMode(QToolButton.MenuButtonPopup) self.toolButton.setDefaultAction(self.explorerAction) bar.addWidget(self.toolButton) self.iface.addPluginToMenu("&GeoGig", self.explorerAction) self.iface.addPluginToMenu("&GeoGig", self.toolAction) addSettingsMenu("GeoGig") addHelpMenu("GeoGig") addAboutMenu("GeoGig") self.mapTool = MapToolGeoGigInfo(self.iface.mapCanvas()) #This crashes QGIS, so we comment it out until finding a solution #self.mapTool.setAction(self.toolAction) self.iface.addDockWidget(Qt.RightDockWidgetArea, navigatorInstance) try: from lessons import addLessonsFolder, addGroup folder = os.path.join(os.path.dirname(__file__), "_lessons") addLessonsFolder(folder, "geogig") group_description = os.path.join(folder, "group.md") addGroup("GeoGig lessons", group_description) except Exception as e: pass def setWarning(self, msg): QMessageBox.warning(None, 'Could not complete GeoGig command', msg, QMessageBox.Ok) def setTool(self): self.toolAction.setChecked(True) self.iface.mapCanvas().setMapTool(self.mapTool)
class OpenlayersPlugin: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # Keep a reference to all OL layers to avoid GC self._ol_layers = [] # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, "i18n", "openlayers_{}.qm".format(locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) self._olLayerTypeRegistry = WebLayerTypeRegistry(self) self.olOverview = OLOverview(iface, self._olLayerTypeRegistry) self.dlgAbout = AboutDialog() self.pluginLayerRegistry = QgsPluginLayerRegistry() def initGui(self): self._olMenu = QMenu("OpenLayers plugin") self._olMenu.setIcon(QIcon(":/plugins/openlayers/openlayers.png")) # Overview self.overviewAddAction = QAction(QApplication.translate( "OpenlayersPlugin", "OpenLayers Overview"), self.iface.mainWindow()) self.overviewAddAction.setCheckable(True) self.overviewAddAction.setChecked(False) self.overviewAddAction.toggled.connect(self.olOverview.setVisible) self._olMenu.addAction(self.overviewAddAction) self._actionAbout = QAction("Terms of Service / About", self.iface.mainWindow()) self._actionAbout.triggered.connect(self.dlgAbout.show) self._olMenu.addAction(self._actionAbout) self.dlgAbout.finished.connect(self._publicationInfoClosed) self._olLayerTypeRegistry.register(OlGooglePhysicalLayer()) self._olLayerTypeRegistry.register(OlGoogleStreetsLayer()) self._olLayerTypeRegistry.register(OlGoogleHybridLayer()) self._olLayerTypeRegistry.register(OlGoogleSatelliteLayer()) self._olLayerTypeRegistry.register(OlOpenStreetMapLayer()) self._olLayerTypeRegistry.register(OlOpenCycleMapLayer()) self._olLayerTypeRegistry.register(OlOCMLandscapeLayer()) self._olLayerTypeRegistry.register(OlOCMPublicTransportLayer()) # ID 8-10 was Yahoo self._olLayerTypeRegistry.register(OlOSMHumanitarianDataModelLayer()) self._olLayerTypeRegistry.register(OlOCMOutdoorstLayer()) self._olLayerTypeRegistry.register(OlOCMTransportDarkLayer()) self._olLayerTypeRegistry.register(OlBingRoadLayer()) self._olLayerTypeRegistry.register(OlBingAerialLayer()) self._olLayerTypeRegistry.register(OlBingAerialLabelledLayer()) # Order from here on is free. Layers 0-14 should keep order for # compatibility with OL Plugin < 2.3 self._olLayerTypeRegistry.register(OlOCMSpinalMapLayer()) self._olLayerTypeRegistry.register(OlOCMPioneerLayer()) self._olLayerTypeRegistry.register(OlOCMMobileAtlasLayer()) self._olLayerTypeRegistry.register(OlOCMNeighbourhoodLayer()) self._olLayerTypeRegistry.register(OlOSMStamenTonerLayer()) self._olLayerTypeRegistry.register(OlOSMStamenTonerLiteLayer()) self._olLayerTypeRegistry.register(OlOSMStamenWatercolorLayer()) self._olLayerTypeRegistry.register(OlOSMStamenTerrainLayer()) self._olLayerTypeRegistry.register(OlAppleiPhotoMapLayer()) self._olLayerTypeRegistry.register(WikimediaLabelledLayer()) self._olLayerTypeRegistry.register(WikimediaUnLabelledLayer()) for group in self._olLayerTypeRegistry.groups(): groupMenu = group.menu() for layer in self._olLayerTypeRegistry.groupLayerTypes(group): layer.addMenuEntry(groupMenu, self.iface.mainWindow()) self._olMenu.addMenu(groupMenu) # add action for API key dialogs for action in self._olMenu.actions(): if action.text() == "Google Maps": self._actionGoogleMapsApiKey = QAction( "Set API key", self.iface.mainWindow()) self._actionGoogleMapsApiKey.triggered.connect( self.showGoogleMapsApiKeyDialog) action.menu().addAction(self._actionGoogleMapsApiKey) if action.text() == "OSM/Thunderforest": self._actionThunderforestApiKey = QAction( "Set API key", self.iface.mainWindow()) self._actionThunderforestApiKey.triggered.connect( self.showThunderforestApiKeyDialog) action.menu().addAction(self._actionThunderforestApiKey) # Create Web menu, if it doesn't exist yet self.iface.addPluginToWebMenu("_tmp", self._actionAbout) self._menu = self.iface.webMenu() self._menu.addMenu(self._olMenu) self.iface.removePluginWebMenu("_tmp", self._actionAbout) # Register plugin layer type self.pluginLayerType = OpenlayersPluginLayerType( self.iface, self.setReferenceLayer, self._olLayerTypeRegistry) self.pluginLayerRegistry.addPluginLayerType( self.pluginLayerType) QgsProject.instance().readProject.connect(self.projectLoaded) QgsProject.instance().projectSaved.connect(self.projectSaved) def unload(self): self.iface.webMenu().removeAction(self._olMenu.menuAction()) self.olOverview.setVisible(False) del self.olOverview # Unregister plugin layer type self.pluginLayerRegistry.removePluginLayerType( OpenlayersLayer.LAYER_TYPE) QgsProject.instance().readProject.disconnect(self.projectLoaded) QgsProject.instance().projectSaved.disconnect(self.projectSaved) def addLayer(self, layerType): if layerType.hasXYZUrl(): # create XYZ layer layer, url = self.createXYZLayer(layerType, layerType.displayName) else: # create OpenlayersLayer layer = OpenlayersLayer(self.iface, self._olLayerTypeRegistry) layer.setName(layerType.displayName) layer.setLayerType(layerType) if layer.isValid(): coordRefSys = layerType.coordRefSys(self.canvasCrs()) self.setMapCrs(coordRefSys) QgsProject.instance().addMapLayer(layer) # store xyz config into qgis settings if layerType.hasXYZUrl(): settings = QSettings() settings.beginGroup('qgis/connections-xyz') settings.setValue("%s/authcfg" % (layer.name()), '') settings.setValue("%s/password" % (layer.name()), '') settings.setValue("%s/referer" % (layer.name()), '') settings.setValue("%s/url" % (layer.name()), url) settings.setValue("%s/username" % (layer.name()), '') # specify max/min or else only a picture of the map is saved # in settings settings.setValue("%s/zmax" % (layer.name()), '18') settings.setValue("%s/zmin" % (layer.name()), '0') settings.endGroup() # reload connections to update Browser Panel content self.iface.reloadConnections() self._ol_layers += [layer] # last added layer is new reference self.setReferenceLayer(layer) if not layerType.hasXYZUrl(): msg = "Printing and rotating of Javascript API " \ "based layers is currently not supported!" self.iface.messageBar().pushMessage( "OpenLayers Plugin", msg, level=Qgis.MessageLevel(1), duration=5) def setReferenceLayer(self, layer): self.layer = layer def removeLayer(self, layerId): if self.layer is not None: if self.layer.id() == layerId: self.layer = None # TODO: switch to next available OpenLayers layer? def canvasCrs(self): mapCanvas = self.iface.mapCanvas() crs = mapCanvas.mapSettings().destinationCrs() return crs def setMapCrs(self, coordRefSys): mapCanvas = self.iface.mapCanvas() # On the fly canvasCrs = self.canvasCrs() if canvasCrs != coordRefSys: coordTrans = QgsCoordinateTransform(canvasCrs, coordRefSys, QgsProject.instance()) extMap = mapCanvas.extent() extMap = coordTrans.transform( extMap, QgsCoordinateTransform.ForwardTransform) mapCanvas.setDestinationCrs(coordRefSys) mapCanvas.freeze(False) mapCanvas.setExtent(extMap) def projectLoaded(self): # replace old OpenlayersLayer with XYZ layer(OL plugin <= 1.3.6) rootGroup = self.iface.layerTreeView().layerTreeModel().rootGroup() for layer in QgsProject.instance().mapLayers().values(): if layer.type() == QgsMapLayer.PluginLayer and layer.pluginLayerType() == OpenlayersLayer.LAYER_TYPE: if layer.layerType.hasXYZUrl(): # replace layer xyzLayer, url = self.createXYZLayer(layer.layerType, layer.name()) if xyzLayer.isValid(): self.replaceLayer(rootGroup, layer, xyzLayer) def _hasOlLayer(self): for layer in QgsProject.instance().mapLayers().values(): if layer.customProperty('ol_layer_type'): return True return False def _publicationInfo(self): cloud_info_off = QSettings().value("Plugin-OpenLayers/cloud_info_off", defaultValue=False, type=bool) day = 3600*24 now = time.time() lastInfo = QSettings().value("Plugin-OpenLayers/cloud_info_ts", defaultValue=0.0, type=float) if lastInfo == 0.0: lastInfo = now-20*day # Show first time after 10 days QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", lastInfo) days = (now-lastInfo)/day if days >= 30 and not cloud_info_off: self.dlgAbout.tabWidget.setCurrentWidget( self.dlgAbout.tab_publishing) self.dlgAbout.show() QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", now) def _publicationInfoClosed(self): QSettings().setValue("Plugin-OpenLayers/cloud_info_off", self.dlgAbout.cb_publishing.isChecked()) def projectSaved(self): if self._hasOlLayer(): self._publicationInfo() def createXYZLayer(self, layerType, name): # create XYZ layer with tms url as uri provider = 'wms' url = "type=xyz&url=" + layerType.xyzUrlConfig() layer = QgsRasterLayer(url, name, provider, QgsRasterLayer.LayerOptions()) layer.setCustomProperty('ol_layer_type', layerType.layerTypeName) return layer, layerType.xyzUrlConfig() def replaceLayer(self, group, oldLayer, newLayer): index = 0 for child in group.children(): if QgsLayerTree.isLayer(child): if child.layerId() == oldLayer.id(): # insert new layer QgsProject.instance().addMapLayer(newLayer, False) newLayerNode = group.insertLayer(index, newLayer) newLayerNode.setVisible(child.isVisible()) # remove old layer QgsProject.instance().removeMapLayer( oldLayer.id()) msg = "Updated layer '%s' from old \ OpenLayers Plugin version" % newLayer.name() self.iface.messageBar().pushMessage( "OpenLayers Plugin", msg, level=Qgis.MessageLevel(0)) QgsMessageLog.logMessage( msg, "OpenLayers Plugin", QgsMessageLog.INFO) # layer replaced return True else: if self.replaceLayer(child, oldLayer, newLayer): # layer replaced in child group return True index += 1 # layer not in this group return False def showGoogleMapsApiKeyDialog(self): apiKey = QSettings().value("Plugin-OpenLayers/googleMapsApiKey") newApiKey, ok = QInputDialog.getText( self.iface.mainWindow(), "API key", "Enter your Google Maps API key", QLineEdit.Normal, apiKey) if ok: QSettings().setValue("Plugin-OpenLayers/googleMapsApiKey", newApiKey) def showThunderforestApiKeyDialog(self): apiKey = QSettings().value("Plugin-OpenLayers/thunderforestApiKey") newApiKey, ok = QInputDialog.getText( self.iface.mainWindow(), "API key", "Enter your API key (<a href=\"https://thunderforest.com/pricing/\">https://thunderforest.com</a>)", QLineEdit.Normal, apiKey) if ok: QSettings().setValue("Plugin-OpenLayers/thunderforestApiKey", newApiKey)
class LatLonTools: digitizerDialog = None def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.crossRb = QgsRubberBand(self.canvas, QgsWkbTypes.LineGeometry) self.crossRb.setColor(Qt.red) self.provider = LatLonToolsProvider() self.toolbar = self.iface.addToolBar('Lat Lon Tools Toolbar') self.toolbar.setObjectName('LatLonToolsToolbar') def initGui(self): '''Initialize Lot Lon Tools GUI.''' # Initialize the Settings Dialog box self.settingsDialog = SettingsWidget(self, self.iface, self.iface.mainWindow()) self.mapTool = CopyLatLonTool(self.settingsDialog, self.iface) self.showMapTool = ShowOnMapTool(self.iface) # Add Interface for Coordinate Capturing icon = QIcon(os.path.dirname(__file__) + "/images/copyicon.png") self.copyAction = QAction(icon, "Copy Latitude, Longitude", self.iface.mainWindow()) self.copyAction.setObjectName('latLonToolsCopy') self.copyAction.triggered.connect(self.startCapture) self.copyAction.setCheckable(True) self.toolbar.addAction(self.copyAction) self.iface.addPluginToMenu("Lat Lon Tools", self.copyAction) # Add Interface for External Map icon = QIcon(os.path.dirname(__file__) + "/images/mapicon.png") self.externMapAction = QAction(icon, "Show in External Map", self.iface.mainWindow()) self.externMapAction.setObjectName('latLonToolsExternalMap') self.externMapAction.triggered.connect(self.setShowMapTool) self.externMapAction.setCheckable(True) self.toolbar.addAction(self.externMapAction) self.iface.addPluginToMenu("Lat Lon Tools", self.externMapAction) # Add Interface for Zoom to Coordinate icon = QIcon(os.path.dirname(__file__) + "/images/zoomicon.png") self.zoomToAction = QAction(icon, "Zoom To Latitude, Longitude", self.iface.mainWindow()) self.zoomToAction.setObjectName('latLonToolsZoom') self.zoomToAction.triggered.connect(self.showZoomToDialog) self.toolbar.addAction(self.zoomToAction) self.iface.addPluginToMenu('Lat Lon Tools', self.zoomToAction) self.zoomToDialog = ZoomToLatLon(self, self.iface, self.iface.mainWindow()) self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.zoomToDialog) self.zoomToDialog.hide() # Add Interface for Multi point zoom icon = QIcon(os.path.dirname(__file__) + '/images/multizoom.png') self.multiZoomToAction = QAction(icon, "Multi-location Zoom", self.iface.mainWindow()) self.multiZoomToAction.setObjectName('latLonToolsMultiZoom') self.multiZoomToAction.triggered.connect(self.multiZoomTo) self.toolbar.addAction(self.multiZoomToAction) self.iface.addPluginToMenu('Lat Lon Tools', self.multiZoomToAction) self.multiZoomDialog = MultiZoomWidget(self, self.settingsDialog, self.iface.mainWindow()) self.multiZoomDialog.hide() self.multiZoomDialog.setFloating(True) # Create the conversions menu menu = QMenu() icon = QIcon(os.path.dirname(__file__) + '/images/field2geom.png') action = menu.addAction(icon, "Fields to point layer", self.field2geom) action.setObjectName('latLonToolsField2Geom') icon = QIcon(os.path.dirname(__file__) + '/images/geom2field.png') action = menu.addAction(icon, "Point layer to fields", self.geom2Field) action.setObjectName('latLonToolsGeom2Field') icon = QIcon(os.path.dirname(__file__) + '/images/pluscodes.png') action = menu.addAction(icon, "Plus Codes to point layer", self.PlusCodestoLayer) action.setObjectName('latLonToolsPlusCodes2Geom') action = menu.addAction(icon, "Point layer to Plus Codes", self.toPlusCodes) action.setObjectName('latLonToolsGeom2PlusCodes') icon = QIcon(os.path.dirname(__file__) + '/images/mgrs2point.png') action = menu.addAction(icon, "MGRS to point layer", self.MGRStoLayer) action.setObjectName('latLonToolsMGRS2Geom') icon = QIcon(os.path.dirname(__file__) + '/images/point2mgrs.png') action = menu.addAction(icon, "Point layer to MGRS", self.toMGRS) action.setObjectName('latLonToolsGeom2MGRS') self.conversionsAction = QAction(icon, "Conversions", self.iface.mainWindow()) self.conversionsAction.setMenu(menu) self.iface.addPluginToMenu('Lat Lon Tools', self.conversionsAction) # Add to Digitize Toolbar icon = QIcon(os.path.dirname(__file__) + '/images/latLonDigitize.png') self.digitizeAction = QAction(icon, "Lat Lon Digitize", self.iface.mainWindow()) self.digitizeAction.setObjectName('latLonToolsDigitize') self.digitizeAction.triggered.connect(self.digitizeClicked) self.digitizeAction.setEnabled(False) self.toolbar.addAction(self.digitizeAction) self.iface.addPluginToMenu('Lat Lon Tools', self.digitizeAction) # Add Interface for copying the canvas extent icon = QIcon(os.path.dirname(__file__) + "/images/copycanvas.png") self.copyCanvasAction = QAction(icon, "Copy Canvas Bounding Box", self.iface.mainWindow()) self.copyCanvasAction.setObjectName('latLonToolsCopyCanvas') self.copyCanvasAction.triggered.connect(self.copyCanvas) self.toolbar.addAction(self.copyCanvasAction) self.iface.addPluginToMenu("Lat Lon Tools", self.copyCanvasAction) # Initialize the Settings Dialog Box settingsicon = QIcon(os.path.dirname(__file__) + '/images/settings.png') self.settingsAction = QAction(settingsicon, "Settings", self.iface.mainWindow()) self.settingsAction.setObjectName('latLonToolsSettings') self.settingsAction.triggered.connect(self.settings) self.iface.addPluginToMenu('Lat Lon Tools', self.settingsAction) # Help icon = QIcon(os.path.dirname(__file__) + '/images/help.png') self.helpAction = QAction(icon, "Help", self.iface.mainWindow()) self.helpAction.setObjectName('latLonToolsHelp') self.helpAction.triggered.connect(self.help) self.iface.addPluginToMenu('Lat Lon Tools', self.helpAction) self.iface.currentLayerChanged.connect(self.currentLayerChanged) self.canvas.mapToolSet.connect(self.unsetTool) self.enableDigitizeTool() # Add the processing provider QgsApplication.processingRegistry().addProvider(self.provider) def unsetTool(self, tool): '''Uncheck the Copy Lat Lon tool''' try: if not isinstance(tool, CopyLatLonTool): self.copyAction.setChecked(False) self.multiZoomDialog.stopCapture() self.mapTool.capture4326 = False if not isinstance(tool, ShowOnMapTool): self.externMapAction.setChecked(False) except: pass def unload(self): '''Unload LatLonTools from the QGIS interface''' self.zoomToDialog.removeMarker() self.multiZoomDialog.removeMarkers() self.canvas.unsetMapTool(self.mapTool) self.canvas.unsetMapTool(self.showMapTool) self.iface.removePluginMenu('Lat Lon Tools', self.copyAction) self.iface.removePluginMenu('Lat Lon Tools', self.copyCanvasAction) self.iface.removePluginMenu('Lat Lon Tools', self.externMapAction) self.iface.removePluginMenu('Lat Lon Tools', self.zoomToAction) self.iface.removePluginMenu('Lat Lon Tools', self.multiZoomToAction) self.iface.removePluginMenu('Lat Lon Tools', self.conversionsAction) self.iface.removePluginMenu('Lat Lon Tools', self.settingsAction) self.iface.removePluginMenu('Lat Lon Tools', self.helpAction) self.iface.removePluginMenu('Lat Lon Tools', self.digitizeAction) self.iface.removeDockWidget(self.zoomToDialog) self.iface.removeDockWidget(self.multiZoomDialog) # Remove Toolbar Icons self.iface.removeToolBarIcon(self.copyAction) self.iface.removeToolBarIcon(self.copyCanvasAction) self.iface.removeToolBarIcon(self.zoomToAction) self.iface.removeToolBarIcon(self.externMapAction) self.iface.removeToolBarIcon(self.multiZoomToAction) self.iface.removeToolBarIcon(self.digitizeAction) del self.toolbar self.zoomToDialog = None self.multiZoomDialog = None self.settingsDialog = None self.showMapTool = None self.mapTool = None self.digitizerDialog = None QgsApplication.processingRegistry().removeProvider(self.provider) def startCapture(self): '''Set the focus of the copy coordinate tool and check it''' self.copyAction.setChecked(True) self.canvas.setMapTool(self.mapTool) def copyCanvas(self): extent = self.iface.mapCanvas().extent() canvasCrs = self.canvas.mapSettings().destinationCrs() if settings.bBoxCrs == 0 and canvasCrs != epsg4326: transform = QgsCoordinateTransform(canvasCrs, epsg4326, QgsProject.instance()) p1x, p1y = transform.transform(float(extent.xMinimum()), float(extent.yMinimum())) p2x, p2y = transform.transform(float(extent.xMaximum()), float(extent.yMaximum())) extent.set(p1x, p1y, p2x, p2y) delim = settings.bBoxDelimiter prefix = settings.bBoxPrefix suffix = settings.bBoxSuffix precision = settings.bBoxDigits outStr = '' minX = extent.xMinimum() minY = extent.yMinimum() maxX = extent.xMaximum() maxY = extent.yMaximum() if settings.bBoxFormat == 0: # minX,minY,maxX,maxY - using the delimiter outStr = '{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}'.format( minX, delim, minY, delim, maxX, delim, maxY, prec=precision) elif settings.bBoxFormat == 1: # minX,maxX,minY,maxY - Using the selected delimiter' outStr = '{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}'.format( minX, delim, maxX, delim, minY, delim, maxY, prec=precision) elif settings.bBoxFormat == 2: # x1 y1,x2 y2,x3 y3,x4 y4,x1 y1 - Polygon format outStr = '{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f}'.format( minX, minY, minX, maxY, maxX, maxY, maxX, minY, minX, minY, prec=precision) elif settings.bBoxFormat == 3: # x1,y1 x2,y2 x3,y3 x4,y4 x1,y1 - Polygon format outStr = '{:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f}'.format( minX, minY, minX, maxY, maxX, maxY, maxX, minY, minX, minY, prec=precision) elif settings.bBoxFormat == 4: # WKT Polygon outStr = extent.asWktPolygon() elif settings.bBoxFormat == 5: # bbox: [minX, minY, maxX, maxY] - MapProxy outStr = 'bbox: [{}, {}, {}, {}]'.format( minX, minY, maxX, maxY) elif settings.bBoxFormat == 6: # bbox: [minX, minY, maxX, maxY] - MapProxy outStr = 'bbox={},{},{},{}'.format( minX, minY, maxX, maxY) outStr = '{}{}{}'.format(prefix, outStr, suffix) clipboard = QApplication.clipboard() clipboard.setText(outStr) self.iface.messageBar().pushMessage("", "'{}' copied to the clipboard".format(outStr), level=Qgis.Info, duration=4) def setShowMapTool(self): '''Set the focus of the external map tool and check it''' self.externMapAction.setChecked(True) self.canvas.setMapTool(self.showMapTool) def showZoomToDialog(self): '''Show the zoom to docked widget.''' self.zoomToDialog.show() def multiZoomTo(self): '''Display the Multi-zoom to dialog box''' self.multiZoomDialog.show() def field2geom(self): '''Convert layer containing a point x & y coordinate to a new point layer''' results = processing.execAlgorithmDialog('latlontools:field2geom', {}) def geom2Field(self): '''Convert layer geometry to a text string''' results = processing.execAlgorithmDialog('latlontools:geom2field', {}) def toMGRS(self): '''Display the to MGRS dialog box''' results = processing.execAlgorithmDialog('latlontools:point2mgrs', {}) def MGRStoLayer(self): '''Display the to MGRS dialog box''' results = processing.execAlgorithmDialog('latlontools:mgrs2point', {}) def toPlusCodes(self): results = processing.execAlgorithmDialog('latlontools:point2pluscodes', {}) def PlusCodestoLayer(self): results = processing.execAlgorithmDialog('latlontools:pluscodes2point', {}) def settings(self): '''Show the settings dialog box''' self.settingsDialog.show() def help(self): '''Display a help page''' url = QUrl.fromLocalFile(os.path.dirname(__file__) + "/index.html").toString() webbrowser.open(url, new=2) def settingsChanged(self): # Settings may have changed so we need to make sure the zoomToDialog window is configured properly self.zoomToDialog.configure() self.multiZoomDialog.settingsChanged() def zoomTo(self, srcCrs, lat, lon): canvasCrs = self.canvas.mapSettings().destinationCrs() transform = QgsCoordinateTransform(srcCrs, canvasCrs, QgsProject.instance()) x, y = transform.transform(float(lon), float(lat)) rect = QgsRectangle(x, y, x, y) self.canvas.setExtent(rect) pt = QgsPointXY(x, y) self.highlight(pt) self.canvas.refresh() return pt def highlight(self, point): currExt = self.canvas.extent() leftPt = QgsPoint(currExt.xMinimum(), point.y()) rightPt = QgsPoint(currExt.xMaximum(), point.y()) topPt = QgsPoint(point.x(), currExt.yMaximum()) bottomPt = QgsPoint(point.x(), currExt.yMinimum()) horizLine = QgsGeometry.fromPolyline( [ leftPt , rightPt ] ) vertLine = QgsGeometry.fromPolyline( [ topPt , bottomPt ] ) self.crossRb.reset(QgsWkbTypes.LineGeometry) self.crossRb.addGeometry(horizLine, None) self.crossRb.addGeometry(vertLine, None) QTimer.singleShot(700, self.resetRubberbands) def resetRubberbands(self): self.crossRb.reset() def digitizeClicked(self): if self.digitizerDialog == None: from .digitizer import DigitizerWidget self.digitizerDialog = DigitizerWidget(self, self.iface, self.iface.mainWindow()) self.digitizerDialog.show() def currentLayerChanged(self): layer = self.iface.activeLayer() if layer != None: try: layer.editingStarted.disconnect(self.layerEditingChanged) except: pass try: layer.editingStopped.disconnect(self.layerEditingChanged) except: pass if isinstance(layer, QgsVectorLayer): layer.editingStarted.connect(self.layerEditingChanged) layer.editingStopped.connect(self.layerEditingChanged) self.enableDigitizeTool() def layerEditingChanged(self): self.enableDigitizeTool() def enableDigitizeTool(self): self.digitizeAction.setEnabled(False) layer = self.iface.activeLayer() if layer != None and isinstance(layer, QgsVectorLayer) and (layer.geometryType() == QgsWkbTypes.PointGeometry) and layer.isEditable(): self.digitizeAction.setEnabled(True) else: if self.digitizerDialog != None: self.digitizerDialog.close()
class OpenlayersPlugin: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # Keep a reference to all OL layers to avoid GC self._ol_layers = [] # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, "i18n", "openlayers_{}.qm".format(locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self._olLayerTypeRegistry = WebLayerTypeRegistry(self) self.olOverview = OLOverview(iface, self._olLayerTypeRegistry) self.dlgAbout = AboutDialog() self.pluginLayerRegistry = QgsPluginLayerRegistry() def initGui(self): self._olMenu = QMenu("TMS for Korea") self._olMenu.setIcon(QIcon(":/plugins/openlayers/openlayers.png")) # Overview self.overviewAddAction = QAction(QApplication.translate("OpenlayersPlugin", "OpenLayers Overview"), self.iface.mainWindow()) self.overviewAddAction.setCheckable(True) self.overviewAddAction.setChecked(False) self.overviewAddAction.toggled.connect(self.olOverview.setVisible) self._olMenu.addAction(self.overviewAddAction) self._actionAbout = QAction(QApplication.translate("dlgAbout", "About OpenLayers Plugin"), self.iface.mainWindow()) self._actionAbout.triggered.connect(self.dlgAbout.show) self._olMenu.addAction(self._actionAbout) self.dlgAbout.finished.connect(self._publicationInfoClosed) # Daum self._olLayerTypeRegistry.register(OlDaumStreetLayer()) self._olLayerTypeRegistry.register(OlDaumHybridLayer()) self._olLayerTypeRegistry.register(OlDaumSatelliteLayer()) self._olLayerTypeRegistry.register(OlDaumPhysicalLayer()) self._olLayerTypeRegistry.register(OlDaumCadstralLayer()) # Naver self._olLayerTypeRegistry.register(OlNaverStreetLayer()) self._olLayerTypeRegistry.register(OlNaverHybridLayer()) self._olLayerTypeRegistry.register(OlNaverSatelliteLayer()) self._olLayerTypeRegistry.register(OlNaverPhysicalLayer()) self._olLayerTypeRegistry.register(OlNaverCadastralLayer()) # VWorld self._olLayerTypeRegistry.register(OlVWorldStreetLayer()) self._olLayerTypeRegistry.register(OlVWorldSatelliteLayer()) self._olLayerTypeRegistry.register(OlVWorldGrayLayer()) self._olLayerTypeRegistry.register(OlVWorldHybridLayer()) # NGII self._olLayerTypeRegistry.register(OlNgiiStreetLayer()) self._olLayerTypeRegistry.register(OlNgiiBlankLayer()) self._olLayerTypeRegistry.register(OlNgiiEnglishLayer()) self._olLayerTypeRegistry.register(OlNgiiHighDensityLayer()) self._olLayerTypeRegistry.register(OlNgiiColorBlindLayer()) # Mango #self._olLayerTypeRegistry.register(OlMangoBaseMapLayer()) #self._olLayerTypeRegistry.register(OlMangoBaseMapGrayLayer()) #self._olLayerTypeRegistry.register(OlMangoHiDPIMapLayer()) #self._olLayerTypeRegistry.register(OlMangoHiDPIMapGrayLayer()) for group in self._olLayerTypeRegistry.groups(): groupMenu = group.menu() for layer in self._olLayerTypeRegistry.groupLayerTypes(group): layer.addMenuEntry(groupMenu, self.iface.mainWindow()) self._olMenu.addMenu(groupMenu) # Create Web menu, if it doesn't exist yet self.iface.addPluginToWebMenu("_tmp", self._actionAbout) self._menu = self.iface.webMenu() self._menu.addMenu(self._olMenu) self.iface.removePluginWebMenu("_tmp", self._actionAbout) # Register plugin layer type self.pluginLayerType = OpenlayersPluginLayerType( self.iface, self.setReferenceLayer, self._olLayerTypeRegistry) self.pluginLayerRegistry.addPluginLayerType( self.pluginLayerType) QgsProject.instance().readProject.connect(self.projectLoaded) QgsProject.instance().projectSaved.connect(self.projectSaved) def unload(self): self.iface.webMenu().removeAction(self._olMenu.menuAction()) self.olOverview.setVisible(False) del self.olOverview # Unregister plugin layer type self.pluginLayerRegistry.removePluginLayerType( OpenlayersLayer.LAYER_TYPE) QgsProject.instance().readProject.disconnect(self.projectLoaded) QgsProject.instance().projectSaved.disconnect(self.projectSaved) def addLayer(self, layerType): if layerType.hasXYZUrl(): # create XYZ layer layer, url = self.createXYZLayer(layerType, layerType.displayName) else: # create OpenlayersLayer layer = OpenlayersLayer(self.iface, self._olLayerTypeRegistry) layer.setName(layerType.displayName) layer.setLayerType(layerType) if layer.isValid(): coordRefSys = layerType.coordRefSys(self.canvasCrs()) self.setMapCrs(coordRefSys) QgsProject.instance().addMapLayer(layer) # store xyz config into qgis settings if layerType.hasXYZUrl(): settings = QSettings() settings.beginGroup('qgis/connections-xyz') settings.setValue("%s/authcfg" % (layer.name()), '') settings.setValue("%s/password" % (layer.name()), '') settings.setValue("%s/referer" % (layer.name()), '') settings.setValue("%s/url" % (layer.name()), url) settings.setValue("%s/username" % (layer.name()), '') # specify max/min or else only a picture of the map is saved # in settings settings.setValue("%s/zmax" % (layer.name()), '18') settings.setValue("%s/zmin" % (layer.name()), '0') settings.endGroup() # reload connections to update Browser Panel content self.iface.reloadConnections() self._ol_layers += [layer] # last added layer is new reference self.setReferenceLayer(layer) if not layerType.hasXYZUrl(): msg = "Printing and rotating of Javascript API " \ "based layers is currently not supported!" self.iface.messageBar().pushMessage( "OpenLayers Plugin", msg, level=Qgis.MessageLevel(1), duration=5) def setReferenceLayer(self, layer): self.layer = layer def removeLayer(self, layerId): if self.layer is not None: if self.layer.id() == layerId: self.layer = None # TODO: switch to next available OpenLayers layer? def canvasCrs(self): mapCanvas = self.iface.mapCanvas() crs = mapCanvas.mapSettings().destinationCrs() return crs def setMapCrs(self, targetCRS): mapCanvas = self.iface.mapCanvas() mapExtent = mapCanvas.extent() sourceCRS = self.canvasCrs() QgsProject.instance().setCrs(targetCRS) mapCanvas.freeze(False) try: coordTrans = QgsCoordinateTransform(sourceCRS, targetCRS, QgsProject.instance()) mapExtent = coordTrans.transform(mapExtent, QgsCoordinateTransform.ForwardTransform) mapCanvas.setExtent(mapExtent) except: pass def projectLoaded(self): # replace old OpenlayersLayer with XYZ layer(OL plugin <= 1.3.6) rootGroup = self.iface.layerTreeView().layerTreeModel().rootGroup() for layer in QgsProject.instance().mapLayers().values(): if layer.type() == QgsMapLayer.PluginLayer and layer.pluginLayerType() == OpenlayersLayer.LAYER_TYPE: if layer.layerType.hasXYZUrl(): # replace layer xyzLayer, url = self.createXYZLayer(layer.layerType, layer.name()) if xyzLayer.isValid(): self.replaceLayer(rootGroup, layer, xyzLayer) def _hasOlLayer(self): for layer in QgsProject.instance().mapLayers().values(): if layer.customProperty('ol_layer_type'): return True return False def _publicationInfo(self): cloud_info_off = QSettings().value("Plugin-OpenLayers/cloud_info_off", defaultValue=False, type=bool) day = 3600*24 now = time.time() lastInfo = QSettings().value("Plugin-OpenLayers/cloud_info_ts", defaultValue=0.0, type=float) if lastInfo == 0.0: lastInfo = now-20*day # Show first time after 10 days QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", lastInfo) days = (now-lastInfo)/day if days >= 30 and not cloud_info_off: self.dlgAbout.tabWidget.setCurrentWidget( self.dlgAbout.tab_publishing) self.dlgAbout.show() QSettings().setValue("Plugin-OpenLayers/cloud_info_ts", now) def _publicationInfoClosed(self): QSettings().setValue("Plugin-OpenLayers/cloud_info_off", self.dlgAbout.cb_publishing.isChecked()) def projectSaved(self): if self._hasOlLayer(): self._publicationInfo() def createXYZLayer(self, layerType, name): # create XYZ layer with tms url as uri provider = 'wms' url = "type=xyz&url=" + layerType.xyzUrlConfig() layer = QgsRasterLayer(url, name, provider, QgsRasterLayer.LayerOptions()) layer.setCustomProperty('ol_layer_type', layerType.layerTypeName) return layer, layerType.xyzUrlConfig() def replaceLayer(self, group, oldLayer, newLayer): index = 0 for child in group.children(): if QgsLayerTree.isLayer(child): if child.layerId() == oldLayer.id(): # insert new layer QgsProject.instance().addMapLayer(newLayer, False) newLayerNode = group.insertLayer(index, newLayer) newLayerNode.setVisible(child.isVisible()) # remove old layer QgsProject.instance().removeMapLayer( oldLayer.id()) msg = "Updated layer '%s' from old \ OpenLayers Plugin version" % newLayer.name() self.iface.messageBar().pushMessage( "OpenLayers Plugin", msg, level=Qgis.MessageLevel(0)) QgsMessageLog.logMessage( msg, "OpenLayers Plugin", QgsMessageLog.INFO) # layer replaced return True else: if self.replaceLayer(child, oldLayer, newLayer): # layer replaced in child group return True index += 1 # layer not in this group return False
class GwParentMapTool(QgsMapTool): def __init__(self, icon_path, text, toolbar, action_group, iface, settings, controller, plugin_dir): self.iface = iface self.settings = settings self.controller = controller self.plugin_dir = plugin_dir self.show_help = bool(int(self.settings.value('status/show_help', 1))) self.layer_arc = None self.layer_connec = None self.layer_gully = None self.layer_node = None self.snapper_manager = SnappingConfigManager(self.iface) self.snapper_manager.controller = controller self.canvas = iface.mapCanvas() super().__init__(self.canvas) icon = None if os.path.exists(icon_path): icon = QIcon(icon_path) self.action = None if icon is None: self.action = QAction(text, action_group) else: self.action = QAction(icon, text, action_group) self.action.setObjectName(text) self.action.setCheckable(True) self.action.triggered.connect(self.clicked_event) # Change map tool cursor self.cursor = QCursor() self.cursor.setShape(Qt.CrossCursor) # Get default cursor # noinspection PyCallingNonCallable self.std_cursor = self.parent().cursor() # Set default vertex marker color = QColor(255, 100, 255) self.vertex_marker = QgsVertexMarker(self.canvas) self.vertex_marker.setIconType(QgsVertexMarker.ICON_CIRCLE) self.vertex_marker.setColor(color) self.vertex_marker.setIconSize(15) self.vertex_marker.setPenWidth(3) # Set default rubber band color_selection = QColor(254, 178, 76, 63) self.rubber_band = QgsRubberBand(self.canvas, 2) self.rubber_band.setColor(color) self.rubber_band.setFillColor(color_selection) self.rubber_band.setWidth(1) self.reset() self.force_active_layer = True toolbar.addAction(self.action) self.setAction(self.action) def clicked_event(self): self.controller.prev_maptool = self.iface.mapCanvas().mapTool() if not (self == self.iface.mapCanvas().mapTool()): self.iface.mapCanvas().setMapTool(self) else: self.iface.mapCanvas().unsetMapTool(self) def deactivate(self): # Uncheck button self.action.setChecked(False) # Restore previous snapping self.snapper_manager.recover_snapping_options() # Enable snapping self.snapper_manager.enable_snapping(True) # Recover cursor self.canvas.setCursor(self.std_cursor) # Remove highlight self.vertex_marker.hide() def canvasMoveEvent(self, event): # Make sure active layer is always 'v_edit_node' cur_layer = self.iface.activeLayer() if cur_layer != self.layer_node and self.force_active_layer: self.iface.setActiveLayer(self.layer_node) # Hide highlight and get coordinates self.vertex_marker.hide() event_point = self.snapper_manager.get_event_point(event) # Snapping result = self.snapper_manager.snap_to_current_layer(event_point) if self.snapper_manager.result_is_valid(): self.snapper_manager.add_marker(result, self.vertex_marker) def recover_previus_maptool(self): if self.controller.prev_maptool: self.iface.mapCanvas().setMapTool(self.controller.prev_maptool) self.controller.prev_maptool = None def remove_vertex(self): """ Remove vertex_marker from canvas""" vertex_items = [i for i in self.iface.mapCanvas().scene().items() if issubclass(type(i), QgsVertexMarker)] for ver in vertex_items: if ver in self.iface.mapCanvas().scene().items(): if self.vertex_marker == ver: self.iface.mapCanvas().scene().removeItem(ver) def set_action_pan(self): """ Set action 'Pan' """ try: self.iface.actionPan().trigger() except Exception: pass def reset_rubber_band(self, geom_type="polygon"): try: if geom_type == "polygon": geom_type = QgsWkbTypes.PolygonGeometry elif geom_type == "line": geom_type = QgsWkbTypes.LineString self.rubber_band.reset(geom_type) except: pass def reset(self): self.reset_rubber_band() self.snapped_feat = None def cancel_map_tool(self): """ Executed if user press right button or escape key """ # Reset rubber band self.reset() # Deactivate map tool self.deactivate() self.set_action_pan() def remove_markers(self): """ Remove previous markers """ vertex_items = [i for i in list(self.canvas.scene().items()) if issubclass(type(i), QgsVertexMarker)] for ver in vertex_items: if ver in list(self.canvas.scene().items()): self.canvas.scene().removeItem(ver) def refresh_map_canvas(self): """ Refresh all layers present in map canvas """ self.canvas.refreshAllLayers() for layer_refresh in self.canvas.layers(): layer_refresh.triggerRepaint()
class PostNAS_Search: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join(self.plugin_dir,'i18n','PostNAS_Search_{}.qm'.format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) # Create the dialog (after translation) and keep reference self.dlg = PostNAS_SearchDialog(iface=self.iface) self.conf = PostNAS_ConfDialog(iface=self.iface) # Declare instance attributes self.actions = [] self.menu = self.tr(u'&PostNAS_Search') self.searchDockWidget = None self.searchDockWidgetArea = Qt.LeftDockWidgetArea # noinspection PyMethodMayBeStatic def tr(self, message): # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('PostNAS_Search', message) def initGui(self): # Create Conf-Action and Menuentry self.confAction = QAction("Einstellungen", self.iface.mainWindow()) self.confAction.setWhatsThis("Konfiguration der PostNAS-Suche") self.confAction.setStatusTip("Konfiguration der PostNAS-Suche") self.confAction.triggered.connect(self.showConf) if hasattr(self.iface, "addPluginToDatabaseMenu"): self.iface.addPluginToDatabaseMenu("&PostNAS-Suche", self.confAction) else: self.iface.addPluginToMenu("&PostNAS-Suche", self.confAction) self.toggleSearchAction = QAction(u"Flurstücksuche", self.iface.mainWindow()) self.toggleSearchAction.setWhatsThis(u"Starten/Schliessen der Flurstücksuche") self.toggleSearchAction.setStatusTip(u"Starten/Schliessen der Flurstücksuche") self.toggleSearchAction.triggered.connect(self.toggleWidget) if hasattr(self.iface, "addPluginToDatabaseMenu"): self.iface.addPluginToDatabaseMenu("&PostNAS-Suche", self.toggleSearchAction) else: self.iface.addPluginToMenu("&PostNAS-Suche", self.toggleSearchAction) self.fulltextindex = QAction(u"Volltextindex erstellen", self.iface.mainWindow()) self.fulltextindex.setWhatsThis(u"Erzeugt einen Volltextindex in der Datenbank um die Suche zu beschleunigen") self.fulltextindex.setStatusTip(u"Erzeugt einen Volltextindex in der Datenbank um die Suche zu beschleunigen") self.fulltextindex.triggered.connect(self.createFulltextindex) if hasattr(self.iface, "addPluginToDatabaseMenu"): self.iface.addPluginToDatabaseMenu("&PostNAS-Suche", self.fulltextindex) else: self.iface.addPluginToMenu("&PostNAS-Suche", self.fulltextindex) # Create action that will start plugin configuration self.action = QAction(QIcon(":/plugins/PostNAS_Search/search_24x24.png"),u"Flurstücksuche", self.iface.mainWindow()) self.action.setCheckable(True) # connect the action to the run method self.action.triggered.connect(self.toggleWidget) # Add toolbar button and menu item self.iface.addToolBarIcon(self.action) def toggleWidget(self, event): if self.searchDockWidget == None: self.searchDockWidget = QDockWidget(self.iface.mainWindow()) self.searchDockWidget.setWindowTitle(self.tr(u'Suche')) self.searchDockWidget.setWidget(self.dlg) self.searchDockWidget.closeEvent = self.toggleWidget self.iface.addDockWidget(self.searchDockWidgetArea, self.searchDockWidget) self.action.setChecked(True) else: self.searchDockWidgetArea = self.iface.mainWindow().dockWidgetArea(self.searchDockWidget) self.iface.removeDockWidget(self.searchDockWidget) self.searchDockWidget = None self.action.setChecked(False) def showConf(self): dlg = PostNAS_ConfDialog(self) dlg.exec_() def createFulltextindex(self): dlg = PostNAS_CreateFulltextindex(self) dlg.exec_() def unload(self): # Remove the Toolbar Icon self.iface.removeToolBarIcon(self.action) # Remove DockWidget if self.searchDockWidget != None: self.iface.removeDockWidget(self.searchDockWidget) if hasattr(self.iface, "removePluginDatabaseMenu"): self.iface.removePluginDatabaseMenu("&PostNAS-Suche", self.confAction) self.iface.removePluginDatabaseMenu("&PostNAS-Suche", self.toggleSearchAction) self.iface.removePluginDatabaseMenu("&PostNAS-Suche", self.fulltextindex) else: self.iface.removePluginMenu("&PostNAS-Suche", self.confAction) self.iface.removePluginMenu("&PostNAS-Suche", self.toggleSearchAction) self.iface.removePluginMenu("&PostNAS-Suche", self.fulltextindex) if self.confAction: self.confAction.deleteLater() self.confAction = None if self.toggleSearchAction: self.toggleSearchAction.deleteLater() self.toggleSearchAction = None if self.fulltextindex: self.fulltextindex.deleteLater() self.fulltextindex = None
def _add_child_layer(self): # Create main menu and get cursor click position main_menu = QMenu() cursor = QCursor() x = cursor.pos().x() y = cursor.pos().y() click_point = QPoint(x + 5, y + 5) # Get load layers layer_list = [] for layer in QgsProject.instance().mapLayers().values(): layer_list.append(tools_qgis.get_layer_source_table_name(layer)) body = tools_gw.create_body() json_result = tools_gw.execute_procedure('gw_fct_getaddlayervalues', body) if not json_result or json_result['status'] == 'Failed': return False dict_menu = {} for field in json_result['body']['data']['fields']: if field['context'] is not None: context = json.loads(field['context']) if 'level_1' in context and context['level_1'] not in dict_menu: menu_level_1 = main_menu.addMenu(f"{context['level_1']}") dict_menu[context['level_1']] = menu_level_1 if 'level_2' in context and f"{context['level_1']}_{context['level_2']}" not in dict_menu: menu_level_2 = dict_menu[context['level_1']].addMenu( f"{context['level_2']}") dict_menu[ f"{context['level_1']}_{context['level_2']}"] = menu_level_2 if 'level_3' in context and f"{context['level_1']}_{context['level_2']}_{context['level_3']}" not in dict_menu: menu_level_3 = dict_menu[ f"{context['level_1']}_{context['level_2']}"].addMenu( f"{context['level_3']}") dict_menu[ f"{context['level_1']}_{context['level_2']}_{context['level_3']}"] = menu_level_3 if 'level_3' in context: if f"{context['level_1']}_{context['level_2']}_{context['level_3']}_load_all" not in dict_menu: action = QAction( "Load all", dict_menu[ f"{context['level_1']}_{context['level_2']}_{context['level_3']}"], checkable=True) action.triggered.connect( partial( self._manage_load_all, fields=json_result['body']['data']['fields'], group=context['level_1'], sub_group=context['level_2'], sub_sub_group=context['level_3'])) dict_menu[ f"{context['level_1']}_{context['level_2']}_{context['level_3']}"].addAction( action) dict_menu[ f"{context['level_1']}_{context['level_2']}_{context['level_3']}_load_all"] = True action = QAction( field['layerName'], dict_menu[ f"{context['level_1']}_{context['level_2']}_{context['level_3']}"], checkable=True) dict_menu[ f"{context['level_1']}_{context['level_2']}_{context['level_3']}"].addAction( action) else: if f"{context['level_1']}_{context['level_2']}_load_all" not in dict_menu: action = QAction( "Load all", dict_menu[ f"{context['level_1']}_{context['level_2']}"], checkable=True) action.triggered.connect( partial( self._manage_load_all, fields=json_result['body']['data']['fields'], group=context['level_1'], sub_group=context['level_2'])) dict_menu[ f"{context['level_1']}_{context['level_2']}"].addAction( action) dict_menu[ f"{context['level_1']}_{context['level_2']}_load_all"] = True action = QAction( field['layerName'], dict_menu[ f"{context['level_1']}_{context['level_2']}"], checkable=True) dict_menu[ f"{context['level_1']}_{context['level_2']}"].addAction( action) if f"{field['tableName']}" in layer_list: action.setChecked(True) layer_name = field['tableName'] if field['geomField'] == "None": the_geom = None else: the_geom = field['geomField'] geom_field = field['tableId'] style_id = field['style_id'] group = context['level_1'] sub_group = context['level_2'] action.triggered.connect( partial(self._check_action_ischecked, layer_name, the_geom, geom_field, group, sub_group, style_id)) main_menu.exec_(click_point)
class MGRSCapture: def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.toolbar = self.iface.addToolBar('MGRS Toolbar') self.toolbar.setObjectName('MGRSToolbar') def initGui(self): '''Initialize Lot Lon Tools GUI.''' # Initialize the Settings Dialog box self.settingsDialog = SettingsWidget(self.iface) self.mapTool = CopyMgrsTool(self.iface) # Add Interface for Coordinate Capturing icon = QIcon(os.path.dirname(__file__) + "/images/copyMgrs.svg") self.copyAction = QAction(icon, "Copy/Display MGRS Coordinate", self.iface.mainWindow()) self.copyAction.setObjectName('mgrsCopy') self.copyAction.triggered.connect(self.startCapture) self.copyAction.setCheckable(True) self.toolbar.addAction(self.copyAction) self.iface.addPluginToMenu("MGRS", self.copyAction) # Add Interface for Zoom to Coordinate icon = QIcon(os.path.dirname(__file__) + "/images/zoomToMgrs.svg") self.zoomToAction = QAction(icon, "Zoom To MGRS Coordinate", self.iface.mainWindow()) self.zoomToAction.setObjectName('mgrsZoom') self.zoomToAction.triggered.connect(self.showZoomToDialog) self.toolbar.addAction(self.zoomToAction) self.iface.addPluginToMenu('MGRS', self.zoomToAction) self.zoomToDialog = ZoomToMgrs(self.iface, self.iface.mainWindow()) self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.zoomToDialog) self.zoomToDialog.hide() # Initialize the Settings Dialog Box settingsicon = QIcon(':/images/themes/default/mActionOptions.svg') self.settingsAction = QAction(settingsicon, "Settings", self.iface.mainWindow()) self.settingsAction.setObjectName('mgrsSettings') self.settingsAction.triggered.connect(self.settings) self.iface.addPluginToMenu('MGRS', self.settingsAction) # Help icon = QIcon(os.path.dirname(__file__) + '/images/help.svg') self.helpAction = QAction(icon, "Help", self.iface.mainWindow()) self.helpAction.setObjectName('mgrsHelp') self.helpAction.triggered.connect(self.help) self.iface.addPluginToMenu('MGRS', self.helpAction) self.canvas.mapToolSet.connect(self.resetTools) def resetTools(self, newtool, oldtool): '''Uncheck the Copy MGRS tool''' try: if oldtool is self.mapTool: self.copyAction.setChecked(False) if newtool is self.mapTool: self.copyAction.setChecked(True) except Exception: pass def unload(self): '''Unload LatLonTools from the QGIS interface''' self.zoomToDialog.removeMarker() self.canvas.unsetMapTool(self.mapTool) self.iface.removePluginMenu('MGRS', self.copyAction) self.iface.removePluginMenu('MGRS', self.zoomToAction) self.iface.removePluginMenu('MGRS', self.settingsAction) self.iface.removePluginMenu('MGRS', self.helpAction) self.iface.removeDockWidget(self.zoomToDialog) # Remove Toolbar Icons self.iface.removeToolBarIcon(self.copyAction) self.iface.removeToolBarIcon(self.zoomToAction) del self.toolbar self.zoomToDialog = None self.settingsDialog = None self.mapTool = None def startCapture(self): '''Set the focus of the copy coordinate tool''' self.canvas.setMapTool(self.mapTool) def showZoomToDialog(self): '''Show the zoom to docked widget.''' self.zoomToDialog.show() def settings(self): '''Show the settings dialog box''' self.settingsDialog.show() def help(self): '''Display a help page''' url = QUrl.fromLocalFile(os.path.dirname(__file__) + "/index.html").toString() webbrowser.open(url, new=2)
class LatLonTools: digitizerDialog = None convertCoordinateDialog = None def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.crossRb = QgsRubberBand(self.canvas, QgsWkbTypes.LineGeometry) self.crossRb.setColor(Qt.red) self.provider = LatLonToolsProvider() self.toolbar = self.iface.addToolBar('Lat Lon Tools Toolbar') self.toolbar.setObjectName('LatLonToolsToolbar') def initGui(self): '''Initialize Lot Lon Tools GUI.''' # Initialize the Settings Dialog box self.settingsDialog = SettingsWidget(self, self.iface, self.iface.mainWindow()) self.mapTool = CopyLatLonTool(self.settingsDialog, self.iface) self.showMapTool = ShowOnMapTool(self.iface) # Add Interface for Coordinate Capturing icon = QIcon(os.path.dirname(__file__) + "/images/copyicon.png") self.copyAction = QAction(icon, "Copy/Display Coordinate", self.iface.mainWindow()) self.copyAction.setObjectName('latLonToolsCopy') self.copyAction.triggered.connect(self.startCapture) self.copyAction.setCheckable(True) self.toolbar.addAction(self.copyAction) self.iface.addPluginToMenu("Lat Lon Tools", self.copyAction) # Add Interface for External Map icon = QIcon(os.path.dirname(__file__) + "/images/mapicon.png") self.externMapAction = QAction(icon, "Show in External Map", self.iface.mainWindow()) self.externMapAction.setObjectName('latLonToolsExternalMap') self.externMapAction.triggered.connect(self.setShowMapTool) self.externMapAction.setCheckable(True) self.toolbar.addAction(self.externMapAction) self.iface.addPluginToMenu("Lat Lon Tools", self.externMapAction) # Add Interface for Zoom to Coordinate icon = QIcon(os.path.dirname(__file__) + "/images/zoomicon.png") self.zoomToAction = QAction(icon, "Zoom To Coordinate", self.iface.mainWindow()) self.zoomToAction.setObjectName('latLonToolsZoom') self.zoomToAction.triggered.connect(self.showZoomToDialog) self.toolbar.addAction(self.zoomToAction) self.iface.addPluginToMenu('Lat Lon Tools', self.zoomToAction) self.zoomToDialog = ZoomToLatLon(self, self.iface, self.iface.mainWindow()) self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.zoomToDialog) self.zoomToDialog.hide() # Add Interface for Multi point zoom icon = QIcon(os.path.dirname(__file__) + '/images/multizoom.png') self.multiZoomToAction = QAction(icon, "Multi-location Zoom", self.iface.mainWindow()) self.multiZoomToAction.setObjectName('latLonToolsMultiZoom') self.multiZoomToAction.triggered.connect(self.multiZoomTo) self.toolbar.addAction(self.multiZoomToAction) self.iface.addPluginToMenu('Lat Lon Tools', self.multiZoomToAction) self.multiZoomDialog = MultiZoomWidget(self, self.settingsDialog, self.iface.mainWindow()) self.multiZoomDialog.hide() self.multiZoomDialog.setFloating(True) # Create the coordinate converter menu icon = QIcon(':/images/themes/default/mIconProjectionEnabled.svg') self.convertCoordinatesAction = QAction(icon, "Coordinate Conversion", self.iface.mainWindow()) self.convertCoordinatesAction.setObjectName('latLonToolsCoordinateConversion') self.convertCoordinatesAction.triggered.connect(self.convertCoordinatesTool) self.toolbar.addAction(self.convertCoordinatesAction) self.iface.addPluginToMenu("Lat Lon Tools", self.convertCoordinatesAction) # Create the conversions menu menu = QMenu() icon = QIcon(os.path.dirname(__file__) + '/images/field2geom.png') action = menu.addAction(icon, "Fields to point layer", self.field2geom) action.setObjectName('latLonToolsField2Geom') icon = QIcon(os.path.dirname(__file__) + '/images/geom2field.png') action = menu.addAction(icon, "Point layer to fields", self.geom2Field) action.setObjectName('latLonToolsGeom2Field') icon = QIcon(os.path.dirname(__file__) + '/images/pluscodes.png') action = menu.addAction(icon, "Plus Codes to point layer", self.PlusCodestoLayer) action.setObjectName('latLonToolsPlusCodes2Geom') action = menu.addAction(icon, "Point layer to Plus Codes", self.toPlusCodes) action.setObjectName('latLonToolsGeom2PlusCodes') icon = QIcon(os.path.dirname(__file__) + '/images/mgrs2point.png') action = menu.addAction(icon, "MGRS to point layer", self.MGRStoLayer) action.setObjectName('latLonToolsMGRS2Geom') icon = QIcon(os.path.dirname(__file__) + '/images/point2mgrs.png') action = menu.addAction(icon, "Point layer to MGRS", self.toMGRS) action.setObjectName('latLonToolsGeom2MGRS') self.conversionsAction = QAction(icon, "Conversions", self.iface.mainWindow()) self.conversionsAction.setMenu(menu) self.iface.addPluginToMenu('Lat Lon Tools', self.conversionsAction) # Add to Digitize Toolbar icon = QIcon(os.path.dirname(__file__) + '/images/latLonDigitize.png') self.digitizeAction = QAction(icon, "Lat Lon Digitize", self.iface.mainWindow()) self.digitizeAction.setObjectName('latLonToolsDigitize') self.digitizeAction.triggered.connect(self.digitizeClicked) self.digitizeAction.setEnabled(False) self.toolbar.addAction(self.digitizeAction) self.iface.addPluginToMenu('Lat Lon Tools', self.digitizeAction) # Add Interface for copying the canvas extent icon = QIcon(os.path.dirname(__file__) + "/images/copycanvas.png") self.copyCanvasAction = QAction(icon, "Copy Canvas Bounding Box", self.iface.mainWindow()) self.copyCanvasAction.setObjectName('latLonToolsCopyCanvas') self.copyCanvasAction.triggered.connect(self.copyCanvas) self.toolbar.addAction(self.copyCanvasAction) self.iface.addPluginToMenu("Lat Lon Tools", self.copyCanvasAction) # Initialize the Settings Dialog Box settingsicon = QIcon(os.path.dirname(__file__) + '/images/settings.png') self.settingsAction = QAction(settingsicon, "Settings", self.iface.mainWindow()) self.settingsAction.setObjectName('latLonToolsSettings') self.settingsAction.triggered.connect(self.settings) self.iface.addPluginToMenu('Lat Lon Tools', self.settingsAction) # Help icon = QIcon(os.path.dirname(__file__) + '/images/help.png') self.helpAction = QAction(icon, "Help", self.iface.mainWindow()) self.helpAction.setObjectName('latLonToolsHelp') self.helpAction.triggered.connect(self.help) self.iface.addPluginToMenu('Lat Lon Tools', self.helpAction) self.iface.currentLayerChanged.connect(self.currentLayerChanged) self.canvas.mapToolSet.connect(self.unsetTool) self.enableDigitizeTool() # Add the processing provider QgsApplication.processingRegistry().addProvider(self.provider) def unsetTool(self, tool): '''Uncheck the Copy Lat Lon tool''' try: if not isinstance(tool, CopyLatLonTool): self.copyAction.setChecked(False) self.multiZoomDialog.stopCapture() self.mapTool.capture4326 = False if not isinstance(tool, ShowOnMapTool): self.externMapAction.setChecked(False) except Exception: pass def unload(self): '''Unload LatLonTools from the QGIS interface''' self.zoomToDialog.removeMarker() self.multiZoomDialog.removeMarkers() self.canvas.unsetMapTool(self.mapTool) self.canvas.unsetMapTool(self.showMapTool) self.iface.removePluginMenu('Lat Lon Tools', self.copyAction) self.iface.removePluginMenu('Lat Lon Tools', self.copyCanvasAction) self.iface.removePluginMenu('Lat Lon Tools', self.externMapAction) self.iface.removePluginMenu('Lat Lon Tools', self.zoomToAction) self.iface.removePluginMenu('Lat Lon Tools', self.multiZoomToAction) self.iface.removePluginMenu('Lat Lon Tools', self.convertCoordinatesAction) self.iface.removePluginMenu('Lat Lon Tools', self.conversionsAction) self.iface.removePluginMenu('Lat Lon Tools', self.settingsAction) self.iface.removePluginMenu('Lat Lon Tools', self.helpAction) self.iface.removePluginMenu('Lat Lon Tools', self.digitizeAction) self.iface.removeDockWidget(self.zoomToDialog) self.iface.removeDockWidget(self.multiZoomDialog) # Remove Toolbar Icons self.iface.removeToolBarIcon(self.copyAction) self.iface.removeToolBarIcon(self.copyCanvasAction) self.iface.removeToolBarIcon(self.zoomToAction) self.iface.removeToolBarIcon(self.externMapAction) self.iface.removeToolBarIcon(self.multiZoomToAction) self.iface.removeToolBarIcon(self.convertCoordinatesAction) self.iface.removeToolBarIcon(self.digitizeAction) del self.toolbar self.zoomToDialog = None self.multiZoomDialog = None self.settingsDialog = None self.showMapTool = None self.mapTool = None self.digitizerDialog = None self.convertCoordinateDialog = None QgsApplication.processingRegistry().removeProvider(self.provider) def startCapture(self): '''Set the focus of the copy coordinate tool and check it''' self.copyAction.setChecked(True) self.canvas.setMapTool(self.mapTool) def copyCanvas(self): extent = self.iface.mapCanvas().extent() canvasCrs = self.canvas.mapSettings().destinationCrs() if settings.bBoxCrs == 0 and canvasCrs != epsg4326: transform = QgsCoordinateTransform(canvasCrs, epsg4326, QgsProject.instance()) p1x, p1y = transform.transform(float(extent.xMinimum()), float(extent.yMinimum())) p2x, p2y = transform.transform(float(extent.xMaximum()), float(extent.yMaximum())) extent.set(p1x, p1y, p2x, p2y) delim = settings.bBoxDelimiter prefix = settings.bBoxPrefix suffix = settings.bBoxSuffix precision = settings.bBoxDigits outStr = '' minX = extent.xMinimum() minY = extent.yMinimum() maxX = extent.xMaximum() maxY = extent.yMaximum() if settings.bBoxFormat == 0: # minX,minY,maxX,maxY - using the delimiter outStr = '{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}'.format( minX, delim, minY, delim, maxX, delim, maxY, prec=precision) elif settings.bBoxFormat == 1: # minX,maxX,minY,maxY - Using the selected delimiter' outStr = '{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}{}{:.{prec}f}'.format( minX, delim, maxX, delim, minY, delim, maxY, prec=precision) elif settings.bBoxFormat == 2: # x1 y1,x2 y2,x3 y3,x4 y4,x1 y1 - Polygon format outStr = '{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f}'.format( minX, minY, minX, maxY, maxX, maxY, maxX, minY, minX, minY, prec=precision) elif settings.bBoxFormat == 3: # x1,y1 x2,y2 x3,y3 x4,y4 x1,y1 - Polygon format outStr = '{:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f} {:.{prec}f},{:.{prec}f}'.format( minX, minY, minX, maxY, maxX, maxY, maxX, minY, minX, minY, prec=precision) elif settings.bBoxFormat == 4: # WKT Polygon outStr = extent.asWktPolygon() elif settings.bBoxFormat == 5: # bbox: [minX, minY, maxX, maxY] - MapProxy outStr = 'bbox: [{}, {}, {}, {}]'.format( minX, minY, maxX, maxY) elif settings.bBoxFormat == 6: # bbox: [minX, minY, maxX, maxY] - MapProxy outStr = 'bbox={},{},{},{}'.format( minX, minY, maxX, maxY) outStr = '{}{}{}'.format(prefix, outStr, suffix) clipboard = QApplication.clipboard() clipboard.setText(outStr) self.iface.messageBar().pushMessage("", "'{}' copied to the clipboard".format(outStr), level=Qgis.Info, duration=4) def setShowMapTool(self): '''Set the focus of the external map tool and check it''' self.externMapAction.setChecked(True) self.canvas.setMapTool(self.showMapTool) def showZoomToDialog(self): '''Show the zoom to docked widget.''' self.zoomToDialog.show() def convertCoordinatesTool(self): '''Display the Convert Coordinate Tool Dialog box.''' if self.convertCoordinateDialog is None: from .coordinateConverter import CoordinateConverterWidget self.convertCoordinateDialog = CoordinateConverterWidget(self, self.settingsDialog, self.iface, self.iface.mainWindow()) self.convertCoordinateDialog.show() def multiZoomTo(self): '''Display the Multi-zoom to dialog box''' self.multiZoomDialog.show() def field2geom(self): '''Convert layer containing a point x & y coordinate to a new point layer''' processing.execAlgorithmDialog('latlontools:field2geom', {}) def geom2Field(self): '''Convert layer geometry to a text string''' processing.execAlgorithmDialog('latlontools:geom2field', {}) def toMGRS(self): '''Display the to MGRS dialog box''' processing.execAlgorithmDialog('latlontools:point2mgrs', {}) def MGRStoLayer(self): '''Display the to MGRS dialog box''' processing.execAlgorithmDialog('latlontools:mgrs2point', {}) def toPlusCodes(self): processing.execAlgorithmDialog('latlontools:point2pluscodes', {}) def PlusCodestoLayer(self): processing.execAlgorithmDialog('latlontools:pluscodes2point', {}) def settings(self): '''Show the settings dialog box''' self.settingsDialog.show() def help(self): '''Display a help page''' url = QUrl.fromLocalFile(os.path.dirname(__file__) + "/index.html").toString() webbrowser.open(url, new=2) def settingsChanged(self): # Settings may have changed so we need to make sure the zoomToDialog window is configured properly self.zoomToDialog.configure() self.multiZoomDialog.settingsChanged() def zoomTo(self, srcCrs, lat, lon): canvasCrs = self.canvas.mapSettings().destinationCrs() transform = QgsCoordinateTransform(srcCrs, canvasCrs, QgsProject.instance()) x, y = transform.transform(float(lon), float(lat)) rect = QgsRectangle(x, y, x, y) self.canvas.setExtent(rect) pt = QgsPointXY(x, y) self.highlight(pt) self.canvas.refresh() return pt def highlight(self, point): currExt = self.canvas.extent() leftPt = QgsPoint(currExt.xMinimum(), point.y()) rightPt = QgsPoint(currExt.xMaximum(), point.y()) topPt = QgsPoint(point.x(), currExt.yMaximum()) bottomPt = QgsPoint(point.x(), currExt.yMinimum()) horizLine = QgsGeometry.fromPolyline([leftPt, rightPt]) vertLine = QgsGeometry.fromPolyline([topPt, bottomPt]) self.crossRb.reset(QgsWkbTypes.LineGeometry) self.crossRb.addGeometry(horizLine, None) self.crossRb.addGeometry(vertLine, None) QTimer.singleShot(700, self.resetRubberbands) def resetRubberbands(self): self.crossRb.reset() def digitizeClicked(self): if self.digitizerDialog is None: from .digitizer import DigitizerWidget self.digitizerDialog = DigitizerWidget(self, self.iface, self.iface.mainWindow()) self.digitizerDialog.show() def currentLayerChanged(self): layer = self.iface.activeLayer() if layer is not None: try: layer.editingStarted.disconnect(self.layerEditingChanged) except Exception: pass try: layer.editingStopped.disconnect(self.layerEditingChanged) except Exception: pass if isinstance(layer, QgsVectorLayer): layer.editingStarted.connect(self.layerEditingChanged) layer.editingStopped.connect(self.layerEditingChanged) self.enableDigitizeTool() def layerEditingChanged(self): self.enableDigitizeTool() def enableDigitizeTool(self): self.digitizeAction.setEnabled(False) layer = self.iface.activeLayer() if layer is not None and isinstance(layer, QgsVectorLayer) and (layer.geometryType() == QgsWkbTypes.PointGeometry) and layer.isEditable(): self.digitizeAction.setEnabled(True) else: if self.digitizerDialog is not None: self.digitizerDialog.close()
def clicked_event(self): # Create main menu and get cursor click position main_menu = QMenu() cursor = QCursor() x = cursor.pos().x() y = cursor.pos().y() click_point = QPoint(x + 5, y + 5) schema_name = self.schema_name.replace('"', '') # Get parent layers sql = ( "SELECT distinct ( CASE parent_layer WHEN 'v_edit_node' THEN 'Node' " "WHEN 'v_edit_arc' THEN 'Arc' WHEN 'v_edit_connec' THEN 'Connec' " "WHEN 'v_edit_gully' THEN 'Gully' END ), parent_layer FROM cat_feature " "ORDER BY parent_layer") parent_layers = self.controller.get_rows(sql) for parent_layer in parent_layers: # Get child layers sql = ( f"SELECT DISTINCT(child_layer), lower(feature_type), cat_feature.id as alias, style as style_id, " f" group_layer " f" FROM cat_feature " f" LEFT JOIN config_table ON config_table.id = child_layer " f"WHERE parent_layer = '{parent_layer[1]}' " f"AND child_layer IN (" f" SELECT table_name FROM information_schema.tables" f" WHERE table_schema = '{schema_name}')" f" ORDER BY child_layer") child_layers = self.controller.get_rows(sql) if not child_layers: continue # Create sub menu sub_menu = main_menu.addMenu(str(parent_layer[0])) child_layers.insert( 0, ['Load all', 'Load all', 'Load all', 'Load all', 'Load all']) for child_layer in child_layers: # Create actions action = QAction(str(child_layer[2]), sub_menu, checkable=True) # Get load layers and create child layers menu (actions) layers_list = [] layers = self.iface.mapCanvas().layers() for layer in layers: layers_list.append(str(layer.name())) if str(child_layer[0]) in layers_list: action.setChecked(True) sub_menu.addAction(action) if child_layer[0] == 'Load all': action.triggered.connect( partial(from_postgres_to_toc, child_layers=child_layers)) else: layer_name = child_layer[0] the_geom = "the_geom" geom_field = child_layer[1] + "_id" style_id = child_layer[3] group = child_layer[4] if child_layer[ 4] is not None else 'GW Layers' action.triggered.connect( partial(from_postgres_to_toc, layer_name, the_geom, geom_field, None, group, style_id)) main_menu.exec_(click_point)
class FeatureSelectSample: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface self.canvas = self.iface.mapCanvas() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # プラグインの登録場所 self.menu_pos = 'サンプル フューチャー選択' # キャンバスウィンドウ上でのマウスイベントの設定 self.mouseEventSample = FeatureSelectionTool(self.canvas) def initGui(self): icon = QIcon(self.plugin_dir + '/icon.png') self.action = QAction(icon, '一つ選択→属性編集', self.iface.mainWindow()) self.action.triggered.connect( self.execSample) # アイコンを押下した時に実行されるメソッドを登録 self.action.setCheckable(True) # Trueだとアイコンを押下したら次に押下するまで凹んだままになる。 #self.iface.addToolBarIcon(self.action) # ツールバーにアイコンを表示させたいなら#外して self.iface.addPluginToMenu(self.menu_pos, self.action) # このサンプル以外のアイコンが押された場合、アイコンを元の状態に戻す def unsetTool(self, tool): if not isinstance(tool, FeatureSelectSample): try: self.mouseEventSample.featureIdentified.disconnect( self.editAttribute) except Exception: pass self.iface.layerTreeView().currentLayerChanged.disconnect( self.changeLayer) self.canvas.mapToolSet.disconnect(self.unsetTool) self.canvas.unsetMapTool(self.mouseEventSample) self.action.setChecked(False) def execSample(self): if self.action.isChecked(): self.layer = self.iface.activeLayer() if (self.layer == None) or (type(self.layer) is not qgis._core.QgsVectorLayer): QMessageBox.about(None, '警告', 'ベクタレイヤを選択してから実行してください') self.action.setChecked(False) return self.previousMapTool = self.canvas.mapTool() self.canvas.setMapTool(self.mouseEventSample) self.canvas.mapToolSet.connect(self.unsetTool) self.iface.layerTreeView().currentLayerChanged.connect( self.changeLayer) # アクティブレイヤが変更された時に呼ぶメソッドを登録 self.mouseEventSample.setLayer(self.iface.activeLayer()) self.mouseEventSample.featureIdentified.connect(self.editAttribute) else: self.mouseEventSample.featureIdentified.disconnect( self.editAttribute) self.iface.layerTreeView().currentLayerChanged.disconnect( self.changeLayer) self.canvas.mapToolSet.disconnect(self.unsetTool) self.canvas.unsetMapTool(self.mouseEventSample) self.canvas.setMapTool(self.previousMapTool) # フューチャーを一つ選択した時に呼ばれる。 def editAttribute(self, feature): self.layer.removeSelection() self.layer.select(feature.id()) self.layer.startEditing() # レイヤを編集状態にする # 選択しているフューチャーの属性フォーム表示 self.attdlg = self.iface.getFeatureForm(self.layer, feature) self.attdlg.setMode(qgis.gui.QgsAttributeEditorContext.SingleEditMode) self.attdlg.finished.connect(self.commitEdit) self.attdlg.show() def commitEdit(self, result): if result == 1: self.layer.commitChanges() else: self.layer.rollBack() self.attdlg.finished.disconnect(self.commitEdit) # レイヤウィンドウでレイヤを選択したときに呼ばれる def changeLayer(self, layer): if (layer == None) or (type(layer) is not qgis.core.QgsVectorLayer): return self.layer.removeSelection() self.layer = layer self.mouseEventSample.setLayer(self.layer)
class Plugin(): """The QGIS interface implementation for the InaSAFE plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menu bar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. :param iface:Quantum GIS iface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. :type iface: QgisAppInterface """ # Save reference to the QGIS interface self.iface = iface self.dock_widget = None # Actions self.action_add_layers = None self.action_add_osm_layer = None self.action_add_petabencana_layer = None self.action_batch_runner = None self.action_dock = None self.action_extent_selector = None self.action_field_mapping = None self.action_multi_exposure = None self.action_function_centric_wizard = None self.action_import_dialog = None self.action_keywords_wizard = None self.action_minimum_needs = None self.action_minimum_needs_config = None self.action_multi_buffer = None self.action_options = None self.action_run_tests = None self.action_save_scenario = None self.action_shake_converter = None self.action_show_definitions = None self.action_toggle_rubberbands = None self.action_metadata_converter = None self.translator = None self.toolbar = None self.wizard = None self.actions = [] # list of all QActions we create for InaSAFE self.message_bar_item = None # Flag indicating if toolbar should show only common icons or not self.full_toolbar = False # print self.tr('InaSAFE') # For enable/disable the keyword editor icon self.iface.currentLayerChanged.connect(self.layer_changed) developer_mode = setting('developer_mode', False, expected_type=bool) self.hide_developer_buttons = (inasafe_release_status == 'final' and not developer_mode) # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('Plugin', message) def add_action(self, action, add_to_toolbar=True, add_to_legend=False): """Add a toolbar icon to the InaSAFE toolbar. :param action: The action that should be added to the toolbar. :type action: QAction :param add_to_toolbar: Flag indicating whether the action should also be added to the InaSAFE toolbar. Defaults to True. :type add_to_toolbar: bool :param add_to_legend: Flag indicating whether the action should also be added to the layer legend menu. Default to False. :type add_to_legend: bool """ # store in the class list of actions for easy plugin unloading self.actions.append(action) self.iface.addPluginToMenu(self.tr('InaSAFE'), action) if add_to_toolbar: self.toolbar.addAction(action) if add_to_legend: # The id is the action name without spaces, tabs ... self.iface.addCustomActionForLayerType(action, self.tr('InaSAFE'), QgsMapLayer.VectorLayer, True) self.iface.addCustomActionForLayerType(action, self.tr('InaSAFE'), QgsMapLayer.RasterLayer, True) def _create_dock_toggle_action(self): """Create action for plugin dockable window (show/hide).""" # pylint: disable=W0201 icon = resources_path('img', 'icons', 'icon.svg') self.action_dock = QAction(QIcon(icon), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.action_dock.setObjectName('InaSAFEDockToggle') self.action_dock.setStatusTip(self.tr('Show/hide InaSAFE dock widget')) self.action_dock.setWhatsThis(self.tr('Show/hide InaSAFE dock widget')) self.action_dock.setCheckable(True) self.action_dock.setChecked(True) self.action_dock.triggered.connect(self.toggle_dock_visibility) self.add_action(self.action_dock) # -------------------------------------- # Create action for keywords creation wizard # ------------------------------------- def _create_keywords_wizard_action(self): """Create action for keywords creation wizard.""" icon = resources_path('img', 'icons', 'show-keyword-wizard.svg') self.action_keywords_wizard = QAction( QIcon(icon), self.tr('Keywords Creation Wizard'), self.iface.mainWindow()) self.action_keywords_wizard.setStatusTip( self.tr('Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setWhatsThis( self.tr('Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setEnabled(False) self.action_keywords_wizard.triggered.connect( self.show_keywords_wizard) self.add_action(self.action_keywords_wizard, add_to_legend=True) def _create_analysis_wizard_action(self): """Create action for IF-centric wizard.""" icon = resources_path('img', 'icons', 'show-wizard.svg') self.action_function_centric_wizard = QAction( QIcon(icon), self.tr('Impact Function Centric Wizard'), self.iface.mainWindow()) self.action_function_centric_wizard.setStatusTip( self.tr('Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setWhatsThis( self.tr('Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setEnabled(True) self.action_function_centric_wizard.triggered.connect( self.show_function_centric_wizard) self.add_action(self.action_function_centric_wizard) def _create_options_dialog_action(self): """Create action for options dialog.""" icon = resources_path('img', 'icons', 'configure-inasafe.svg') self.action_options = QAction(QIcon(icon), self.tr('Options'), self.iface.mainWindow()) self.action_options.setStatusTip( self.tr('Open InaSAFE options dialog')) self.action_options.setWhatsThis( self.tr('Open InaSAFE options dialog')) self.action_options.triggered.connect(self.show_options) self.add_action(self.action_options, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_action(self): """Create action for minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-minimum-needs.svg') self.action_minimum_needs = QAction( QIcon(icon), self.tr('Minimum Needs Calculator'), self.iface.mainWindow()) self.action_minimum_needs.setStatusTip( self.tr('Open InaSAFE minimum needs calculator')) self.action_minimum_needs.setWhatsThis( self.tr('Open InaSAFE minimum needs calculator')) self.action_minimum_needs.triggered.connect(self.show_minimum_needs) self.add_action(self.action_minimum_needs, add_to_toolbar=self.full_toolbar) def _create_multi_buffer_action(self): """Create action for multi buffer dialog.""" icon = resources_path('img', 'icons', 'show-multi-buffer.svg') self.action_multi_buffer = QAction(QIcon(icon), self.tr('Multi Buffer'), self.iface.mainWindow()) self.action_multi_buffer.setStatusTip( self.tr('Open InaSAFE multi buffer')) self.action_multi_buffer.setWhatsThis( self.tr('Open InaSAFE multi buffer')) self.action_multi_buffer.triggered.connect(self.show_multi_buffer) self.add_action(self.action_multi_buffer, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_options_action(self): """Create action for global minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-global-minimum-needs.svg') self.action_minimum_needs_config = QAction( QIcon(icon), self.tr('Minimum Needs Configuration'), self.iface.mainWindow()) self.action_minimum_needs_config.setStatusTip( self.tr('Open InaSAFE minimum needs configuration')) self.action_minimum_needs_config.setWhatsThis( self.tr('Open InaSAFE minimum needs configuration')) self.action_minimum_needs_config.triggered.connect( self.show_minimum_needs_configuration) self.add_action(self.action_minimum_needs_config, add_to_toolbar=self.full_toolbar) def _create_shakemap_converter_action(self): """Create action for converter dialog.""" icon = resources_path('img', 'icons', 'show-converter-tool.svg') self.action_shake_converter = QAction(QIcon(icon), self.tr('Shakemap Converter'), self.iface.mainWindow()) self.action_shake_converter.setStatusTip( self.tr('Open InaSAFE Converter')) self.action_shake_converter.setWhatsThis( self.tr('Open InaSAFE Converter')) self.action_shake_converter.triggered.connect( self.show_shakemap_importer) self.add_action(self.action_shake_converter, add_to_toolbar=self.full_toolbar) def _create_batch_runner_action(self): """Create action for batch runner dialog.""" icon = resources_path('img', 'icons', 'show-batch-runner.svg') self.action_batch_runner = QAction(QIcon(icon), self.tr('Batch Runner'), self.iface.mainWindow()) self.action_batch_runner.setStatusTip(self.tr('Open Batch Runner')) self.action_batch_runner.setWhatsThis(self.tr('Open Batch Runner')) self.action_batch_runner.triggered.connect(self.show_batch_runner) self.add_action(self.action_batch_runner, add_to_toolbar=self.full_toolbar) def _create_save_scenario_action(self): """Create action for save scenario dialog.""" icon = resources_path('img', 'icons', 'save-as-scenario.svg') self.action_save_scenario = QAction(QIcon(icon), self.tr('Save Current Scenario'), self.iface.mainWindow()) message = self.tr('Save current scenario to text file') self.action_save_scenario.setStatusTip(message) self.action_save_scenario.setWhatsThis(message) # noinspection PyUnresolvedReferences self.action_save_scenario.triggered.connect(self.save_scenario) self.add_action(self.action_save_scenario, add_to_toolbar=self.full_toolbar) def _create_osm_downloader_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'show-osm-download.svg') self.action_import_dialog = QAction( QIcon(icon), self.tr('OpenStreetMap Downloader'), self.iface.mainWindow()) self.action_import_dialog.setStatusTip( self.tr('OpenStreetMap Downloader')) self.action_import_dialog.setWhatsThis( self.tr('OpenStreetMap Downloader')) self.action_import_dialog.triggered.connect(self.show_osm_downloader) self.add_action(self.action_import_dialog, add_to_toolbar=True) def _create_geonode_uploader_action(self): """Create action for Geonode uploader dialog.""" icon = resources_path('img', 'icons', 'geonode.png') label = tr('Geonode Uploader') self.action_geonode = QAction(QIcon(icon), label, self.iface.mainWindow()) self.action_geonode.setStatusTip(label) self.action_geonode.setWhatsThis(label) self.action_geonode.triggered.connect(self.show_geonode_uploader) self.add_action(self.action_geonode, add_to_toolbar=False) def _create_add_osm_layer_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'add-osm-tiles-layer.svg') self.action_add_osm_layer = QAction( QIcon(icon), self.tr('Add OpenStreetMap Tile Layer'), self.iface.mainWindow()) self.action_add_osm_layer.setStatusTip( self.tr('Add OpenStreetMap Tile Layer')) self.action_add_osm_layer.setWhatsThis( self.tr('Use this to add an OSM layer to your map. ' 'It needs internet access to function.')) self.action_add_osm_layer.triggered.connect(self.add_osm_layer) self.add_action(self.action_add_osm_layer, add_to_toolbar=True) def _create_show_definitions_action(self): """Create action for showing definitions / help.""" icon = resources_path('img', 'icons', 'show-inasafe-help.svg') self.action_show_definitions = QAction(QIcon(icon), self.tr('InaSAFE Help'), self.iface.mainWindow()) self.action_show_definitions.setStatusTip(self.tr('Show InaSAFE Help')) self.action_show_definitions.setWhatsThis( self. tr('Use this to show a document describing all InaSAFE concepts.')) self.action_show_definitions.triggered.connect(self.show_definitions) self.add_action(self.action_show_definitions, add_to_toolbar=True) def _create_metadata_converter_action(self): """Create action for showing metadata converter dialog.""" icon = resources_path('img', 'icons', 'show-metadata-converter.svg') self.action_metadata_converter = QAction( QIcon(icon), self.tr('InaSAFE Metadata Converter'), self.iface.mainWindow()) self.action_metadata_converter.setStatusTip( self.tr('Convert metadata from version 4.3 to version 3.5.')) self.action_metadata_converter.setWhatsThis( self.tr('Use this tool to convert metadata 4.3 to version 3.5')) self.action_metadata_converter.triggered.connect( self.show_metadata_converter) self.add_action(self.action_metadata_converter, add_to_toolbar=self.full_toolbar) def _create_field_mapping_action(self): """Create action for showing field mapping dialog.""" icon = resources_path('img', 'icons', 'show-mapping-tool.svg') self.action_field_mapping = QAction( QIcon(icon), self.tr('InaSAFE Field Mapping Tool'), self.iface.mainWindow()) self.action_field_mapping.setStatusTip( self.tr('Assign field mapping to layer.')) self.action_field_mapping.setWhatsThis( self.tr('Use this tool to assign field mapping in layer.')) self.action_field_mapping.setEnabled(False) self.action_field_mapping.triggered.connect(self.show_field_mapping) self.add_action(self.action_field_mapping, add_to_toolbar=self.full_toolbar) def _create_multi_exposure_action(self): """Create action for showing the multi exposure tool.""" self.action_multi_exposure = QAction( QIcon(resources_path('img', 'icons', 'show-multi-exposure.svg')), self.tr('InaSAFE Multi Exposure Tool'), self.iface.mainWindow()) self.action_multi_exposure.setStatusTip( self.tr('Open the multi exposure tool.')) self.action_multi_exposure.setWhatsThis( self.tr('Open the multi exposure tool.')) self.action_multi_exposure.setEnabled(True) self.action_multi_exposure.triggered.connect(self.show_multi_exposure) self.add_action(self.action_multi_exposure, add_to_toolbar=self.full_toolbar) def _create_add_petabencana_layer_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'add-petabencana-layer.svg') self.action_add_petabencana_layer = QAction( QIcon(icon), self.tr('Add PetaBencana Flood Layer'), self.iface.mainWindow()) self.action_add_petabencana_layer.setStatusTip( self.tr('Add PetaBencana Flood Layer')) self.action_add_petabencana_layer.setWhatsThis( self.tr('Use this to add a PetaBencana layer to your map. ' 'It needs internet access to function.')) self.action_add_petabencana_layer.triggered.connect( self.add_petabencana_layer) self.add_action(self.action_add_petabencana_layer, add_to_toolbar=self.full_toolbar) def _create_rubber_bands_action(self): """Create action for toggling rubber bands.""" icon = resources_path('img', 'icons', 'toggle-rubber-bands.svg') self.action_toggle_rubberbands = QAction( QIcon(icon), self.tr('Toggle Scenario Outlines'), self.iface.mainWindow()) message = self.tr('Toggle rubber bands showing scenario extents.') self.action_toggle_rubberbands.setStatusTip(message) self.action_toggle_rubberbands.setWhatsThis(message) # Set initial state self.action_toggle_rubberbands.setCheckable(True) flag = setting('showRubberBands', False, expected_type=bool) self.action_toggle_rubberbands.setChecked(flag) # noinspection PyUnresolvedReferences self.action_toggle_rubberbands.triggered.connect( self.dock_widget.toggle_rubber_bands) self.add_action(self.action_toggle_rubberbands) def _create_analysis_extent_action(self): """Create action for analysis extent dialog.""" icon = resources_path('img', 'icons', 'set-extents-tool.svg') self.action_extent_selector = QAction(QIcon(icon), self.tr('Set Analysis Area'), self.iface.mainWindow()) self.action_extent_selector.setStatusTip( self.tr('Set the analysis area for InaSAFE')) self.action_extent_selector.setWhatsThis( self.tr('Set the analysis area for InaSAFE')) self.action_extent_selector.triggered.connect( self.show_extent_selector) self.add_action(self.action_extent_selector) def _create_test_layers_action(self): """Create action for adding layers (developer mode, non final only).""" if self.hide_developer_buttons: return icon = resources_path('img', 'icons', 'add-test-layers.svg') self.action_add_layers = QAction(QIcon(icon), self.tr('Add Test Layers'), self.iface.mainWindow()) self.action_add_layers.setStatusTip(self.tr('Add test layers')) self.action_add_layers.setWhatsThis(self.tr('Add test layers')) self.action_add_layers.triggered.connect(self.add_test_layers) self.add_action(self.action_add_layers) def _create_run_test_action(self): """Create action for running tests (developer mode, non final only).""" if self.hide_developer_buttons: return default_package = str(setting('testPackage', 'safe', expected_type=str)) msg = self.tr('Run tests in %s' % default_package) self.test_button = QToolButton() self.test_button.setMenu(QMenu()) self.test_button.setPopupMode(QToolButton.MenuButtonPopup) icon = resources_path('img', 'icons', 'run-tests.svg') self.action_run_tests = QAction(QIcon(icon), msg, self.iface.mainWindow()) self.action_run_tests.setStatusTip(msg) self.action_run_tests.setWhatsThis(msg) self.action_run_tests.triggered.connect(self.run_tests) self.test_button.menu().addAction(self.action_run_tests) self.test_button.setDefaultAction(self.action_run_tests) self.action_select_package = QAction(QIcon(icon), self.tr('Select package'), self.iface.mainWindow()) self.action_select_package.setStatusTip(self.tr('Select Test Package')) self.action_select_package.setWhatsThis(self.tr('Select Test Package')) self.action_select_package.triggered.connect(self.select_test_package) self.test_button.menu().addAction(self.action_select_package) self.toolbar.addWidget(self.test_button) self.add_action(self.action_run_tests, add_to_toolbar=False) self.add_action(self.action_select_package, add_to_toolbar=False) def _create_dock(self): """Create dockwidget and tabify it with the legend.""" # Import dock here as it needs to be imported AFTER i18n is set up from safe.gui.widgets.dock import Dock self.dock_widget = Dock(self.iface) self.dock_widget.setObjectName('InaSAFE-Dock') self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock_widget) legend_tab = self.iface.mainWindow().findChild(QApplication, 'Legend') if legend_tab: self.iface.mainWindow().tabifyDockWidget(legend_tab, self.dock_widget) self.dock_widget.raise_() # noinspection PyPep8Naming def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') self.dock_widget = None # Now create the actual dock self._create_dock() # And all the menu actions # Configuration Group self._create_dock_toggle_action() self._create_options_dialog_action() self._create_minimum_needs_options_action() self._create_analysis_extent_action() self._create_rubber_bands_action() self._add_spacer_to_menu() self._create_keywords_wizard_action() self._create_analysis_wizard_action() self._add_spacer_to_menu() self._create_field_mapping_action() self._create_multi_exposure_action() self._create_metadata_converter_action() self._create_osm_downloader_action() self._create_add_osm_layer_action() self._create_add_petabencana_layer_action() self._create_geonode_uploader_action() self._create_shakemap_converter_action() self._create_minimum_needs_action() self._create_multi_buffer_action() self._create_test_layers_action() self._create_run_test_action() self._add_spacer_to_menu() self._create_batch_runner_action() self._create_save_scenario_action() self._add_spacer_to_menu() self._create_show_definitions_action() # Hook up a slot for when the dock is hidden using its close button # or view-panels # self.dock_widget.visibilityChanged.connect(self.toggle_inasafe_action) # Also deal with the fact that on start of QGIS dock may already be # hidden. self.action_dock.setChecked(self.dock_widget.isVisible()) self.iface.initializationCompleted.connect( partial(self.show_welcome_message)) def _add_spacer_to_menu(self): """Create a spacer to the menu to separate action groups.""" separator = QAction(self.iface.mainWindow()) separator.setSeparator(True) self.iface.addPluginToMenu(self.tr('InaSAFE'), separator) @staticmethod def clear_modules(): """Unload inasafe functions and try to return QGIS to before InaSAFE. .. todo:: I think this function can be removed. TS. """ # next lets force remove any inasafe related modules modules = [] for module in sys.modules: if 'inasafe' in module: # Check if it is really one of our modules i.e. exists in the # plugin directory tokens = module.split('.') path = '' for myToken in tokens: path += os.path.sep + myToken parent = os.path.abspath( os.path.join(__file__, os.path.pardir, os.path.pardir)) full_path = os.path.join(parent, path + '.py') if os.path.exists(os.path.abspath(full_path)): LOGGER.debug('Removing: %s' % module) modules.append(module) for module in modules: del (sys.modules[module]) for module in sys.modules: if 'inasafe' in module: print(module) # Lets also clean up all the path additions that were made package_path = os.path.abspath( os.path.join(os.path.dirname(__file__), os.path.pardir)) LOGGER.debug('Path to remove: %s' % package_path) # We use a list comprehension to ensure duplicate entries are removed LOGGER.debug(sys.path) sys.path = [y for y in sys.path if package_path not in y] LOGGER.debug(sys.path) def unload(self): """GUI breakdown procedure (for QGIS plugin api). .. note:: Don't change the name of this method from unload! This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. """ # Remove the plugin menu item and icon if self.wizard: self.wizard.deleteLater() for myAction in self.actions: self.iface.removePluginMenu(self.tr('InaSAFE'), myAction) self.iface.removeToolBarIcon(myAction) self.iface.removeCustomActionForLayerType(myAction) self.iface.mainWindow().removeDockWidget(self.dock_widget) self.iface.mainWindow().removeToolBar(self.toolbar) self.dock_widget.setVisible(False) self.dock_widget.destroy() self.iface.currentLayerChanged.disconnect(self.layer_changed) # Unload QGIS expressions loaded by the plugin. for qgis_expression in list(qgis_expressions().keys()): QgsExpression.unregisterFunction(qgis_expression) def toggle_inasafe_action(self, checked): """Check or un-check the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels. :param checked: True if the dock should be shown, otherwise False. :type checked: bool """ self.action_dock.setChecked(checked) # Run method that performs all the real work def toggle_dock_visibility(self): """Show or hide the dock widget.""" if self.dock_widget.isVisible(): self.dock_widget.setVisible(False) else: self.dock_widget.setVisible(True) self.dock_widget.raise_() def add_test_layers(self): """Add standard test layers.""" from safe.test.utilities import load_standard_layers load_standard_layers() rect = QgsRectangle(106.806, -6.195, 106.837, -6.167) self.iface.mapCanvas().setExtent(rect) def select_test_package(self): """Select the test package.""" default_package = 'safe' user_package = str( setting('testPackage', default_package, expected_type=str)) test_package, _ = QInputDialog.getText( self.iface.mainWindow(), self.tr('Select the python test package'), self.tr('Select the python test package'), QLineEdit.Normal, user_package) if test_package == '': test_package = default_package set_setting('testPackage', test_package) msg = self.tr('Run tests in %s' % test_package) self.action_run_tests.setWhatsThis(msg) self.action_run_tests.setText(msg) def run_tests(self): """Run unit tests in the python console.""" from qgis.PyQt.QtWidgets import QDockWidget main_window = self.iface.mainWindow() action = main_window.findChild(QAction, 'mActionShowPythonDialog') action.trigger() package = str(setting('testPackage', 'safe', expected_type=str)) for child in main_window.findChildren(QDockWidget, 'PythonConsole'): if child.objectName() == 'PythonConsole': child.show() for widget in child.children(): if 'PythonConsoleWidget' in str(widget.__class__): # print "Console widget found" shell = widget.shell shell.runCommand( 'from inasafe.test_suite import test_package') shell.runCommand('test_package(\'%s\')' % package) break def show_extent_selector(self): """Show the extent selector widget for defining analysis extents.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.extent_selector_dialog import ExtentSelectorDialog widget = ExtentSelectorDialog( self.iface, self.iface.mainWindow(), extent=self.dock_widget.extent.user_extent, crs=self.dock_widget.extent.crs) widget.clear_extent.connect( self.dock_widget.extent.clear_user_analysis_extent) widget.extent_defined.connect( self.dock_widget.define_user_analysis_extent) # This ensures that run button state is updated on dialog close widget.extent_selector_closed.connect( self.dock_widget.validate_impact_function) # Needs to be non modal to support hide -> interact with map -> show widget.show() # non modal def show_minimum_needs(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_calculator_dialog import ( NeedsCalculatorDialog) dialog = NeedsCalculatorDialog(self.iface.mainWindow()) dialog.exec_() def show_minimum_needs_configuration(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_manager_dialog import ( NeedsManagerDialog) dialog = NeedsManagerDialog(parent=self.iface.mainWindow(), dock=self.dock_widget) dialog.exec_() # modal def show_options(self): """Show the options dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.options_dialog import OptionsDialog dialog = OptionsDialog(iface=self.iface, parent=self.iface.mainWindow()) dialog.show_option_dialog() if dialog.exec_(): # modal self.dock_widget.read_settings() from safe.gui.widgets.message import getting_started_message send_static_message(self.dock_widget, getting_started_message()) # Issue #4734, make sure to update the combobox after update the # InaSAFE option self.dock_widget.get_layers() def show_welcome_message(self): """Show the welcome message.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.options_dialog import OptionsDialog # Do not show by default show_message = False previous_version = StrictVersion(setting('previous_version')) current_version = StrictVersion(inasafe_version) # Set previous_version to the current inasafe_version set_setting('previous_version', inasafe_version) if setting('always_show_welcome_message', expected_type=bool): # Show if it the setting said so show_message = True elif previous_version < current_version: # Always show if the user installed new version show_message = True # Allow to disable welcome message when running automated tests if os.environ.get('INASAFE_DISABLE_WELCOME_MESSAGE', False): show_message = False if show_message: dialog = OptionsDialog(iface=self.iface, parent=self.iface.mainWindow()) dialog.show_welcome_dialog() if dialog.exec_(): # modal self.dock_widget.read_settings() def show_keywords_wizard(self): """Show the keywords creation wizard.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.wizard.wizard_dialog import WizardDialog if self.iface.activeLayer() is None: return # Don't break an existing wizard session if accidentally clicked if self.wizard and self.wizard.isVisible(): return # Prevent spawning multiple copies since the IFCW is non modal if not self.wizard: self.wizard = WizardDialog(self.iface.mainWindow(), self.iface, self.dock_widget) self.wizard.set_keywords_creation_mode() self.wizard.exec_() # modal def show_function_centric_wizard(self): """Show the function centric wizard.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.wizard.wizard_dialog import WizardDialog # Don't break an existing wizard session if accidentally clicked if self.wizard and self.wizard.isVisible(): return # Prevent spawning multiple copies since it is non modal if not self.wizard: self.wizard = WizardDialog(self.iface.mainWindow(), self.iface, self.dock_widget) self.wizard.set_function_centric_mode() # non-modal in order to hide for selecting user extent self.wizard.show() def show_shakemap_importer(self): """Show the converter dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.shake_grid.shakemap_converter_dialog import ( ShakemapConverterDialog) dialog = ShakemapConverterDialog(self.iface.mainWindow(), self.iface, self.dock_widget) dialog.exec_() # modal def show_multi_buffer(self): """Show the multi buffer tool.""" from safe.gui.tools.multi_buffer_dialog import (MultiBufferDialog) dialog = MultiBufferDialog(self.iface.mainWindow(), self.iface, self.dock_widget) dialog.exec_() # modal def show_osm_downloader(self): """Show the OSM buildings downloader dialog.""" from safe.gui.tools.osm_downloader_dialog import OsmDownloaderDialog dialog = OsmDownloaderDialog(self.iface.mainWindow(), self.iface) # otherwise dialog is never deleted dialog.setAttribute(Qt.WA_DeleteOnClose, True) dialog.show() # non modal def show_geonode_uploader(self): """Show the Geonode uploader dialog.""" from safe.gui.tools.geonode_uploader import GeonodeUploaderDialog dialog = GeonodeUploaderDialog(self.iface.mainWindow()) dialog.show() # non modal def add_osm_layer(self): """Add OSM tile layer to the map. This uses a gdal wrapper around the OSM tile service - see the WorldOSM.gdal file for how it is constructed. """ path = resources_path('osm', 'WorldOSM.gdal') layer = QgsRasterLayer(path, self.tr('OpenStreetMap')) project = QgsProject.instance() # Try to add it as the last layer in the list # False flag prevents layer being added to legend project.addMapLayer(layer, False) root = QgsProject.instance().layerTreeRoot() index = len(root.findLayers()) + 1 # LOGGER.info('Inserting layer %s at position %s' % ( # layer.source(), index)) root.insertLayer(index, layer) project.addMapLayer(layer) def show_definitions(self): """Show InaSAFE Definitions (a report showing all key metadata).""" from safe.utilities.help import show_help from safe.gui.tools.help import definitions_help show_help(definitions_help.definitions_help()) def show_field_mapping(self): """Show InaSAFE Field Mapping.""" from safe.gui.tools.field_mapping_dialog import FieldMappingDialog dialog = FieldMappingDialog( parent=self.iface.mainWindow(), iface=self.iface, ) if dialog.exec_(): # modal LOGGER.debug('Show field mapping accepted') self.dock_widget.layer_changed(self.iface.activeLayer()) else: LOGGER.debug('Show field mapping not accepted') def show_metadata_converter(self): """Show InaSAFE Metadata Converter.""" from safe.gui.tools.metadata_converter_dialog import ( MetadataConverterDialog) dialog = MetadataConverterDialog( parent=self.iface.mainWindow(), iface=self.iface, ) dialog.exec_() def show_multi_exposure(self): """Show InaSAFE Multi Exposure.""" from safe.gui.tools.multi_exposure_dialog import MultiExposureDialog dialog = MultiExposureDialog(self.iface.mainWindow(), self.iface) dialog.exec_() # modal def add_petabencana_layer(self): """Add petabencana layer to the map. This uses the PetaBencana API to fetch the latest floods in JK. See https://data.petabencana.id/floods """ from safe.gui.tools.peta_bencana_dialog import PetaBencanaDialog dialog = PetaBencanaDialog(self.iface.mainWindow(), self.iface) dialog.show() # non modal def show_batch_runner(self): """Show the batch runner dialog.""" from safe.gui.tools.batch.batch_dialog import BatchDialog dialog = BatchDialog(parent=self.iface.mainWindow(), iface=self.iface, dock=self.dock_widget) dialog.exec_() # modal def save_scenario(self): """Save current scenario to text file.""" from safe.gui.tools.save_scenario import SaveScenarioDialog dialog = SaveScenarioDialog(iface=self.iface, dock=self.dock_widget) dialog.save_scenario() def layer_changed(self, layer): """Enable or disable keywords editor icon when active layer changes. :param layer: The layer that is now active. :type layer: QgsMapLayer """ if not layer: enable_keyword_wizard = False elif not hasattr(layer, 'providerType'): enable_keyword_wizard = False elif layer.providerType() == 'wms': enable_keyword_wizard = False else: enable_keyword_wizard = True try: if layer: if is_raster_layer(layer): enable_field_mapping_tool = False else: keywords = KeywordIO().read_keywords(layer) keywords_version = keywords.get('keyword_version') if not keywords_version: supported = False else: supported = ( is_keyword_version_supported(keywords_version)) if not supported: enable_field_mapping_tool = False else: layer_purpose = keywords.get('layer_purpose') if not layer_purpose: enable_field_mapping_tool = False else: if layer_purpose == layer_purpose_exposure['key']: layer_subcategory = keywords.get('exposure') elif layer_purpose == layer_purpose_hazard['key']: layer_subcategory = keywords.get('hazard') else: layer_subcategory = None field_groups = get_field_groups( layer_purpose, layer_subcategory) if len(field_groups) == 0: # No field group, disable field mapping tool. enable_field_mapping_tool = False else: enable_field_mapping_tool = True else: enable_field_mapping_tool = False except (KeywordNotFoundError, NoKeywordsFoundError, MetadataReadError): # No keywords, disable field mapping tool. enable_field_mapping_tool = False self.action_keywords_wizard.setEnabled(enable_keyword_wizard) self.action_field_mapping.setEnabled(enable_field_mapping_tool) def shortcut_f7(self): """Executed when user press F7 - will show the shakemap importer.""" self.show_shakemap_importer()
class PolygonMapWindow(QMainWindow): """Open a map window where the user can draw a polygon and use it to crop data. Shares a lot of similarities with MapWindow calss, but there're enough differences that I decided not to inherit from it.""" # signal emitted when polygons succesfully selected finished = pyqtSignal() 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 pan(self): """Simply activates the tool""" self.canvas.setMapTool(self.toolPan) # make sure the other button isn't checked to avoid confusion self.actionDraw.setChecked(False) def draw(self): """Activates draw tool""" self.canvas.setMapTool(self.toolDraw) self.actionPan.setChecked(False) def clear(self): self.toolDraw.reset() def connect(self): """Calls the polygon tool to connect an unconnected polygon""" self.toolDraw.finishPolygon() def finishedSelection(self): """Activated when user clicks 'returns selection'. Closes window and emits signal to indicate the job is finished""" self.close() self.finished.emit() def cancel(self): """In case user changes their mind. Does the same as above, but doesn't emit signal.""" self.close() def showCanvas(self): """Shows the map canvas with a vector background map for reference""" """ url = ("http://86.50.168.160/geoserver/ows?service=wfs&version=2.0.0"+ "&request=GetFeature&typename=ogiir:maakuntajako_2018_4500k&pagingEnabled=true") #self.bg_layer = QgsVectorLayer(url, "BACKGROUND-REMOVE", "WFS") """ self.bg_layer = QgsRasterLayer( "url=http://86.50.168.160/ogiir_cache/wmts/1.0.0/" + "WMTSCapabilities.xml&crs=EPSG:3067&dpiMode=7&format=image/" + "png&layers=taustakartta&styles=default&tileMatrixSet=GRIDI-FIN", 'GEOCUBES POLYGON BG-LAYER - TEMPORARY', 'wms') if self.bg_layer.isValid(): QgsProject.instance().addMapLayer(self.bg_layer, False) self.canvas.setExtent(self.bg_layer.extent()) self.canvas.setLayers([self.bg_layer]) self.show() def closeEvent(self, event): """Activated anytime Mapwindow is closed either programmatically or if the user finds some other way to close the window. Automatically finishes the polygon if it's unconnected.""" try: QgsProject.instance().removeMapLayer(self.bg_layer) except Exception: pass self.toolDraw.finishPolygon() QMainWindow.closeEvent(self, event) def getPolygon(self): return self.toolDraw.getPoints() def getPolygonBbox(self): return self.toolDraw.getPolyBbox()
class LockZoomToTiles: def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.epsg3857 = QgsCoordinateReferenceSystem('EPSG:3857') self.epsg4326 = QgsCoordinateReferenceSystem('EPSG:4326') self.islocking = False def initGui(self): '''Initialize Lock Zoom to Tiles GUI.''' icon = QIcon() icon.addFile(os.path.dirname(__file__) + "/images/zoomUnlocked.png", state=QIcon.Off) icon.addFile(os.path.dirname(__file__) + "/images/zoomLocked.png", state=QIcon.On) self.action = QAction(icon, "Lock zoom scale", self.iface.mainWindow()) self.action.setObjectName('lockZoom') self.action.triggered.connect(self.lockIt) self.action.setCheckable(True) self.iface.addPluginToMenu("Lock zoom to tile scale", self.action) self.iface.addToolBarIcon(self.action) icon = QIcon(os.path.dirname(__file__) + '/images/help.png') self.helpAction = QAction(icon, "Help", self.iface.mainWindow()) self.helpAction.triggered.connect(self.help) self.iface.addPluginToMenu('Lock zoom to tile scale', self.helpAction) self.checkCrs() self.canvas.destinationCrsChanged.connect(self.checkCrs) self.canvas.layersChanged.connect(self.checkCrs) def unload(self): '''Unload from the QGIS interface''' self.iface.removePluginMenu('Lock zoom to tile scale', self.action) self.iface.removeToolBarIcon(self.action) self.iface.removePluginMenu("Lock zoom to tile scale", self.helpAction) self.canvas.destinationCrsChanged.disconnect(self.checkCrs) if self.islocking == True: try: self.canvas.scaleChanged.disconnect(self.lockIt) except Exception: pass def help(self): '''Display a help page''' url = QUrl.fromLocalFile(os.path.dirname(__file__) + "/index.html").toString() webbrowser.open(url, new=2) def lockIt(self): '''Set the focus of the copy coordinate tool''' if self.action.isChecked(): self.zoomTo() if self.islocking == False: self.islocking = True self.canvas.scaleChanged.connect(self.zoomTo) self.action.setText("Unlock zoom scale") self.action.setIconText("Unlock zoom scale") else: if self.islocking == True: self.canvas.scaleChanged.disconnect(self.zoomTo) self.islocking = False self.action.setText("Lock zoom scale") self.action.setIconText("Lock zoom scale") def zoomTo(self): crs = self.canvas.mapSettings().destinationCrs() mupp = self.canvas.mapUnitsPerPixel() if crs == self.epsg3857: r = 0 for i in range(0, len(r3857)): r = i if r3857[i] > mupp: if i > 0 and (r3857[i] - mupp > mupp - r3857[i - 1]): r = i - 1 break if not math.isclose(r3857[r], mupp, rel_tol=1e-5): self.canvas.zoomByFactor(r3857[r] / self.canvas.mapUnitsPerPixel()) else: r = 0 for i in range(0, len(r4326)): r = i if r4326[i] > mupp: if i > 0 and (r4326[i] - mupp > mupp - r4326[i - 1]): r = i - 1 break if not math.isclose(r4326[r], mupp, rel_tol=1e-5): self.canvas.zoomByFactor(r4326[r] / self.canvas.mapUnitsPerPixel()) def checkCrs(self): crs = self.canvas.mapSettings().destinationCrs() numlayers = self.canvas.layerCount() if (crs == self.epsg3857 or crs == self.epsg4326) and numlayers > 0: self.action.setEnabled(True) else: self.action.setEnabled(False) self.action.setChecked(False) self.lockIt()
class SplinePlugin(object): def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.plugin_dir = os.path.dirname(__file__) self.proc_provider = None locale = QSettings().value("locale/userLocale")[0:2] locale_path = os.path.join(self.plugin_dir, "i18n", "splineplugin_{}.qm".format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) QCoreApplication.installTranslator(self.translator) self.tool = SplineTool(self.iface) self.connected_layer = None self.settings_dialog = None self.action_settings = None self.action_spline = None def initProcessing(self): self.proc_provider = proc_provider() QgsApplication.processingRegistry().addProvider(self.proc_provider) def initGui(self): self.initProcessing() self.action_settings = QAction( QCoreApplication.translate("Spline", "Settings"), self.iface.mainWindow()) self.action_settings.setObjectName("splineAction") self.action_settings.triggered.connect(self.open_settings) self.iface.addPluginToVectorMenu(u"Digitize Spline", self.action_settings) ico = QIcon(icon_path("icon.png")) self.action_spline = QAction( ico, QCoreApplication.translate("spline", "Digitize Splines"), self.iface.mainWindow(), ) self.action_spline.setObjectName("actionSpline") self.action_spline.setEnabled(False) self.action_spline.setCheckable(True) # Connect to signals for button behaviour self.action_spline.triggered.connect(self.digitize) self.iface.currentLayerChanged.connect(self.layer_changed) self.layer_changed() # to enable when plugin is loaded self.canvas.mapToolSet.connect(self.deactivate) # Add actions to the toolbar self.iface.addToolBarIcon(self.action_spline) def unload(self): QgsApplication.processingRegistry().removeProvider(self.proc_provider) self.iface.removeToolBarIcon(self.action_spline) self.iface.removePluginVectorMenu(u"Digitize Spline", self.action_settings) def open_settings(self): self.settings_dialog = SettingsDialog() self.settings_dialog.changed.connect(self.settings_changed) self.settings_dialog.show() def digitize(self): self.canvas.setMapTool(self.tool) self.action_spline.setChecked(True) def is_active_layer_for_spline(self): layer = self.iface.activeLayer() if layer is None: return False if layer.type() != QgsMapLayerType.VectorLayer: return False if not layer.geometryType() in ( QgsWkbTypes.LineGeometry, QgsWkbTypes.PolygonGeometry, ): return False return True def enable_action(self): self.action_spline.setEnabled(False) self.action_spline.setChecked(False) if self.is_active_layer_for_spline(): if self.iface.activeLayer().isEditable(): self.action_spline.setEnabled(True) def layer_changed(self): self.deactivate() self.tool.deactivate() self.enable_action() self.connect_layer() def connect_layer(self): self.disconnect_layer() if not self.is_active_layer_for_spline(): return layer = self.iface.activeLayer() if layer is None: return self.connected_layer = layer layer.editingStopped.connect(self.enable_action) layer.editingStarted.connect(self.enable_action) def disconnect_layer(self): try: self.connected_layer.editingStopped.disconnect(self.enable_action) self.connected_layer.editingStarted.disconnect(self.enable_action) except (RuntimeError, AttributeError, TypeError): pass self.connected_layer = None def deactivate(self): self.tool.deactivate() self.action_spline.setChecked(False) def settings_changed(self): self.tool.refresh()
class ProfilesPlugin(object): def __init__(self, iface): self.iface = iface QSettings().setValue('/UI/Customization/enabled', False) try: from profiles.tests import testerplugin from qgistester.tests import addTestModule addTestModule(testerplugin, 'Profiles plugin') except: pass self.userProfileAction = None self.profilesMenu = None iface.initializationCompleted.connect(self.initProfile) def unload(self): if self.profilesMenu is not None: self.profilesMenu.deleteLater() self.iface.removePluginMenu(self.tr('Profiles'), self.autoloadAction) self.iface.removePluginMenu(self.tr('Profiles'), self.saveProfileAction) try: from profiles.tests import testerplugin from qgistester.tests import removeTestModule removeTestModule(testerplugin, 'Profiles plugin') except: pass saveCurrentPluginState() def initGui(self): self.addMenus() def addMenus(self): if self.profilesMenu is not None: self.profilesMenu.clear() self.actions = defaultdict(list) settings = QSettings() defaultProfile = settings.value('profilesplugin/LastProfile', 'Default', str) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) for k, v in profiles.items(): action = QAction(k, self.iface.mainWindow()) action.setCheckable(True) if k == defaultProfile and autoLoad: action.setChecked(True) action.triggered.connect(lambda _, menuName=k: self.applyProfile(menuName)) action.setObjectName('mProfilesPlugin_' + k) self.actions[v.group].append(action) actions = self.iface.mainWindow().menuBar().actions() settingsMenu = None self.profilesGroup = QActionGroup(self.iface.mainWindow()) if self.profilesMenu is None: for action in actions: if action.menu().objectName() == 'mSettingsMenu': settingsMenu = action.menu() self.profilesMenu = QMenu(settingsMenu) self.profilesMenu.setObjectName('mProfilesPlugin') self.profilesMenu.setTitle(self.tr('Profiles')) settingsMenu.addMenu(self.profilesMenu) break if self.profilesMenu is not None: for k,v in self.actions.items(): submenu = QMenu(self.profilesMenu) submenu.setObjectName('mProfilesPlugin_submenu_' + k) submenu.setTitle(k) for action in v: self.profilesGroup.addAction(action) submenu.addAction(action) self.profilesMenu.addMenu(submenu) self.profilesMenu.addSeparator() settings = QSettings() def _setAutoLoad(): settings.setValue('profilesplugin/AutoLoad', self.autoloadAction.isChecked()) self.autoloadAction = QAction(self.tr('Auto-load last profile on QGIS start'), iface.mainWindow()) self.autoloadAction.setCheckable(True) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) self.autoloadAction.setChecked(autoLoad) self.autoloadAction.setObjectName('mProfilesPluginAutoLoad') self.autoloadAction.triggered.connect(_setAutoLoad) self.profilesMenu.addAction(self.autoloadAction) self.saveProfileAction = QAction(self.tr('Profiles manager...'), self.iface.mainWindow()) self.saveProfileAction.setObjectName('mProfilesPluginProfilesManager') self.saveProfileAction.triggered.connect(self.saveProfile) self.profilesMenu.addAction(self.saveProfileAction) self.showHelpAction = QAction(self.tr('Help'), self.iface.mainWindow()) self.showHelpAction.setIcon(QgsApplication.getThemeIcon('/mActionHelpContents.svg')) self.showHelpAction.setObjectName('mProfilesPluginShowHelp') self.showHelpAction.triggered.connect(self.showHelp) self.profilesMenu.addAction(self.showHelpAction) def applyProfile(self, name): profile = profiles.get(name) applyProfile(profile) def initProfile(self): settings = QSettings() autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) if autoLoad: profileName = settings.value('profilesplugin/LastProfile', '', str) if profileName in profiles: profile = profiles[profileName] if not profile.hasToInstallPlugins(): applyProfile(profile, False) def saveProfile(self): dlg = ProfileManager(iface.mainWindow()) dlg.exec_() def showHelp(self): if not QDesktopServices.openUrl( QUrl('file://{}'.format(os.path.join(pluginPath, 'docs', 'html', 'index.html')))): QMessageBox.warning(None, self.tr('Error'), self.tr('Can not open help URL in browser')) def tr(self, text): return QCoreApplication.translate('Profiles', text)
class proposalsPanel(RestrictionTypeUtilsMixin): def __init__(self, iface, TOMsToolBar): #def __init__(self, iface, TOMsMenu, proposalsManager): # Save reference to the QGIS interface self.iface = iface self.canvas = self.iface.mapCanvas() self.TOMsToolBar = TOMsToolBar self.actionProposalsPanel = QAction( QIcon(":/plugins/TOMs/resources/TOMsStart.png"), QCoreApplication.translate("MyPlugin", "Start TOMs"), self.iface.mainWindow()) self.actionProposalsPanel.setCheckable(True) self.TOMsToolBar.addAction(self.actionProposalsPanel) self.actionProposalsPanel.triggered.connect(self.onInitProposalsPanel) self.newProposalRequired = False self.proposalsManager = TOMsProposalsManager(self.iface) self.tableNames = self.proposalsManager.tableNames # Now set up the toolbar self.RestrictionTools = manageRestrictionDetails( self.iface, self.TOMsToolBar, self.proposalsManager) self.RestrictionTools.disableTOMsToolbarItems() self.searchBar = searchBar(self.iface, self.TOMsToolBar, self.proposalsManager) self.searchBar.disableSearchBar() TOMsMessageLog.logMessage("Finished proposalsPanel init ...", level=Qgis.Warning) def onInitProposalsPanel(self): """Filter main layer based on date and state options""" TOMsMessageLog.logMessage("In onInitProposalsPanel", level=Qgis.Info) #print "** STARTING ProposalPanel" # dockwidget may not exist if: # first run of plugin # removed on close (see self.onClosePlugin method) # self.TOMSLayers.TOMsStartupFailure.connect(self.setCloseTOMsFlag) #self.RestrictionTypeUtilsMixin.tableNames.TOMsStartupFailure.connect(self.closeTOMsTools) if self.actionProposalsPanel.isChecked(): TOMsMessageLog.logMessage( "In onInitProposalsPanel. Activating ...", level=Qgis.Info) self.openTOMsTools() else: TOMsMessageLog.logMessage( "In onInitProposalsPanel. Deactivating ...", level=Qgis.Info) self.closeTOMsTools() pass def openTOMsTools(self): # actions when the Proposals Panel is closed or the toolbar "start" is toggled TOMsMessageLog.logMessage("In openTOMsTools. Activating ...", level=Qgis.Info) self.closeTOMs = False # Check that tables are present TOMsMessageLog.logMessage("In onInitProposalsPanel. Checking tables", level=Qgis.Info) self.tableNames.TOMsLayersNotFound.connect(self.setCloseTOMsFlag) self.tableNames.getLayers() if self.closeTOMs: QMessageBox.information(self.iface.mainWindow(), "ERROR", ("Unable to start TOMs ...")) self.actionProposalsPanel.setChecked(False) return # QMessageBox.information(self.iface.mainWindow(), "ERROR", ("TOMsActivated about to emit")) self.proposalsManager.TOMsActivated.emit() self.dock = ProposalPanelDockWidget() self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock) # set up tabbing for Panels self.setupPanelTabs(self.iface, self.dock) self.proposalsManager.dateChanged.connect(self.onDateChanged) self.dock.filterDate.setDisplayFormat("dd-MM-yyyy") self.dock.filterDate.setDate(QDate.currentDate()) self.Proposals = self.tableNames.setLayer("Proposals") # Set up field details for table ** what about errors here ** idxProposalID = self.Proposals.fields().indexFromName("ProposalID") self.idxProposalTitle = self.Proposals.fields().indexFromName( "ProposalTitle") self.idxCreateDate = self.Proposals.fields().indexFromName( "ProposalCreateDate") self.idxOpenDate = self.Proposals.fields().indexFromName( "ProposalOpenDate") self.idxProposalStatusID = self.Proposals.fields().indexFromName( "ProposalStatusID") self.createProposalcb() # set CurrentProposal to be 0 #self.proposalsManager.setCurrentProposal(0) # set up action for when the date is changed from the user interface self.dock.filterDate.dateChanged.connect( lambda: self.proposalsManager.setDate(self.dock.filterDate.date())) # set up action for "New Proposal" self.dock.btn_NewProposal.clicked.connect(self.onNewProposal) # set up action for "View Proposal" self.dock.btn_ViewProposal.clicked.connect(self.onProposalDetails) self.proposalsManager.newProposalCreated.connect( self.onNewProposalCreated) # Create a transaction object for the Proposals self.proposalTransaction = TOMsTransaction(self.iface, self.proposalsManager) self.RestrictionTools.enableTOMsToolbarItems(self.proposalTransaction) self.searchBar.enableSearchBar() # setup use of "Escape" key to deactive map tools - https://gis.stackexchange.com/questions/133228/how-to-deactivate-my-custom-tool-by-pressing-the-escape-key-using-pyqgis """shortcutEsc = QShortcut(QKeySequence(Qt.Key_Escape), self.iface.mainWindow()) shortcutEsc.setContext(Qt.ApplicationShortcut) shortcutEsc.activated.connect(self.iface.mapCanvas().unsetMapTool(self.mapTool))""" self.proposalsManager.setCurrentProposal(0) # TODO: Deal with the change of project ... More work required on this # self.TOMsProject = QgsProject.instance() # self.TOMsProject.cleared.connect(self.closeTOMsTools) def setCloseTOMsFlag(self): self.closeTOMs = True def closeTOMsTools(self): # actions when the Proposals Panel is closed or the toolbar "start" is toggled TOMsMessageLog.logMessage("In closeTOMsTools. Deactivating ...", level=Qgis.Info) # TODO: Delete any objects that are no longer needed self.proposalTransaction.rollBackTransactionGroup() del self.proposalTransaction # There is another call to this function from the dock.close() # Now disable the items from the Toolbar self.RestrictionTools.disableTOMsToolbarItems() self.searchBar.disableSearchBar() self.actionProposalsPanel.setChecked(False) # Now close the proposals panel self.dock.close() # Now clear the filters self.proposalsManager.clearRestrictionFilters() pass def createProposalcb(self): TOMsMessageLog.logMessage("In createProposalcb", level=Qgis.Info) # set up a "NULL" field for "No proposals to be shown" #self.dock.cb_ProposalsList.currentIndexChanged.connect(self.onProposalListIndexChanged) #self.dock.cb_ProposalsList.currentIndexChanged.disconnect(self.onProposalListIndexChanged) self.dock.cb_ProposalsList.clear() currProposalID = 0 currProposalTitle = "0 - No proposal shown" TOMsMessageLog.logMessage("In createProposalcb: Adding 0", level=Qgis.Info) self.dock.cb_ProposalsList.addItem(currProposalTitle, currProposalID) for (currProposalID, currProposalTitle, currProposalStatusID, currProposalOpenDate, currProposal) in sorted( self.proposalsManager.getProposalsListWithStatus( ProposalStatus.IN_PREPARATION), key=lambda f: f[1]): TOMsMessageLog.logMessage("In createProposalcb: proposalID: " + str(currProposalID) + ":" + currProposalTitle, level=Qgis.Info) self.dock.cb_ProposalsList.addItem(currProposalTitle, currProposalID) # set up action for when the proposal is changed self.dock.cb_ProposalsList.currentIndexChanged.connect( self.onProposalListIndexChanged) def onChangeProposal(self): TOMsMessageLog.logMessage("In onChangeProposal", level=Qgis.Info) # https://gis.stackexchange.com/questions/94135/how-to-populate-a-combobox-with-layers-in-toc newProposal_cbIndex = self.dock.cb_ProposalsList.currentIndex() newProposalID = self.dock.cb_ProposalsList.itemData( newProposal_cbIndex) newProposalTitle = self.dock.cb_ProposalsList.currentText() self.setCurrentProposal(newProposalID) TOMsMessageLog.logMessage("In onChangeProposal. newProposalID: " + str(newProposalID) + " newProposalTitle: " + str(newProposalTitle), level=Qgis.Info) # Set the project variable reply = QMessageBox.information(self.iface.mainWindow(), "Information", "All changes will be rolled back", QMessageBox.Ok) def onNewProposal(self): TOMsMessageLog.logMessage("In onNewProposal", level=Qgis.Info) # set up a transaction self.proposalTransaction.startTransactionGroup() # create a new Proposal """self.newProposal = QgsFeature(self.Proposals.fields()) #newProposal.setGeometry(QgsGeometry()) self.newProposal[self.idxProposalTitle] = '' #str(uuid.uuid4()) self.newProposal[self.idxCreateDate] = self.proposalsManager.date() self.newProposal[self.idxOpenDate] = self.proposalsManager.date() self.newProposal[self.idxProposalStatusID] = ProposalStatus.IN_PREPARATION self.newProposal.setGeometry(QgsGeometry()) self.Proposals.addFeature(self.newProposal) # TH (added for v3)""" self.newProposalObject = self.proposalsManager.currentProposalObject( ).initialiseProposal() self.newProposal = self.proposalsManager.currentProposalObject( ).getProposalRecord() self.proposalDialog = self.iface.getFeatureForm( self.Proposals, self.newProposal) #self.proposalDialog.attributeForm().disconnectButtonBox() self.button_box = self.proposalDialog.findChild( QDialogButtonBox, "button_box") if self.button_box is None: TOMsMessageLog.logMessage("In onNewProposal. button box not found", level=Qgis.Info) #self.button_box.accepted.disconnect() self.button_box.accepted.connect( functools.partial(self.onSaveProposalFormDetails, self.newProposal, self.newProposalObject, self.Proposals, self.proposalDialog, self.proposalTransaction)) #self.button_box.rejected.disconnect() self.button_box.rejected.connect(self.onRejectProposalDetailsFromForm) self.proposalDialog.attributeForm().attributeChanged.connect( functools.partial(self.onAttributeChangedClass2, self.newProposal, self.Proposals)) self.proposalDialog.show() #self.iface.openFeatureForm(self.Proposals, newProposal, False, True) #self.createProposalcb() pass def onNewProposalCreated(self, proposal): TOMsMessageLog.logMessage("In onNewProposalCreated. New proposal = " + str(proposal), level=Qgis.Info) self.createProposalcb() # change the list to show the new proposal for currIndex in range(self.dock.cb_ProposalsList.count()): currProposalID = self.dock.cb_ProposalsList.itemData(currIndex) #TOMsMessageLog.logMessage("In onNewProposalSaved. checking index = " + str(currIndex), level=Qgis.Info) if currProposalID == proposal: TOMsMessageLog.logMessage( "In onNewProposalCreated. index found as " + str(currIndex), level=Qgis.Info) self.dock.cb_ProposalsList.setCurrentIndex(currIndex) return return #def onSaveProposalDetailsFromForm(self): #self.onSaveProposalFormDetails(self.newProposal, self.Proposals, self.proposalDialog, self.currTransaction) def onRejectProposalDetailsFromForm(self): self.Proposals.destroyEditCommand() self.proposalDialog.reject() #self.rollbackCurrentEdits() self.proposalTransaction.rollBackTransactionGroup() pass def onProposalDetails(self): TOMsMessageLog.logMessage("In onProposalDetails", level=Qgis.Info) # set up transaction self.proposalTransaction.startTransactionGroup() # https://gis.stackexchange.com/questions/94135/how-to-populate-a-combobox-with-layers-in-toc currProposal_cbIndex = self.dock.cb_ProposalsList.currentIndex() if currProposal_cbIndex == 0: return # there is nothing to see currProposalID = self.dock.cb_ProposalsList.itemData( currProposal_cbIndex) # self.currProposal = self.getProposal(currProposalID) self.currProposalObject = self.proposalsManager.currentProposalObject() self.currProposal = self.proposalsManager.currentProposalObject( ).getProposalRecord() self.proposalDialog = self.iface.getFeatureForm( self.Proposals, self.currProposal) #self.proposalDialog.attributeForm().disconnectButtonBox() self.button_box = self.proposalDialog.findChild( QDialogButtonBox, "button_box") if self.button_box is None: TOMsMessageLog.logMessage("In onNewProposal. button box not found", level=Qgis.Info) self.button_box.accepted.disconnect() self.button_box.accepted.connect( functools.partial(self.onSaveProposalFormDetails, self.currProposal, self.currProposalObject, self.Proposals, self.proposalDialog, self.proposalTransaction)) self.button_box.rejected.disconnect() self.button_box.rejected.connect(self.onRejectProposalDetailsFromForm) self.proposalDialog.attributeForm().attributeChanged.connect( functools.partial(self.onAttributeChangedClass2, self.currProposal, self.Proposals)) self.proposalDialog.show() pass def onProposalListIndexChanged(self): TOMsMessageLog.logMessage("In onProposalListIndexChanged.", level=Qgis.Info) #currProposal = self.proposalsManager.currentProposal() #currProposalIdx = self.dock.cb_ProposalsList.findData(currProposal) #self.dock.cb_ProposalsList.setCurrentIndex(currProposalIdx) currProposal_cbIndex = self.dock.cb_ProposalsList.currentIndex() TOMsMessageLog.logMessage( "In onProposalListIndexChanged. Current Index = " + str(currProposal_cbIndex), level=Qgis.Info) currProposalID = self.dock.cb_ProposalsList.itemData( currProposal_cbIndex) self.proposalsManager.setCurrentProposal(currProposalID) TOMsMessageLog.logMessage("In onProposalChanged. Zoom to extents", level=Qgis.Info) """if self.proposalsManager.getProposalBoundingBox(): TOMsMessageLog.logMessage("In onProposalChanged. Bounding box found", level=Qgis.Info) self.iface.mapCanvas().setExtent(self.proposalsManager.getProposalBoundingBox()) self.iface.mapCanvas().refresh()""" def updateCurrentProposal(self): TOMsMessageLog.logMessage("In updateCurrentProposal.", level=Qgis.Info) """Will be called whenever a new entry is selected in the combobox""" # Can we check to see if there are any outstanding edits?!! """reply = QMessageBox.information(self.iface.mainWindow(), "Information", "All changes will be rolled back", QMessageBox.Ok) if reply: self.iface.actionRollbackAllEdits().trigger() self.iface.actionCancelAllEdits().trigger() pass""" currProposal_cbIndex = self.dock.cb_ProposalsList.currentIndex() currProposalID = self.dock.cb_ProposalsList.itemData( currProposal_cbIndex) self.proposalsManager.setCurrentProposal(currProposalID) def onDateChanged(self): TOMsMessageLog.logMessage("In onDateChanged.", level=Qgis.Info) date = self.proposalsManager.date() self.dock.filterDate.setDate(date) """ onChangeProposalStatus(self): TOMsMessageLog.logMessage("In onChangeProposalStatus. Proposed status: " + str(self.Proposals.fields().indexFromName("ProposalStatusID")), level=Qgis.Info) # check to see if the proposal is "Accepted" acceptProposal = False newProposalStatus = int(self.Proposals.fields().indexFromName("ProposalStatusID")) if newProposalStatus == 1: # should be 2 but with list ... # if so, check to see if this was intended reply = QMessageBox.question(self.iface.mainWindow(), 'Confirm changes to Proposal', 'Are you you want to accept this proposal?. Accepting will make all the proposed changes permanent.', QMessageBox.Yes, QMessageBox.No) if reply == QMessageBox.Yes: # make the changes permanent acceptProposal = True # bring the Proposals dislog back to the front self.dlg.activateWindow() return acceptProposal""" """def getRestrictionLayerTableID(self, currRestLayer): TOMsMessageLog.logMessage("In getRestrictionLayerTableID.", level=Qgis.Info) # find the ID for the layer within the table " RestrictionsLayers = QgsMapLayerRegistry.instance().mapLayersByName("RestrictionLayers2")[0] layersTableID = 0 # not sure if there is better way to search for something, .e.g., using SQL ?? for layer in RestrictionsLayers.getFeatures(): if layer.attribute("RestrictionLayerName") == str(currRestLayer.name()): layersTableID = layer.attribute("id") TOMsMessageLog.logMessage("In getRestrictionLayerTableID. layersTableID: " + str(layersTableID), level=Qgis.Info) return layersTableID""" def getProposal(self, proposalID): TOMsMessageLog.logMessage("In getProposal.", level=Qgis.Info) # proposalsLayer = QgsMapLayerRegistry.instance().mapLayersByName("Proposals")[0] -- v2 proposalsLayer = QgsProject.instance().mapLayersByName("Proposals")[0] # not sure if there is better way to search for something, .e.g., using SQL ?? for currProposal in proposalsLayer.getFeatures(): if currProposal.attribute("ProposalID") == proposalID: return currProposal return None pass
class ProcessingPlugin: def __init__(self, iface): self.iface = iface self.options_factory = ProcessingOptionsFactory() self.options_factory.setTitle(self.tr('Processing')) iface.registerOptionsWidgetFactory(self.options_factory) self.drop_handler = ProcessingDropHandler() iface.registerCustomDropHandler(self.drop_handler) self.item_provider = ProcessingDataItemProvider() QgsApplication.dataItemProviderRegistry().addProvider( self.item_provider) self.locator_filter = AlgorithmLocatorFilter() iface.registerLocatorFilter(self.locator_filter) # Invalidate the locator filter for in-place when active layer changes iface.currentLayerChanged.connect( lambda _: self.iface.invalidateLocatorResults()) self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter() iface.registerLocatorFilter(self.edit_features_locator_filter) Processing.initialize() def initGui(self): self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged) self.resultsDock = ResultsDock() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock) self.resultsDock.hide() self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow()) self.toolboxAction.setCheckable(True) self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QgsApplication.getThemeIcon("/processingAlgorithm.svg")) self.iface.registerMainWindowAction( self.toolboxAction, QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText)) self.toolboxAction.toggled.connect(self.openToolbox) self.iface.attributesToolBar().insertAction( self.iface.actionOpenStatisticalSummary(), self.toolboxAction) self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QgsApplication.getThemeIcon("/processingModel.svg"), QCoreApplication.translate('ProcessingPlugin', 'Graphical &Modeler…'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction( self.modelerAction, QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText)) self.menu.addAction(self.modelerAction) self.historyAction = QAction( QgsApplication.getThemeIcon("/mIconHistory.svg"), QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction( self.historyAction, QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText)) self.menu.addAction(self.historyAction) self.toolbox.processingToolbar.addAction(self.historyAction) self.resultsAction = QAction( QgsApplication.getThemeIcon("/processingResult.svg"), self.tr('&Results Viewer'), self.iface.mainWindow()) self.resultsAction.setCheckable(True) self.iface.registerMainWindowAction( self.resultsAction, QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText)) self.menu.addAction(self.resultsAction) self.toolbox.processingToolbar.addAction(self.resultsAction) self.resultsDock.visibilityChanged.connect( self.resultsAction.setChecked) self.resultsAction.toggled.connect(self.resultsDock.setUserVisible) self.toolbox.processingToolbar.addSeparator() self.editInPlaceAction = QAction( QgsApplication.getThemeIcon("/mActionProcessSelected.svg"), self.tr('Edit Features In-Place'), self.iface.mainWindow()) self.editInPlaceAction.setObjectName('editInPlaceFeatures') self.editInPlaceAction.setCheckable(True) self.editInPlaceAction.toggled.connect(self.editSelected) self.menu.addAction(self.editInPlaceAction) self.toolbox.processingToolbar.addAction(self.editInPlaceAction) self.toolbox.processingToolbar.addSeparator() self.optionsAction = QAction( QgsApplication.getThemeIcon("/mActionOptions.svg"), self.tr('Options'), self.iface.mainWindow()) self.optionsAction.setObjectName('optionsAction') self.optionsAction.triggered.connect(self.openProcessingOptions) self.toolbox.processingToolbar.addAction(self.optionsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(), self.menu) self.menu.addSeparator() initializeMenus() createMenus() # In-place editing button state sync self.iface.currentLayerChanged.connect(self.sync_in_place_button_state) self.iface.mapCanvas().selectionChanged.connect( self.sync_in_place_button_state) self.iface.actionToggleEditing().triggered.connect( partial(self.sync_in_place_button_state, None)) self.sync_in_place_button_state() def sync_in_place_button_state(self, layer=None): """Synchronise the button state with layer state""" if layer is None: layer = self.iface.activeLayer() old_enabled_state = self.editInPlaceAction.isEnabled() new_enabled_state = layer is not None and layer.type( ) == QgsMapLayer.VectorLayer self.editInPlaceAction.setEnabled(new_enabled_state) if new_enabled_state != old_enabled_state: self.toolbox.set_in_place_edit_mode( new_enabled_state and self.editInPlaceAction.isChecked()) def openProcessingOptions(self): self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions') def unload(self): self.toolbox.setVisible(False) self.iface.removeDockWidget(self.toolbox) self.iface.attributesToolBar().removeAction(self.toolboxAction) self.resultsDock.setVisible(False) self.iface.removeDockWidget(self.resultsDock) self.toolbox.deleteLater() self.menu.deleteLater() # delete temporary output files folder = QgsProcessingUtils.tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) # also delete temporary help files folder = tempHelpFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.toolboxAction) self.iface.unregisterMainWindowAction(self.modelerAction) self.iface.unregisterMainWindowAction(self.historyAction) self.iface.unregisterMainWindowAction(self.resultsAction) self.iface.unregisterOptionsWidgetFactory(self.options_factory) self.iface.deregisterLocatorFilter(self.locator_filter) self.iface.deregisterLocatorFilter(self.edit_features_locator_filter) self.iface.unregisterCustomDropHandler(self.drop_handler) QgsApplication.dataItemProviderRegistry().removeProvider( self.item_provider) removeMenus() Processing.deinitialize() def openToolbox(self, show): self.toolbox.setUserVisible(show) def toolboxVisibilityChanged(self, visible): self.toolboxAction.setChecked(visible) def openModeler(self): dlg = ModelerDialog() dlg.update_model.connect(self.updateModel) dlg.show() def updateModel(self): model_provider = QgsApplication.processingRegistry().providerById( 'model') model_provider.refreshAlgorithms() def openResults(self): if self.resultsDock.isVisible(): self.resultsDock.hide() else: self.resultsDock.show() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def tr(self, message): return QCoreApplication.translate('ProcessingPlugin', message) def editSelected(self, enabled): self.toolbox.set_in_place_edit_mode(enabled)
class ShapeTools(object): def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.settingsDialog = None self.xyLineDialog = None self.geodesicDensifyDialog = None self.azDigitizerTool = None self.lineDigitizerTool = None self.previousLayer = None self.toolbar = self.iface.addToolBar('Shape Tools Toolbar') self.toolbar.setObjectName('ShapeToolsToolbar') self.provider = ShapeToolsProvider() # Initialize the plugin path directory self.plugin_dir = os.path.dirname(__file__) # initialize locale try: locale = QSettings().value("locale/userLocale", "en", type=str)[0:2] except Exception: locale = "en" locale_path = os.path.join(self.plugin_dir, 'i18n', 'shapeTools_{}.qm'.format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) QCoreApplication.installTranslator(self.translator) def initGui(self): self.azDigitizerTool = AzDigitizerTool(self.iface) self.lineDigitizerTool = LineDigitizerTool(self.iface) # Initialize the create shape menu items menu = QMenu() # Initialize Create Arc Wedge tool icon = QIcon(self.plugin_dir + '/images/arc.png') self.createArcAction = menu.addAction(icon, tr('Create arc wedge'), self.createArc) self.createArcAction.setObjectName('stCreateArcWedge') icon = QIcon(self.plugin_dir + '/images/donut.png') self.createDonutAction = menu.addAction(icon, tr('Create donut'), self.createDonut) self.createDonutAction.setObjectName('stCreateDonut') icon = QIcon(self.plugin_dir + '/images/ellipse.png') self.createEllipseAction = menu.addAction(icon, tr('Create ellipse'), self.createEllipse) self.createEllipseAction.setObjectName('stCreateEllipse') icon = QIcon(self.plugin_dir + '/images/rose.png') self.createEllipseRoseAction = menu.addAction( icon, tr('Create ellipse rose'), self.createEllipseRose) self.createEllipseRoseAction.setObjectName('stCreateEllipseRose') icon = QIcon(self.plugin_dir + '/images/epicycloid.png') self.createEpicycloidAction = menu.addAction(icon, tr('Create epicycloid'), self.createEpicycloid) self.createEpicycloidAction.setObjectName('stCreateEpicycloid') icon = QIcon(self.plugin_dir + '/images/heart.png') self.createHeartAction = menu.addAction(icon, tr('Create heart'), self.createHeart) self.createHeartAction.setObjectName('stCreateHeart') icon = QIcon(self.plugin_dir + '/images/hypocycloid.png') self.createHypocycloidAction = menu.addAction(icon, tr('Create hypocycloid'), self.createHypocycloid) self.createHypocycloidAction.setObjectName('stCreateHypocycloid') icon = QIcon(self.plugin_dir + '/images/line.png') self.createLOBAction = menu.addAction(icon, tr('Create line of bearing'), self.createLOB) self.createLOBAction.setObjectName('stCreateLineOfBearing') icon = QIcon(self.plugin_dir + '/images/pie.png') self.createPieAction = menu.addAction(icon, tr('Create pie wedge'), self.createPie) self.createPieAction.setObjectName('stCreatePie') icon = QIcon(self.plugin_dir + '/images/polyfoil.png') self.createPolyfoilAction = menu.addAction(icon, tr('Create polyfoil'), self.createPolyfoil) self.createPolyfoilAction.setObjectName('stCreatePolyfoil') icon = QIcon(self.plugin_dir + '/images/polygon.png') self.createPolygonAction = menu.addAction(icon, tr('Create polygon'), self.createPolygon) self.createPolygonAction.setObjectName('stCreatePolygon') icon = QIcon(self.plugin_dir + '/images/radialLines.png') self.createPolygonAction = menu.addAction(icon, tr('Create radial lines'), self.createRadialLines) self.createPolygonAction.setObjectName('stCreateRadialLines') icon = QIcon(self.plugin_dir + '/images/star.png') self.createStarAction = menu.addAction(icon, tr('Create star'), self.createStar) self.createStarAction.setObjectName('stCreateStar') # Add the shape creation tools to the menu icon = QIcon(self.plugin_dir + '/images/shapes.png') self.createShapesAction = QAction(icon, tr('Create shapes'), self.iface.mainWindow()) self.createShapesAction.setMenu(menu) self.iface.addPluginToVectorMenu('Shape Tools', self.createShapesAction) # Add the shape creation tools to the toolbar self.createShapeButton = QToolButton() self.createShapeButton.setMenu(menu) self.createShapeButton.setDefaultAction(self.createDonutAction) self.createShapeButton.setPopupMode(QToolButton.MenuButtonPopup) self.createShapeButton.triggered.connect(self.createShapeTriggered) self.createShapeToolbar = self.toolbar.addWidget( self.createShapeButton) # Initialize the XY to Line menu item icon = QIcon(self.plugin_dir + '/images/xyline.svg') self.xyLineAction = QAction(icon, tr('XY to line'), self.iface.mainWindow()) self.xyLineAction.setObjectName('stXYtoLine') self.xyLineAction.triggered.connect(self.xyLineTool) self.iface.addPluginToVectorMenu('Shape Tools', self.xyLineAction) self.toolbar.addAction(self.xyLineAction) # Initialize the Geodesic Densifier menu item icon = QIcon(self.plugin_dir + '/images/geodesicDensifier.svg') self.geodesicDensifyAction = QAction(icon, tr('Geodesic shape densifier'), self.iface.mainWindow()) self.geodesicDensifyAction.setObjectName('stGeodesicDensifier') self.geodesicDensifyAction.triggered.connect(self.geodesicDensifyTool) self.iface.addPluginToVectorMenu('Shape Tools', self.geodesicDensifyAction) self.toolbar.addAction(self.geodesicDensifyAction) # Initialize the Geodesic decimation menu items menu = QMenu() icon = QIcon(self.plugin_dir + '/images/geodesicLineDecimate.svg') self.lineDecimateAction = menu.addAction(icon, tr('Geodesic line decimate'), self.lineDecimateTool) self.lineDecimateAction.setObjectName('stGeodesicLineDecimate') icon = QIcon(self.plugin_dir + '/images/geodesicPointDecimate.svg') self.pointDecimateAction = menu.addAction( icon, tr('Geodesic point decimate'), self.pointDecimateTool) self.pointDecimateAction.setObjectName('stGeodesicPointDecimate') # Add the decimation tools to the menu icon = QIcon(self.plugin_dir + '/images/geodesicLineDecimate.svg') self.simplifyGeomAction = QAction( icon, tr('Geodesic geometry simplification'), self.iface.mainWindow()) self.simplifyGeomAction.setMenu(menu) self.iface.addPluginToVectorMenu('Shape Tools', self.simplifyGeomAction) # Add the shape creation tools to the toolbar self.simplifyButton = QToolButton() self.simplifyButton.setMenu(menu) self.simplifyButton.setDefaultAction(self.lineDecimateAction) self.simplifyButton.setPopupMode(QToolButton.MenuButtonPopup) self.simplifyButton.triggered.connect(self.simplifyTriggered) self.simplifyToolbar = self.toolbar.addWidget(self.simplifyButton) # Initialize the Geodesic line break menu item icon = QIcon(self.plugin_dir + '/images/idlbreak.svg') self.geodesicLineBreakAction = QAction( icon, tr('Geodesic line break at -180,180'), self.iface.mainWindow()) self.geodesicLineBreakAction.setObjectName('stGeodesicLineBreak') self.geodesicLineBreakAction.triggered.connect( self.geodesicLineBreakTool) self.iface.addPluginToVectorMenu('Shape Tools', self.geodesicLineBreakAction) self.toolbar.addAction(self.geodesicLineBreakAction) # Initialize Geodesic Measure Tool self.geodesicMeasureTool = GeodesicMeasureTool(self.iface, self.iface.mainWindow()) icon = QIcon(self.plugin_dir + '/images/measure.svg') self.measureAction = QAction(icon, tr('Geodesic measure tool'), self.iface.mainWindow()) self.measureAction.setObjectName('stGeodesicMeasureTool') self.measureAction.triggered.connect(self.measureTool) self.measureAction.setCheckable(True) self.iface.addPluginToVectorMenu('Shape Tools', self.measureAction) self.toolbar.addAction(self.measureAction) # Initialize Geodesic Measurement layer icon = QIcon(self.plugin_dir + '/images/measureLine.svg') self.measureLayerAction = QAction(icon, tr('Geodesic measurement layer'), self.iface.mainWindow()) self.measureLayerAction.setObjectName('stGeodesicLineBreak') self.measureLayerAction.triggered.connect(self.measureLayerTool) self.iface.addPluginToVectorMenu('Shape Tools', self.measureLayerAction) self.toolbar.addAction(self.measureLayerAction) menu = QMenu() # Initialize Geodesic transformation tool icon = QIcon(self.plugin_dir + '/images/transformShape.svg') self.transformationsAction = menu.addAction( icon, tr('Geodesic transformations'), self.transformTool) self.transformationsAction.setObjectName('stGeodesicTransformations') icon = QIcon(self.plugin_dir + '/images/flip.svg') self.flipRotateAction = menu.addAction(icon, tr('Geodesic flip and rotate'), self.flipRotateTool) self.flipRotateAction.setObjectName('stGeodesicFlipRotate') icon = QIcon(self.plugin_dir + '/images/flipHorizontal.svg') self.flipHorizontalAction = menu.addAction(icon, tr('Flip horizontal'), self.flipHorizontalTool) self.flipHorizontalAction.setObjectName('stGeodesicFlipHorizontal') self.flipHorizontalAction.setEnabled(False) icon = QIcon(self.plugin_dir + '/images/flipVertical.svg') self.flipVerticalAction = menu.addAction(icon, tr('Flip vertical'), self.flipVerticalTool) self.flipVerticalAction.setObjectName('stGeodesicFlipVertical') self.flipVerticalAction.setEnabled(False) icon = QIcon(self.plugin_dir + '/images/rotate180.svg') self.rotate180Action = menu.addAction(icon, tr('Rotate 180\xb0'), self.rotate180Tool) self.rotate180Action.setObjectName('stGeodesicRotate180') self.rotate180Action.setEnabled(False) icon = QIcon(self.plugin_dir + '/images/rotatecw.svg') self.rotate90CWAction = menu.addAction(icon, tr('Rotate 90\xb0 CW'), self.rotate90CWTool) self.rotate90CWAction.setObjectName('stGeodesicRotate90CW') self.rotate90CWAction.setEnabled(False) icon = QIcon(self.plugin_dir + '/images/rotateccw.svg') self.rotate90CCWAction = menu.addAction(icon, tr('Rotate 90\xb0 CCW'), self.rotate90CCWTool) self.rotate90CCWAction.setObjectName('stGeodesicRotate90CCW') self.rotate90CCWAction.setEnabled(False) self.transformsAction = QAction(icon, tr('Geodesic transforms'), self.iface.mainWindow()) self.transformsAction.setMenu(menu) self.iface.addPluginToVectorMenu('Shape Tools', self.transformsAction) self.transformationButton = QToolButton() self.transformationButton.setMenu(menu) self.transformationButton.setDefaultAction(self.transformationsAction) self.transformationButton.setPopupMode(QToolButton.MenuButtonPopup) self.transformationButton.triggered.connect(self.toolButtonTriggered) self.tranformToolbar = self.toolbar.addWidget( self.transformationButton) # Initialize the Azimuth Distance Digitize function icon = QIcon(self.plugin_dir + '/images/dazdigitize.svg') self.digitizeAction = QAction(icon, tr('Azimuth distance digitizer'), self.iface.mainWindow()) self.digitizeAction.setObjectName('stAzDistanceDigitizer') self.digitizeAction.triggered.connect(self.setShowAzDigitizerTool) self.digitizeAction.setCheckable(True) self.digitizeAction.setEnabled(False) self.iface.addPluginToVectorMenu(u'Shape Tools', self.digitizeAction) self.toolbar.addAction(self.digitizeAction) # Initialize the multi point azimuth Digitize function icon = QIcon(self.plugin_dir + '/images/linedigitize.svg') self.lineDigitizeAction = QAction( icon, tr('Azimuth distance sequence digitizer'), self.iface.mainWindow()) self.lineDigitizeAction.setObjectName('stLineDigitizer') self.lineDigitizeAction.triggered.connect(self.setShowLineDigitizeTool) self.lineDigitizeAction.setCheckable(True) self.lineDigitizeAction.setEnabled(False) self.iface.addPluginToVectorMenu(u'Shape Tools', self.lineDigitizeAction) self.toolbar.addAction(self.lineDigitizeAction) # Settings icon = QIcon(':/images/themes/default/mActionOptions.svg') self.settingsAction = QAction(icon, tr('Settings'), self.iface.mainWindow()) self.settingsAction.setObjectName('shapeToolsSettings') self.settingsAction.triggered.connect(self.settings) self.iface.addPluginToVectorMenu('Shape Tools', self.settingsAction) # Help icon = QIcon(self.plugin_dir + '/images/help.svg') self.helpAction = QAction(icon, tr('Shape Tools help'), self.iface.mainWindow()) self.helpAction.setObjectName('shapeToolsHelp') self.helpAction.triggered.connect(self.help) self.iface.addPluginToVectorMenu('Shape Tools', self.helpAction) self.iface.currentLayerChanged.connect(self.currentLayerChanged) self.canvas.mapToolSet.connect(self.unsetTool) self.enableTools() # Add the processing provider QgsApplication.processingRegistry().addProvider(self.provider) def unsetTool(self, tool): try: if not isinstance(tool, GeodesicMeasureTool): self.measureAction.setChecked(False) self.geodesicMeasureTool.endInteractiveLine() if not isinstance(tool, AzDigitizerTool): self.digitizeAction.setChecked(False) if not isinstance(tool, LineDigitizerTool): self.lineDigitizeAction.setChecked(False) except Exception: pass def unload(self): self.canvas.unsetMapTool(self.azDigitizerTool) self.canvas.unsetMapTool(self.lineDigitizerTool) # remove from menu self.iface.removePluginVectorMenu('Shape Tools', self.createShapesAction) self.iface.removePluginVectorMenu('Shape Tools', self.xyLineAction) self.iface.removePluginVectorMenu('Shape Tools', self.geodesicDensifyAction) self.iface.removePluginVectorMenu('Shape Tools', self.simplifyGeomAction) self.iface.removePluginVectorMenu('Shape Tools', self.geodesicLineBreakAction) self.iface.removePluginVectorMenu('Shape Tools', self.measureAction) self.iface.removePluginVectorMenu('Shape Tools', self.measureLayerAction) self.iface.removePluginVectorMenu('Shape Tools', self.transformsAction) self.iface.removePluginVectorMenu('Shape Tools', self.digitizeAction) self.iface.removePluginVectorMenu('Shape Tools', self.lineDigitizeAction) self.iface.removePluginVectorMenu('Shape Tools', self.settingsAction) self.iface.removePluginVectorMenu('Shape Tools', self.helpAction) # Remove from toolbar self.iface.removeToolBarIcon(self.createShapeToolbar) self.iface.removeToolBarIcon(self.xyLineAction) self.iface.removeToolBarIcon(self.geodesicDensifyAction) self.iface.removeToolBarIcon(self.simplifyToolbar) self.iface.removeToolBarIcon(self.geodesicLineBreakAction) self.iface.removeToolBarIcon(self.measureAction) self.iface.removeToolBarIcon(self.measureLayerAction) self.iface.removeToolBarIcon(self.transformationsAction) self.iface.removeToolBarIcon(self.digitizeAction) self.iface.removeToolBarIcon(self.lineDigitizeAction) self.iface.removeToolBarIcon(self.tranformToolbar) self.azDigitizerTool = None self.lineDigitizerTool = None # remove the toolbar del self.toolbar QgsApplication.processingRegistry().removeProvider(self.provider) def toolButtonTriggered(self, action): self.transformationButton.setDefaultAction(action) def createShapeTriggered(self, action): self.createShapeButton.setDefaultAction(action) def simplifyTriggered(self, action): self.simplifyButton.setDefaultAction(action) def setShowAzDigitizerTool(self): self.digitizeAction.setChecked(True) self.canvas.setMapTool(self.azDigitizerTool) def setShowLineDigitizeTool(self): self.lineDigitizeAction.setChecked(True) self.canvas.setMapTool(self.lineDigitizerTool) def xyLineTool(self): processing.execAlgorithmDialog('shapetools:xy2line', {}) def geodesicDensifyTool(self): processing.execAlgorithmDialog('shapetools:geodesicdensifier', {}) def pointDecimateTool(self): processing.execAlgorithmDialog('shapetools:geodesicpointdecimate', {}) def lineDecimateTool(self): processing.execAlgorithmDialog('shapetools:geodesiclinedecimate', {}) def geodesicLineBreakTool(self): processing.execAlgorithmDialog('shapetools:linebreak', {}) def measureTool(self): self.measureAction.setChecked(True) self.canvas.setMapTool(self.geodesicMeasureTool) def createArc(sefl): processing.execAlgorithmDialog('shapetools:createarc', {}) def createDonut(sefl): processing.execAlgorithmDialog('shapetools:createdonut', {}) def createEllipse(sefl): processing.execAlgorithmDialog('shapetools:createellipse', {}) def createEllipseRose(sefl): processing.execAlgorithmDialog('shapetools:createrose', {}) def createEpicycloid(sefl): processing.execAlgorithmDialog('shapetools:createepicycloid', {}) def createHeart(sefl): processing.execAlgorithmDialog('shapetools:createheart', {}) def createHypocycloid(sefl): processing.execAlgorithmDialog('shapetools:createhypocycloid', {}) def createLOB(sefl): processing.execAlgorithmDialog('shapetools:createlob', {}) def createPie(sefl): processing.execAlgorithmDialog('shapetools:createpie', {}) def createPolyfoil(sefl): processing.execAlgorithmDialog('shapetools:createpolyfoil', {}) def createPolygon(sefl): processing.execAlgorithmDialog('shapetools:createpolygon', {}) def createRadialLines(sefl): processing.execAlgorithmDialog('shapetools:createradiallines', {}) def createStar(sefl): processing.execAlgorithmDialog('shapetools:createstar', {}) def measureLayerTool(self): processing.execAlgorithmDialog('shapetools:measurelayer', {}) def transformTool(self): processing.execAlgorithmDialog('shapetools:geodesictransformations', {}) def flipRotateTool(self): processing.execAlgorithmDialog('shapetools:geodesicflip', {}) def flipHorizontalTool(self): layer = self.iface.activeLayer() flipLayer(self.iface, layer, 0) def flipVerticalTool(self): layer = self.iface.activeLayer() flipLayer(self.iface, layer, 1) def rotate180Tool(self): layer = self.iface.activeLayer() flipLayer(self.iface, layer, 2) def rotate90CWTool(self): layer = self.iface.activeLayer() flipLayer(self.iface, layer, 3) def rotate90CCWTool(self): layer = self.iface.activeLayer() flipLayer(self.iface, layer, 4) def settings(self): if self.settingsDialog is None: self.settingsDialog = SettingsWidget(self.iface, self.iface.mainWindow()) self.settingsDialog.show() def help(self): '''Display a help page''' url = QUrl.fromLocalFile(self.plugin_dir + '/index.html').toString() webbrowser.open(url, new=2) def currentLayerChanged(self): layer = self.iface.activeLayer() if self.previousLayer is not None: try: self.previousLayer.editingStarted.disconnect( self.layerEditingChanged) except Exception: pass try: self.previousLayer.editingStopped.disconnect( self.layerEditingChanged) except Exception: pass self.previousLayer = None if layer is not None: if isinstance(layer, QgsVectorLayer): layer.editingStarted.connect(self.layerEditingChanged) layer.editingStopped.connect(self.layerEditingChanged) self.previousLayer = layer self.enableTools() def layerEditingChanged(self): self.enableTools() def enableTools(self): self.digitizeAction.setEnabled(False) self.lineDigitizeAction.setEnabled(False) self.flipHorizontalAction.setEnabled(False) self.flipVerticalAction.setEnabled(False) self.rotate180Action.setEnabled(False) self.rotate90CWAction.setEnabled(False) self.rotate90CCWAction.setEnabled(False) layer = self.iface.activeLayer() if not layer or not layer.isValid() or ( layer.type() != QgsMapLayer.VectorLayer) or not layer.isEditable(): return wkbtype = layer.wkbType() geomtype = QgsWkbTypes.geometryType(wkbtype) self.lineDigitizeAction.setEnabled(True) if geomtype == QgsWkbTypes.PointGeometry or geomtype == QgsWkbTypes.LineGeometry: self.digitizeAction.setEnabled(True) if geomtype == QgsWkbTypes.LineGeometry or geomtype == QgsWkbTypes.PolygonGeometry: self.flipHorizontalAction.setEnabled(True) self.flipVerticalAction.setEnabled(True) self.rotate180Action.setEnabled(True) self.rotate90CWAction.setEnabled(True) self.rotate90CCWAction.setEnabled(True)
class ProcessingPlugin: def __init__(self, iface): self.iface = iface self.options_factory = None self.drop_handler = None self.item_provider = None self.locator_filter = None self.edit_features_locator_filter = None self.initialized = False self.initProcessing() def initProcessing(self): if not self.initialized: self.initialized = True Processing.initialize() def initGui(self): self.options_factory = ProcessingOptionsFactory() self.options_factory.setTitle(self.tr('Processing')) iface.registerOptionsWidgetFactory(self.options_factory) self.drop_handler = ProcessingDropHandler() iface.registerCustomDropHandler(self.drop_handler) self.item_provider = ProcessingDataItemProvider() QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider) self.locator_filter = AlgorithmLocatorFilter() iface.registerLocatorFilter(self.locator_filter) # Invalidate the locator filter for in-place when active layer changes iface.currentLayerChanged.connect(lambda _: self.iface.invalidateLocatorResults()) self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter() iface.registerLocatorFilter(self.edit_features_locator_filter) self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged) self.resultsDock = ResultsDock() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock) self.resultsDock.hide() self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow()) self.toolboxAction.setCheckable(True) self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QgsApplication.getThemeIcon("/processingAlgorithm.svg")) self.iface.registerMainWindowAction(self.toolboxAction, QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText)) self.toolboxAction.toggled.connect(self.openToolbox) self.iface.attributesToolBar().insertAction(self.iface.actionOpenStatisticalSummary(), self.toolboxAction) self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QgsApplication.getThemeIcon("/processingModel.svg"), QCoreApplication.translate('ProcessingPlugin', 'Graphical &Modeler…'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction(self.modelerAction, QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText)) self.menu.addAction(self.modelerAction) self.historyAction = QAction( QgsApplication.getThemeIcon("/mIconHistory.svg"), QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction(self.historyAction, QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText)) self.menu.addAction(self.historyAction) self.toolbox.processingToolbar.addAction(self.historyAction) self.resultsAction = QAction( QgsApplication.getThemeIcon("/processingResult.svg"), self.tr('&Results Viewer'), self.iface.mainWindow()) self.resultsAction.setCheckable(True) self.iface.registerMainWindowAction(self.resultsAction, QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText)) self.menu.addAction(self.resultsAction) self.toolbox.processingToolbar.addAction(self.resultsAction) self.resultsDock.visibilityChanged.connect(self.resultsAction.setChecked) self.resultsAction.toggled.connect(self.resultsDock.setUserVisible) self.toolbox.processingToolbar.addSeparator() self.editInPlaceAction = QAction( QgsApplication.getThemeIcon("/mActionProcessSelected.svg"), self.tr('Edit Features In-Place'), self.iface.mainWindow()) self.editInPlaceAction.setObjectName('editInPlaceFeatures') self.editInPlaceAction.setCheckable(True) self.editInPlaceAction.toggled.connect(self.editSelected) self.menu.addAction(self.editInPlaceAction) self.toolbox.processingToolbar.addAction(self.editInPlaceAction) self.toolbox.processingToolbar.addSeparator() self.optionsAction = QAction( QgsApplication.getThemeIcon("/mActionOptions.svg"), self.tr('Options'), self.iface.mainWindow()) self.optionsAction.setObjectName('optionsAction') self.optionsAction.triggered.connect(self.openProcessingOptions) self.toolbox.processingToolbar.addAction(self.optionsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu( self.iface.firstRightStandardMenu().menuAction(), self.menu) self.menu.addSeparator() initializeMenus() createMenus() # In-place editing button state sync self.iface.currentLayerChanged.connect(self.sync_in_place_button_state) self.iface.mapCanvas().selectionChanged.connect(self.sync_in_place_button_state) self.iface.actionToggleEditing().triggered.connect(partial(self.sync_in_place_button_state, None)) self.sync_in_place_button_state() def sync_in_place_button_state(self, layer=None): """Synchronise the button state with layer state""" if layer is None: layer = self.iface.activeLayer() old_enabled_state = self.editInPlaceAction.isEnabled() new_enabled_state = layer is not None and layer.type() == QgsMapLayerType.VectorLayer self.editInPlaceAction.setEnabled(new_enabled_state) if new_enabled_state != old_enabled_state: self.toolbox.set_in_place_edit_mode(new_enabled_state and self.editInPlaceAction.isChecked()) def openProcessingOptions(self): self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions') def unload(self): self.toolbox.setVisible(False) self.iface.removeDockWidget(self.toolbox) self.iface.attributesToolBar().removeAction(self.toolboxAction) self.resultsDock.setVisible(False) self.iface.removeDockWidget(self.resultsDock) self.toolbox.deleteLater() self.menu.deleteLater() # delete temporary output files folder = QgsProcessingUtils.tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) # also delete temporary help files folder = tempHelpFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.toolboxAction) self.iface.unregisterMainWindowAction(self.modelerAction) self.iface.unregisterMainWindowAction(self.historyAction) self.iface.unregisterMainWindowAction(self.resultsAction) self.iface.unregisterOptionsWidgetFactory(self.options_factory) self.iface.deregisterLocatorFilter(self.locator_filter) self.iface.deregisterLocatorFilter(self.edit_features_locator_filter) self.iface.unregisterCustomDropHandler(self.drop_handler) QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider) removeMenus() Processing.deinitialize() def openToolbox(self, show): self.toolbox.setUserVisible(show) def toolboxVisibilityChanged(self, visible): self.toolboxAction.setChecked(visible) def openModeler(self): dlg = ModelerDialog() dlg.update_model.connect(self.updateModel) dlg.show() def updateModel(self): model_provider = QgsApplication.processingRegistry().providerById('model') model_provider.refreshAlgorithms() def openResults(self): if self.resultsDock.isVisible(): self.resultsDock.hide() else: self.resultsDock.show() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def tr(self, message): return QCoreApplication.translate('ProcessingPlugin', message) def editSelected(self, enabled): self.toolbox.set_in_place_edit_mode(enabled)
class ProcessingPlugin(QObject): def __init__(self, iface): super().__init__() self.iface = iface self.options_factory = None self.drop_handler = None self.item_provider = None self.locator_filter = None self.edit_features_locator_filter = None self.initialized = False self.initProcessing() def initProcessing(self): if not self.initialized: self.initialized = True Processing.initialize() def initGui(self): # port old log, ONCE ONLY! settings = QgsSettings() if not settings.value("/Processing/hasPortedOldLog", False, bool): processing_history_provider = QgsGui.historyProviderRegistry().providerById('processing') if processing_history_provider: processing_history_provider.portOldLog() settings.setValue("/Processing/hasPortedOldLog", True) self.options_factory = ProcessingOptionsFactory() self.options_factory.setTitle(self.tr('Processing')) iface.registerOptionsWidgetFactory(self.options_factory) self.drop_handler = ProcessingDropHandler() iface.registerCustomDropHandler(self.drop_handler) self.item_provider = ProcessingDataItemProvider() QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider) self.locator_filter = AlgorithmLocatorFilter() iface.registerLocatorFilter(self.locator_filter) # Invalidate the locator filter for in-place when active layer changes iface.currentLayerChanged.connect(lambda _: self.iface.invalidateLocatorResults()) self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter() iface.registerLocatorFilter(self.edit_features_locator_filter) self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged) self.toolbox.executeWithGui.connect(self.executeAlgorithm) self.resultsDock = ResultsDock() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock) self.resultsDock.hide() self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow()) self.toolboxAction.setCheckable(True) self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QgsApplication.getThemeIcon("/processingAlgorithm.svg")) self.iface.registerMainWindowAction(self.toolboxAction, QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText)) self.toolboxAction.toggled.connect(self.openToolbox) self.iface.attributesToolBar().insertAction(self.iface.actionOpenStatisticalSummary(), self.toolboxAction) self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QgsApplication.getThemeIcon("/processingModel.svg"), QCoreApplication.translate('ProcessingPlugin', '&Graphical Modeler…'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction(self.modelerAction, QKeySequence('Ctrl+Alt+G').toString(QKeySequence.NativeText)) self.menu.addAction(self.modelerAction) self.historyAction = QAction( QgsApplication.getThemeIcon("/mIconHistory.svg"), QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction(self.historyAction, QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText)) self.menu.addAction(self.historyAction) self.toolbox.processingToolbar.addAction(self.historyAction) self.resultsAction = QAction( QgsApplication.getThemeIcon("/processingResult.svg"), self.tr('&Results Viewer'), self.iface.mainWindow()) self.resultsAction.setObjectName('resultsViewer') self.resultsAction.setCheckable(True) self.iface.registerMainWindowAction(self.resultsAction, QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText)) self.menu.addAction(self.resultsAction) self.toolbox.processingToolbar.addAction(self.resultsAction) self.resultsDock.visibilityChanged.connect(self.resultsAction.setChecked) self.resultsAction.toggled.connect(self.resultsDock.setUserVisible) self.toolbox.processingToolbar.addSeparator() self.editInPlaceAction = QAction( QgsApplication.getThemeIcon("/mActionProcessSelected.svg"), self.tr('Edit Features In-Place'), self.iface.mainWindow()) self.editInPlaceAction.setObjectName('editInPlaceFeatures') self.editInPlaceAction.setCheckable(True) self.editInPlaceAction.toggled.connect(self.editSelected) self.menu.addAction(self.editInPlaceAction) self.toolbox.processingToolbar.addAction(self.editInPlaceAction) self.toolbox.processingToolbar.addSeparator() self.optionsAction = QAction( QgsApplication.getThemeIcon("/mActionOptions.svg"), self.tr('Options'), self.iface.mainWindow()) self.optionsAction.setObjectName('optionsAction') self.optionsAction.triggered.connect(self.openProcessingOptions) self.toolbox.processingToolbar.addAction(self.optionsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu( self.iface.firstRightStandardMenu().menuAction(), self.menu) self.menu.addSeparator() initializeMenus() createMenus() createButtons() # In-place editing button state sync self.iface.currentLayerChanged.connect(self.sync_in_place_button_state) self.iface.mapCanvas().selectionChanged.connect(self.sync_in_place_button_state) self.iface.actionToggleEditing().triggered.connect(partial(self.sync_in_place_button_state, None)) self.sync_in_place_button_state() # Sync project models self.projectModelsMenu = None self.projectMenuAction = None self.projectMenuSeparator = None self.projectProvider = QgsApplication.instance().processingRegistry().providerById("project") self.projectProvider.algorithmsLoaded.connect(self.updateProjectModelMenu) def updateProjectModelMenu(self): """Add projects models to menu""" if self.projectMenuAction is None: self.projectModelsMenu = QMenu(self.tr("Models")) self.projectMenuAction = self.iface.projectMenu().insertMenu(self.iface.projectMenu().children()[-1], self.projectModelsMenu) self.projectMenuAction.setParent(self.projectModelsMenu) self.iface.projectMenu().insertSeparator(self.projectMenuAction) self.projectModelsMenu.clear() for model in self.projectProvider.algorithms(): modelSubMenu = self.projectModelsMenu.addMenu(model.name()) modelSubMenu.setParent(self.projectModelsMenu) action = QAction(self.tr("Execute…"), modelSubMenu) action.triggered.connect(partial(self.executeAlgorithm, model.id(), self.projectModelsMenu, self.toolbox.in_place_mode)) modelSubMenu.addAction(action) if model.flags() & QgsProcessingAlgorithm.FlagSupportsBatch: action = QAction(self.tr("Execute as Batch Process…"), modelSubMenu) modelSubMenu.addAction(action) action.triggered.connect(partial(self.executeAlgorithm, model.id(), self.projectModelsMenu, self.toolbox.in_place_mode, True)) @pyqtSlot(str, QWidget, bool, bool) def executeAlgorithm(self, alg_id, parent, in_place=False, as_batch=False): """Executes a project model with GUI interaction if needed. :param alg_id: algorithm id :type alg_id: string :param parent: parent widget :type parent: QWidget :param in_place: in place flag, defaults to False :type in_place: bool, optional :param as_batch: execute as batch flag, defaults to False :type as_batch: bool, optional """ config = {} if in_place: config['IN_PLACE'] = True alg = QgsApplication.instance().processingRegistry().createAlgorithmById(alg_id, config) if alg is not None: ok, message = alg.canExecute() if not ok: dlg = MessageDialog() dlg.setTitle(self.tr('Error executing algorithm')) dlg.setMessage( self.tr('<h3>This algorithm cannot ' 'be run :-( </h3>\n{0}').format(message)) dlg.exec_() return if as_batch: dlg = BatchAlgorithmDialog(alg, iface.mainWindow()) dlg.show() dlg.exec_() else: in_place_input_parameter_name = 'INPUT' if hasattr(alg, 'inputParameterName'): in_place_input_parameter_name = alg.inputParameterName() if in_place and not [d for d in alg.parameterDefinitions() if d.name() not in (in_place_input_parameter_name, 'OUTPUT')]: parameters = {} feedback = MessageBarProgress(algname=alg.displayName()) ok, results = execute_in_place(alg, parameters, feedback=feedback) if ok: iface.messageBar().pushSuccess('', self.tr('{algname} completed. %n feature(s) processed.', n=results['__count']).format(algname=alg.displayName())) feedback.close() # MessageBarProgress handles errors return if alg.countVisibleParameters() > 0: dlg = alg.createCustomParametersWidget(parent) if not dlg: dlg = AlgorithmDialog(alg, in_place, iface.mainWindow()) canvas = iface.mapCanvas() prevMapTool = canvas.mapTool() dlg.show() dlg.exec_() if canvas.mapTool() != prevMapTool: try: canvas.mapTool().reset() except Exception: pass canvas.setMapTool(prevMapTool) else: feedback = MessageBarProgress(algname=alg.displayName()) context = dataobjects.createContext(feedback) parameters = {} ret, results = execute(alg, parameters, context, feedback) handleAlgorithmResults(alg, context, feedback) feedback.close() def sync_in_place_button_state(self, layer=None): """Synchronise the button state with layer state""" if layer is None: layer = self.iface.activeLayer() old_enabled_state = self.editInPlaceAction.isEnabled() new_enabled_state = layer is not None and layer.type() == QgsMapLayerType.VectorLayer self.editInPlaceAction.setEnabled(new_enabled_state) if new_enabled_state != old_enabled_state: self.toolbox.set_in_place_edit_mode(new_enabled_state and self.editInPlaceAction.isChecked()) def openProcessingOptions(self): self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions') def unload(self): self.toolbox.setVisible(False) self.iface.removeDockWidget(self.toolbox) self.iface.attributesToolBar().removeAction(self.toolboxAction) self.resultsDock.setVisible(False) self.iface.removeDockWidget(self.resultsDock) self.toolbox.deleteLater() self.menu.deleteLater() # also delete temporary help files folder = tempHelpFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.toolboxAction) self.iface.unregisterMainWindowAction(self.modelerAction) self.iface.unregisterMainWindowAction(self.historyAction) self.iface.unregisterMainWindowAction(self.resultsAction) self.iface.unregisterOptionsWidgetFactory(self.options_factory) self.iface.deregisterLocatorFilter(self.locator_filter) self.iface.deregisterLocatorFilter(self.edit_features_locator_filter) self.iface.unregisterCustomDropHandler(self.drop_handler) QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider) removeButtons() removeMenus() if self.projectMenuAction is not None: self.iface.projectMenu().removeAction(self.projectMenuAction) self.projectMenuAction = None if self.projectMenuSeparator is not None: self.iface.projectMenu().removeAction(self.projectMenuSeparator) self.projectMenuSeparator = None Processing.deinitialize() def openToolbox(self, show): self.toolbox.setUserVisible(show) def toolboxVisibilityChanged(self, visible): self.toolboxAction.setChecked(visible) def openModeler(self): dlg = ModelerDialog.create() dlg.update_model.connect(self.updateModel) dlg.show() def updateModel(self): model_provider = QgsApplication.processingRegistry().providerById('model') model_provider.refreshAlgorithms() def openResults(self): if self.resultsDock.isVisible(): self.resultsDock.hide() else: self.resultsDock.show() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def tr(self, message, disambiguation=None, n=-1): return QCoreApplication.translate('ProcessingPlugin', message, disambiguation=disambiguation, n=n) def editSelected(self, enabled): self.toolbox.set_in_place_edit_mode(enabled)
class ProcessingPlugin: def __init__(self, iface): self.iface = iface self.options_factory = ProcessingOptionsFactory() self.options_factory.setTitle(self.tr('Processing')) iface.registerOptionsWidgetFactory(self.options_factory) self.drop_handler = ProcessingDropHandler() iface.registerCustomDropHandler(self.drop_handler) self.item_provider = ProcessingDataItemProvider() QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider) self.locator_filter = AlgorithmLocatorFilter() iface.registerLocatorFilter(self.locator_filter) Processing.initialize() def initGui(self): self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged) self.resultsDock = ResultsDock() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock) self.resultsDock.hide() self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow()) self.toolboxAction.setCheckable(True) self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QgsApplication.getThemeIcon("/processingAlgorithm.svg")) self.iface.registerMainWindowAction(self.toolboxAction, QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText)) self.toolboxAction.toggled.connect(self.openToolbox) self.iface.attributesToolBar().insertAction(self.iface.actionOpenStatisticalSummary(), self.toolboxAction) self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QgsApplication.getThemeIcon("/processingModel.svg"), QCoreApplication.translate('ProcessingPlugin', 'Graphical &Modeler…'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction(self.modelerAction, QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText)) self.menu.addAction(self.modelerAction) self.historyAction = QAction( QgsApplication.getThemeIcon("/mIconHistory.svg"), QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction(self.historyAction, QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText)) self.menu.addAction(self.historyAction) self.toolbox.processingToolbar.addAction(self.historyAction) self.resultsAction = QAction( QgsApplication.getThemeIcon("/processingResult.svg"), self.tr('&Results Viewer'), self.iface.mainWindow()) self.resultsAction.setCheckable(True) self.iface.registerMainWindowAction(self.resultsAction, QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText)) self.menu.addAction(self.resultsAction) self.toolbox.processingToolbar.addAction(self.resultsAction) self.resultsDock.visibilityChanged.connect(self.resultsAction.setChecked) self.resultsAction.toggled.connect(self.resultsDock.setUserVisible) self.optionsAction = QAction( QgsApplication.getThemeIcon("/mActionOptions.svg"), self.tr('Options'), self.iface.mainWindow()) self.optionsAction.setObjectName('optionsAction') self.optionsAction.triggered.connect(self.openProcessingOptions) self.toolbox.processingToolbar.addAction(self.optionsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu( self.iface.firstRightStandardMenu().menuAction(), self.menu) self.menu.addSeparator() initializeMenus() createMenus() def openProcessingOptions(self): self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions') def unload(self): self.toolbox.setVisible(False) self.iface.removeDockWidget(self.toolbox) self.iface.attributesToolBar().removeAction(self.toolboxAction) self.resultsDock.setVisible(False) self.iface.removeDockWidget(self.resultsDock) self.toolbox.deleteLater() self.menu.deleteLater() # delete temporary output files folder = QgsProcessingUtils.tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) # also delete temporary help files folder = tempHelpFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.toolboxAction) self.iface.unregisterMainWindowAction(self.modelerAction) self.iface.unregisterMainWindowAction(self.historyAction) self.iface.unregisterMainWindowAction(self.resultsAction) self.iface.unregisterOptionsWidgetFactory(self.options_factory) self.iface.deregisterLocatorFilter(self.locator_filter) self.iface.unregisterCustomDropHandler(self.drop_handler) QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider) removeMenus() Processing.deinitialize() def openToolbox(self, show): self.toolbox.setUserVisible(show) def toolboxVisibilityChanged(self, visible): self.toolboxAction.setChecked(visible) def openModeler(self): dlg = ModelerDialog() dlg.update_model.connect(self.updateModel) dlg.show() def updateModel(self): model_provider = QgsApplication.processingRegistry().providerById('model') model_provider.refreshAlgorithms() def openResults(self): if self.resultsDock.isVisible(): self.resultsDock.hide() else: self.resultsDock.show() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def tr(self, message): return QCoreApplication.translate('ProcessingPlugin', message)
class ShapeTools(object): def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.settingsDialog = None self.shapeDialog = None self.xyLineDialog = None self.geodesicDensifyDialog = None self.azDigitizerTool = None self.previousLayer = None self.toolbar = self.iface.addToolBar('Shape Tools Toolbar') self.toolbar.setObjectName('ShapeToolsToolbar') self.provider = ShapeToolsProvider() def initGui(self): self.azDigitizerTool = AzDigitizerTool(self.iface) # Initialize the create shape menu item icon = QIcon(os.path.dirname(__file__) + '/images/shapes.png') self.shapeAction = QAction(icon, tr('Create Shapes'), self.iface.mainWindow()) self.shapeAction.setObjectName('stCreateShapes') self.shapeAction.triggered.connect(self.shapeTool) self.iface.addPluginToVectorMenu('Shape Tools', self.shapeAction) self.toolbar.addAction(self.shapeAction) # Initialize the XY to Line menu item icon = QIcon(os.path.dirname(__file__) + '/images/xyline.png') self.xyLineAction = QAction(icon, tr('XY to Line'), self.iface.mainWindow()) self.xyLineAction.setObjectName('stXYtoLine') self.xyLineAction.triggered.connect(self.xyLineTool) self.iface.addPluginToVectorMenu('Shape Tools', self.xyLineAction) self.toolbar.addAction(self.xyLineAction) # Initialize the Geodesic Densifier menu item icon = QIcon( os.path.dirname(__file__) + '/images/geodesicDensifier.png') self.geodesicDensifyAction = QAction(icon, tr('Geodesic Shape Densifier'), self.iface.mainWindow()) self.geodesicDensifyAction.setObjectName('stGeodesicDensifier') self.geodesicDensifyAction.triggered.connect(self.geodesicDensifyTool) self.iface.addPluginToVectorMenu('Shape Tools', self.geodesicDensifyAction) self.toolbar.addAction(self.geodesicDensifyAction) # Initialize Geodesic Measure Tool self.geodesicMeasureTool = GeodesicMeasureTool(self.iface, self.iface.mainWindow()) icon = QIcon(os.path.dirname(__file__) + '/images/measure.png') self.measureAction = QAction(icon, tr('Geodesic Measure Tool'), self.iface.mainWindow()) self.measureAction.setObjectName('stGeodesicMeasureTool') self.measureAction.triggered.connect(self.measureTool) self.measureAction.setCheckable(True) self.iface.addPluginToVectorMenu('Shape Tools', self.measureAction) self.toolbar.addAction(self.measureAction) # Initialize the Azimuth Distance Digitize function icon = QIcon(os.path.dirname(__file__) + '/images/dazdigitize.png') self.digitizeAction = QAction(icon, tr('Azimuth Distance Digitizer'), self.iface.mainWindow()) self.digitizeAction.setObjectName('stAzDistanceDigitizer') self.digitizeAction.triggered.connect(self.setShowAzDigitizerTool) self.digitizeAction.setCheckable(True) self.digitizeAction.setEnabled(False) self.iface.addPluginToVectorMenu(u'Shape Tools', self.digitizeAction) self.toolbar.addAction(self.digitizeAction) # Settings icon = QIcon(os.path.dirname(__file__) + '/images/settings.png') self.settingsAction = QAction(icon, tr('Settings'), self.iface.mainWindow()) self.settingsAction.setObjectName('shapeToolsSettings') self.settingsAction.triggered.connect(self.settings) self.iface.addPluginToVectorMenu('Shape Tools', self.settingsAction) # Help icon = QIcon(os.path.dirname(__file__) + '/images/help.png') self.helpAction = QAction(icon, tr('Shape Tools Help'), self.iface.mainWindow()) self.helpAction.setObjectName('shapeToolsHelp') self.helpAction.triggered.connect(self.help) self.iface.addPluginToVectorMenu('Shape Tools', self.helpAction) self.iface.currentLayerChanged.connect(self.currentLayerChanged) self.canvas.mapToolSet.connect(self.unsetTool) self.enableDigitizeTool() # Add the processing provider QgsApplication.processingRegistry().addProvider(self.provider) def unsetTool(self, tool): try: if not isinstance(tool, GeodesicMeasureTool): self.measureAction.setChecked(False) self.geodesicMeasureTool.closeDialog() if not isinstance(tool, AzDigitizerTool): self.digitizeAction.setChecked(False) except: pass def unload(self): self.canvas.unsetMapTool(self.azDigitizerTool) # remove from menu self.iface.removePluginVectorMenu('Shape Tools', self.shapeAction) self.iface.removePluginVectorMenu('Shape Tools', self.xyLineAction) self.iface.removePluginVectorMenu('Shape Tools', self.geodesicDensifyAction) self.iface.removePluginVectorMenu('Shape Tools', self.measureAction) self.iface.removePluginVectorMenu('Shape Tools', self.digitizeAction) self.iface.removePluginVectorMenu('Shape Tools', self.settingsAction) self.iface.removePluginVectorMenu('Shape Tools', self.helpAction) # Remove from toolbar self.iface.removeToolBarIcon(self.shapeAction) self.iface.removeToolBarIcon(self.xyLineAction) self.iface.removeToolBarIcon(self.geodesicDensifyAction) self.iface.removeToolBarIcon(self.measureAction) self.iface.removeToolBarIcon(self.digitizeAction) self.azDigitizerTool = None # remove the toolbar del self.toolbar QgsApplication.processingRegistry().removeProvider(self.provider) def shapeTool(self): if self.shapeDialog is None: self.shapeDialog = Vector2ShapeWidget(self.iface, self.iface.mainWindow()) self.shapeDialog.show() def setShowAzDigitizerTool(self): self.digitizeAction.setChecked(True) self.canvas.setMapTool(self.azDigitizerTool) def xyLineTool(self): results = processing.execAlgorithmDialog('shapetools:xy2line', {}) def geodesicDensifyTool(self): results = processing.execAlgorithmDialog( 'shapetools:geodesicdensifier', {}) def measureTool(self): self.measureAction.setChecked(True) self.canvas.setMapTool(self.geodesicMeasureTool) def settings(self): if self.settingsDialog is None: self.settingsDialog = SettingsWidget(self.iface, self.iface.mainWindow()) self.settingsDialog.show() def help(self): '''Display a help page''' url = QUrl.fromLocalFile(os.path.dirname(__file__) + '/index.html').toString() webbrowser.open(url, new=2) def currentLayerChanged(self): layer = self.iface.activeLayer() if self.previousLayer != None: try: self.previousLayer.editingStarted.disconnect( self.layerEditingChanged) except: pass try: self.previousLayer.editingStopped.disconnect( self.layerEditingChanged) except: pass self.previousLayer = None if layer != None: if isinstance(layer, QgsVectorLayer) and ( (layer.wkbType() == QgsWkbTypes.Point) or (layer.wkbType() == QgsWkbTypes.LineString) or (layer.wkbType() == QgsWkbTypes.MultiLineString)): layer.editingStarted.connect(self.layerEditingChanged) layer.editingStopped.connect(self.layerEditingChanged) self.previousLayer = layer self.enableDigitizeTool() def layerEditingChanged(self): self.enableDigitizeTool() def enableDigitizeTool(self): self.digitizeAction.setEnabled(False) layer = self.iface.activeLayer() if layer != None and isinstance(layer, QgsVectorLayer) and ( (layer.wkbType() == QgsWkbTypes.Point) or (layer.wkbType() == QgsWkbTypes.LineString) or (layer.wkbType() == QgsWkbTypes.MultiLineString)) and layer.isEditable(): self.digitizeAction.setEnabled(True) else: self.digitizeAction.setChecked(False)