def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = os.path.join(self.plugin_dir, 'res', 'icon.png') self.add_action(icon_path, text=self.tr(u'go2mapillary'), callback=self.run, parent=self.iface.mainWindow()) self.dlg = go2mapillaryDockWidget() self.dockwidget = QDockWidget("go2mapillary", self.iface.mainWindow()) self.dockwidget.setObjectName("go2mapillary") self.dockwidget.setWidget(self.dlg) self.dlg.webView.page().setNetworkAccessManager( QgsNetworkAccessManager.instance()) self.dlg.webView.page().mainFrame().setScrollBarPolicy( Qt.Vertical, Qt.ScrollBarAlwaysOff) self.dlg.webView.page().mainFrame().setScrollBarPolicy( Qt.Horizontal, Qt.ScrollBarAlwaysOff) self.canvas.mapToolSet.connect(self.toggleViewer) self.viewer = mapillaryViewer(self.dlg.webView) self.viewer.messageArrived.connect(self.viewerConnection) QgsExpressionContextUtils.setGlobalVariable("mapillaryCurrentKey", "noKey") self.mapSelectionTool = None self.coverage = mapillary_coverage(self.iface) self.mapillaryOverview = None self.mapillaryCoverage = None self.mapillaryLocations = None
def initGui(self): """Initalise the Plugin-UI""" if not pyratImport: iface.messageBar().pushMessage("PyRAT not found!", level=Qgis.Critical) return if 'PyRAT' not in [ action.text() for action in iface.mainWindow().menuBar().actions() ]: self.pyratMenu = iface.mainWindow().menuBar().addMenu('PyRAT') else: self.pyratMenu = [ action.menu() for action in iface.mainWindow().menuBar().actions() if action.text() == 'PyRAT' ][0] action = QAction("Layer2PyRAT", iface.mainWindow()) action.triggered.connect(PyRATBridge.layerToPyrat) self.pyratMenu.addAction(action) action = QAction("PyRAT2Layer", iface.mainWindow()) action.triggered.connect(PyRATBridge.pyratToLayer) self.pyratMenu.addAction(action) action = QAction("Cleanup PyRAT", iface.mainWindow()) action.triggered.connect(PyRATBridge.clearPyRAT) self.pyratMenu.addAction(action) action = QAction("Show PyRAT GUI", iface.mainWindow()) action.triggered.connect(self.showPyrat) self.pyratMenu.addAction(action) self.pyratMenu.addSeparator() # Init PyRAT-Tools, adapted from pyrat.viewer for qgis from inspect import getmembers, isclass modules = [ pyrat.load, pyrat.save, pyrat.transform, pyrat.filter, pyrat.polar, pyrat.insar, pyrat.plugins, pyrat.viewer ] for current_module in modules: modules = getmembers(current_module, isclass) for mod in modules: if issubclass(mod[1], pyrat.Worker): plugin = mod[1] if (hasattr(plugin, 'gui') and plugin.gui['entry'] != "Python console"): self.addMenuEntry(plugin) self.pyratLayerTree = QDockWidget("PyRAT Layers", iface.mainWindow()) PyRATBridge.layerTreeWidget = LayerTreeWidget( parent=self.pyratLayerTree, viewer=ViewerToQGISInterface) self.pyratLayerTree.setObjectName("PyRAT Layers") self.pyratLayerTree.setWidget(PyRATBridge.layerTreeWidget) iface.addDockWidget(Qt.LeftDockWidgetArea, self.pyratLayerTree)
def __init__(self, base_config, iface): QDockWidget.__init__(self, iface.mainWindow()) self.setupUi(self) self.iface = iface self.db_simple_factory = DbSimpleFactory() QgsGui.instance().enableAutoGeometryRestore(self) self.schema_validations = {} self.requested_roles = [ValidationResultModel.Roles.MESSAGE] self.current_configuration = ValidateConfiguration() self.current_schema_identificator = "" self.current_models_model = SchemaModelsModel() self.current_datasets_model = SchemaDatasetsModel() self.current_baskets_model = SchemaBasketsModel() self.current_filter_mode = SchemaDataFilterMode.NO_FILTER self.filter_data_panel = FilterDataPanel(self) self.filter_data_panel.setMaximumHeight(self.fontMetrics().lineSpacing() * 10) self.filter_layout.addWidget(self.filter_data_panel) self._reset_gui() self.run_button.clicked.connect(self._run) self.visibilityChanged.connect(self._visibility_changed) self.result_table_view.setContextMenuPolicy(Qt.CustomContextMenu) self.result_table_view.customContextMenuRequested.connect(self._table_clicked)
def __init__(self, parent=None): QDockWidget.__init__(self, parent) self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea) self.setWidget(MyQueriesWidget()) self.setWindowTitle(tr("ui_my_queries", "QuickOSM - My queries")) self.widget().signal_delete_query_successful.connect( self.signal_delete_query_successful.emit)
def __init__(self, iface, parent=None): QDockWidget.__init__(self, parent) self.setupUi(self) self.iface = iface self.message_bar = self.iface.messageBar() self.layer = None self._gui_elements = [ self.layers_combo, self.unfinished_only_check, self.unfinished_fields_combo, self.previous_button, self.next_button, self.defects_list, self.columns_choice_button ] self._toggle_gui_elements(False) self.settings = QSettings("CatAIS", "VeriSO") self.next_button.clicked.connect(self.next_button_clicked) self.previous_button.clicked.connect(self.previous_button_clicked) self.defects_list.currentItemChanged.connect( self.defects_list_currentItemChanged) self.layers_combo.currentIndexChanged.connect( self.layers_combo_currentIndexChanged) self.unfinished_fields_combo.currentIndexChanged.connect( self.unfinished_fields_combo_currentIndexChanged) self.unfinished_only_check.toggled.connect( self.unfinished_only_check_toggled) self.columns_choice_button.clicked.connect( self.columns_choice_button_clicked)
def __init__(self, iface): QDockWidget.__init__(self, iface.mainWindow()) self.setupUi(self) self.newsFrame.setVisible(False) self.iface = iface self.search_threads = None # [] self.extent_renderer = RubberBandResultRenderer() self.cmbStatusFilter.addItem(self.tr('All'), STATUS_FILTER_ALL) self.cmbStatusFilter.addItem(self.tr('Valid'), STATUS_FILTER_ONLY_WORKS) self.cmbStatusFilter.currentIndexChanged.connect(self.start_search) if hasattr(self.txtSearch, 'setPlaceholderText'): self.txtSearch.setPlaceholderText(self.tr("Search string...")) self.delay_timer = QTimer(self) self.delay_timer.setSingleShot(True) self.delay_timer.setInterval(250) self.delay_timer.timeout.connect(self.start_search) self.txtSearch.textChanged.connect(self.delay_timer.start) self.btnFilterByExtent.toggled.connect(self.toggle_filter_button) self.one_process_work = QMutex() self.add_last_used_services() self.show_news()
def __init__(self, iface, layers, parent=None): QDockWidget.__init__(self, parent) self.setupUi(self) self.layers = layers self.count_id = None self.sensor = None self.status = self.layers.IMPORT_STATUS_DEFINITIVE
def __init__(self, parent=None): QDockWidget.__init__(self, parent) self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea) self.setWidget(QueryWidget()) self.setWindowTitle(tr("ui_query", "QuickOSM - Query")) self.widget().signal_new_query_successful.connect( self.signal_new_query_successful.emit)
def initGui(self): # add action to toolbar self.action = QAction(QIcon(":/plugins/mutant/img/icon.svg"), "Mutant", self.iface.mainWindow()) self.iface.addToolBarIcon(self.action) self.tool = MutantMap(self.canvas, self.action) self.saveTool = None self.action.triggered.connect(self.activateTool) self.tool.deactivated.connect(self.deactivateTool) # create the widget to display information self.mutantwidget = MutantWidget(self.iface) self.tool.moved.connect(self.mutantwidget.toolMoved) self.tool.pressed.connect(self.mutantwidget.toolPressed) self.mutantwidget.toggleMutant.clicked.connect(self.toggleTool) self.mutantwidget.plotOnMove.clicked.connect(self.toggleMouseClick) # create the dockwidget with the correct parent and add the widget self.mutantdockwidget = QDockWidget("Mutant", self.iface.mainWindow()) self.mutantdockwidget.setObjectName("Mutant") self.mutantdockwidget.setWidget(self.mutantwidget) # QObject.connect(self.mutantdockwidget, # SIGNAL('visibilityChanged ( bool )'), self.showHideDockWidget) # add the dockwidget to iface self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.mutantdockwidget)
def initGui(self): # Create action that will show plugin widget self.action = QAction( QIcon(os.path.join(self.plugin_dir, "icons/select2.png")), # the following does not seem to work anymore, maybe since PyQt5?! #QIcon(':/plugins/LayerFeatureLabeler/icons/select.png'), u"LayerFeatureLabeler", self.iface.mainWindow()) # connect the action to the run method self.action.triggered.connect(self.run) # Add toolbar button and menu item self.iface.addToolBarIcon(self.action) self.iface.addPluginToMenu(u"&VectorLayerTool", self.action) #creating dock view intance # self.dock = attributePainterDialog(self.iface) self.dockwidget = QDockWidget("Layer Feature Labeler", self.iface.mainWindow()) self.dockwidget.setObjectName("Layer Feature Labeler") self.dockwidget.setWidget(self.dock) self.layerHighlighted = None self.sourceFeat = None # here the map tool is choosen self.sourceMapTool = IdentifyGeometry(self.canvas, pickMode='active') self.destinationMapTool = IdentifyGeometry(self.canvas, pickMode='active')
def on_view_plots(self, plot_type): layer = self.iface.activeLayer() if not layer: return if layer.id() not in self.__config: if layer.geometryType() != QgsWkbTypes.NullGeometry: dlg = ConfigurePlotDialog(layer, self.iface.mainWindow()) if dlg.exec_(): conf = dlg.config() self.__config[layer.id()] = conf json_config = json.dumps(self.__config) QgsProject.instance().writeEntry("QGeoloGIS", "config", json_config) else: return else: return if plot_type == "logs": self.__dock = QDockWidget("Well Logs") else: self.__dock = QDockWidget("Timeseries") self.__dock.setObjectName("QGeoloGIS_plot_view_dock") dialog = MainDialog(self.__dock, plot_type, self.__config, layer, self.iface) self.__dock.setWidget(dialog) self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.__dock)
def __init__(self, iface, parent=None): QDockWidget.__init__(self, parent) self.setupUi(self) self.iface = iface self.message_bar = self.iface.messageBar() # self.layer = None self._gui_elements = [self.treeWidget]
def __init__(self): """Constructor for the dialog. """ QDockWidget.__init__(self) self.setupUi(self)
def __init__(self, parent, plugin): self.plugin = plugin QDockWidget.__init__(self, parent) self.setupUi(self) self.btnApply.setIcon( QIcon(str(DIR_PLUGIN_ROOT / "resources/arrow_green.png"))) self.btnMask.setIcon( QIcon(str(DIR_PLUGIN_ROOT / "resources/add_mask.png"))) self.btnLayer.setIcon( QIcon(str(DIR_PLUGIN_ROOT / "resources/add_layer.png"))) self.btnHelp.setIcon( QIcon(QgsApplication.iconPath("mActionHelpContents.svg"))) self.tableResult.installEventFilter(self) # cf. eventFilter method self.tableResult.cellDoubleClicked.connect(self.onChoose) self.tableResult.cellEntered.connect(self.cellEntered) self.editSearch.returnPressed.connect(self.onReturnPressed) self.btnSearch.clicked.connect(self.onReturnPressed) self.btnApply.clicked.connect(self.onApply) self.btnHelp.clicked.connect( lambda: showPluginHelp(filename="../doc/index")) self.btnLocalize.clicked.connect(self.doLocalize) self.btnMask.clicked.connect(self.onMask) self.btnLayer.clicked.connect(self.onLayer) self.singleLayerId = { QgsWkbTypes.PolygonGeometry: None, QgsWkbTypes.LineGeometry: None, QgsWkbTypes.PointGeometry: None, } self.singleLayerName = { QgsWkbTypes.PolygonGeometry: "OSM Place Search Polygons", QgsWkbTypes.LineGeometry: "OSM Place Search Lines", QgsWkbTypes.PointGeometry: "OSM Place Search Points", } self.memoryLayerType = { QgsWkbTypes.PolygonGeometry: "MultiPolygon", QgsWkbTypes.LineGeometry: "MultiLineString", QgsWkbTypes.PointGeometry: "Point", } try: self.cbExtent.setChecked(tools.limitSearchToExtent) except: self.cbExtent.setChecked(tools.limitSearchToExtent) self.currentExtent = self.plugin.canvas.extent() self.tableResult.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) try: self.editSearch.setText(self.plugin.lastSearch) except: pass
def _setDocWidget(self): self._dockwidget = QDockWidget( QApplication.translate("OpenLayersOverviewWidget", "OpenLayers Overview"), self._iface.mainWindow()) self._dockwidget.setObjectName("dwOpenlayersOverview") self._oloWidget = OpenLayersOverviewWidget(self._iface, self._dockwidget, self._olLayerTypeRegistry) self._dockwidget.setWidget(self._oloWidget)
def __init__(self, parent,iface,msettings): self.parent = parent self.iface=iface #midvsettings instance self.ms = msettings self.ms.loadSettings() #initiate the dockwidget QDockWidget.__init__(self, self.parent) self.setAttribute(Qt.WA_DeleteOnClose) self.setupUi( self )#Required by Qt4 to initialize the UI self.initUI()
def __init__(self, parent, iface, msettings): self.parent = parent self.iface = iface #midvsettings instance self.ms = msettings self.ms.loadSettings() #initiate the dockwidget QDockWidget.__init__(self, self.parent) self.setAttribute(Qt.WA_DeleteOnClose) self.setupUi(self) #Required by Qt4 to initialize the UI self.initUI()
def __init__(self, iface, parent=None, featuresId=None, layer=None): QDockWidget.__init__(self) self.setupUi(self) self.DEFAULT_URL = ("http://" + config.IP + ":" + str(config.PORT) + "/viewer.html") self.DEFAULT_EMPTY = ("http://" + config.IP + ":" + str(config.PORT) + "/none.html") self.DEFAULT_BLANK = ("http://" + config.IP + ":" + str(config.PORT) + "/blank.html") # Create Viewer self.CreateViewer() self.plugin_path = os.path.dirname(os.path.realpath(__file__)) self.iface = iface self.canvas = self.iface.mapCanvas() self.parent = parent # Orientation from image self.yaw = math.pi self.bearing = None self.layer = layer self.featuresId = featuresId self.actualPointDx = None self.actualPointSx = None self.actualPointOrientation = None self.selected_features = qgsutils.getToFeature(self.layer, self.featuresId) # Get image path self.current_image = self.GetImage() # Check if image exist if os.path.exists(self.current_image) is False: qgsutils.showUserAndLogMessage(u"Information: ", u"There is no associated image.") self.resetQgsRubberBand() self.ChangeUrlViewer(self.DEFAULT_EMPTY) return # Copy file to local server self.CopyFile(self.current_image) # Set RubberBand self.resetQgsRubberBand() self.setOrientation() self.setPosition()
class SeptimaGeoSearch(object): def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path() + "/python/plugins/" + __package__ # initialize locale. Default to Danish self.config = QSettings() localePath = "" try: locale = self.config.value("locale/userLocale")[0:2] except: locale = 'da' if QFileInfo(self.plugin_dir).exists(): localePath = self.plugin_dir + "/i18n/" + locale + ".qt.qm" if QFileInfo(localePath).exists(): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QgsApplication.installTranslator(self.translator) # new config method self.settings = Settings() self.options_factory = OptionsFactory(self.settings) self.options_factory.setTitle('Geosearch DK') iface.registerOptionsWidgetFactory(self.options_factory) def initGui(self): # create the widget to display information self.searchwidget = SearchBox(self.iface) # create the dockwidget with the correct parent and add the valuewidget self.searchdockwidget = QDockWidget( "Geosearch DK", self.iface.mainWindow() ) self.searchdockwidget.setObjectName("Geosearch DK") self.searchdockwidget.setWidget(self.searchwidget) # add the dockwidget to iface self.iface.addDockWidget( Qt.TopDockWidgetArea, self.searchdockwidget ) # Make changed settings apply immediately self.settings.settings_updated.connect(self.searchwidget.readconfig) def unload(self): self.searchwidget.unload() # try to avoid processing events, when QGIS is closing self.iface.removeDockWidget(self.searchdockwidget) self.iface.unregisterOptionsWidgetFactory(self.options_factory)
def initGui(self): # create the widget to display information self.searchwidget = SearchBox(self.iface) # create the dockwidget with the correct parent and add the valuewidget self.searchdockwidget = QDockWidget("Geosearch DK", self.iface.mainWindow()) self.searchdockwidget.setObjectName("Geosearch DK") self.searchdockwidget.setWidget(self.searchwidget) # add the dockwidget to iface self.iface.addDockWidget(Qt.TopDockWidgetArea, self.searchdockwidget) # Make changed settings apply immediately self.settings.settings_updated.connect(self.searchwidget.readconfig)
def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = os.path.join(self.plugin_dir, 'res', 'icon.png') self.mainAction = self.add_action(icon_path, text=self.tr(u'go2mapillary'), callback=self.run, checkable=True, parent=self.iface.mainWindow()) self.dlg = go2mapillaryDockWidget() self.dockwidget = QDockWidget("go2mapillary", self.iface.mainWindow()) self.dockwidget.setObjectName("go2mapillary") self.dockwidget.setWidget(self.dlg) self.dockwidget.visibilityChanged.connect( self.mlyDockwidgetvisibilityChanged) self.dlg.webView.page().setNetworkAccessManager( QgsNetworkAccessManager.instance()) self.dlg.webView.page().mainFrame().setScrollBarPolicy( Qt.Vertical, Qt.ScrollBarAlwaysOff) self.dlg.webView.page().mainFrame().setScrollBarPolicy( Qt.Horizontal, Qt.ScrollBarAlwaysOff) self.canvas.mapToolSet.connect(self.toggleViewer) self.viewer = mapillaryViewer(self) self.viewer.messageArrived.connect(self.viewerConnection) self.viewer.openFilter.connect(self.filter_images_func) #QgsExpressionContextUtils.setGlobalVariable( "mapillaryCurrentKey","noKey") QgsExpressionContextUtils.removeGlobalVariable("mapillaryCurrentKey") self.mapSelectionTool = None self.coverage = mapillary_coverage(self) self.filterDialog = mapillaryFilter(self) self.filterAction_images = QAction(QIcon(icon_path), 'filter mapillary coverage', self.iface.mainWindow()) self.filterAction_sequences = QAction(QIcon(icon_path), 'filter mapillary coverage', self.iface.mainWindow()) self.filterAction_overview = QAction(QIcon(icon_path), 'filter mapillary coverage', self.iface.mainWindow()) self.filterAction_images.triggered.connect(self.filter_images_func) self.filterAction_sequences.triggered.connect( self.filter_sequences_func) self.filterAction_overview.triggered.connect(self.filter_overview_func) self.sample_cursor = mapillary_cursor(self) self.sample_settings = mapillarySettings(self) self.sample_cursor.update_ds( self.sample_settings.settings['sample_source']) self.samples_form = mapillaryForm(self) self.iface.projectRead.connect(self.removeMapillaryLayerGroup) self.canvas.mapCanvasRefreshed.connect(self.mapRefreshed) self.enableMapillaryRender = False
def __init__(self, parent=None): QDockWidget.__init__(self, parent) self.setObjectName("PythonConsole") self.setWindowTitle(QCoreApplication.translate("PythonConsole", "Python Console")) # self.setAllowedAreas(Qt.BottomDockWidgetArea) self.console = PythonConsoleWidget(self) self.setWidget(self.console) self.setFocusProxy(self.console) # try to restore position from stored main window state if iface and not iface.mainWindow().restoreDockWidget(self): iface.mainWindow().addDockWidget(Qt.BottomDockWidgetArea, self)
def __init__(self, parent, canvas, add_dock_widget): QDockWidget.__init__(self, parent) self.setupUi(self) self.selectCurrentPathAction = QAction(self.tr('Select current path'), self.selectButton) self.selectCurrentPathAction.triggered.connect(self.onSelectCurrentPathAction) self.selectButton.setDefaultAction(self.selectCurrentPathAction) self.configureSelectionAction = QAction(self.tr('Configure Select'), self.selectButton) self.configureSelectionAction.triggered.connect(self.onConfigureSelectAction) self.selectButton.addAction(self.configureSelectionAction) self.setAttribute(Qt.WA_DeleteOnClose) self.canvas = canvas self.addDockWidget = add_dock_widget
class SeptimaGeoSearch(object): def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = QFileInfo(QgsApplication.qgisUserDatabaseFilePath() ).path() + "/python/plugins/" + __package__ # initialize locale. Default to Danish self.config = QSettings() localePath = "" try: locale = self.config.value("locale/userLocale")[0:2] except: locale = 'da' if QFileInfo(self.plugin_dir).exists(): localePath = self.plugin_dir + "/i18n/" + locale + ".qt.qm" if QFileInfo(localePath).exists(): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QgsApplication.installTranslator(self.translator) # new config method self.settings = Settings() self.options_factory = OptionsFactory(self.settings) self.options_factory.setTitle('Geosearch DK') iface.registerOptionsWidgetFactory(self.options_factory) def initGui(self): # create the widget to display information self.searchwidget = SearchBox(self.iface) # create the dockwidget with the correct parent and add the valuewidget self.searchdockwidget = QDockWidget("Geosearch DK", self.iface.mainWindow()) self.searchdockwidget.setObjectName("Geosearch DK") self.searchdockwidget.setWidget(self.searchwidget) # add the dockwidget to iface self.iface.addDockWidget(Qt.TopDockWidgetArea, self.searchdockwidget) # Make changed settings apply immediately self.settings.settings_updated.connect(self.searchwidget.readconfig) def unload(self): self.searchwidget.unload( ) # try to avoid processing events, when QGIS is closing self.iface.removeDockWidget(self.searchdockwidget) self.iface.unregisterOptionsWidgetFactory(self.options_factory)
def __init__(self, iface, layer, currentFeature): self.iface = iface self.layer = layer self.renderer = self.iface.mapCanvas().mapSettings() self.settings = MySettings() QDockWidget.__init__(self) self.setupUi(self) self.setWindowTitle("ItemBrowser: %s" % layer.name()) if layer.isSpatial() is False: self.panCheck.setChecked(False) self.panCheck.setEnabled(False) self.scaleCheck.setChecked(False) self.scaleCheck.setEnabled(False) self.previousButton.setArrowType(Qt.LeftArrow) self.nextButton.setArrowType(Qt.RightArrow) icon = QIcon(":/plugins/itembrowser/icons/openform.svg") self.editFormButton.setIcon(icon) # actions icon = QIcon(":/plugins/itembrowser/icons/action.svg") self.actionButton.setIcon(icon) self.attrAction = layer.actions() actions = [self.attrAction.actions()[i] for i in range(len(self.attrAction.actions()))] preferredAction = layer.customProperty("ItemBrowserPreferedAction", "") if preferredAction not in actions: dfltAction = self.attrAction.defaultAction("Layer") if dfltAction: preferredAction = dfltAction.name() preferredActionFound = False for i, action in enumerate(actions): qAction = QAction(QIcon(":/plugins/itembrowser/icons/action.svg"), action.name(), self) qAction.triggered.connect(lambda checked, uid=action.id(),i=i: self.doAction(uid,i)) self.actionButton.addAction(qAction) if action.name() == preferredAction: self.actionButton.setDefaultAction(qAction) preferredActionFound = True if len(actions) == 0: self.actionButton.setEnabled(False) elif not preferredActionFound: self.actionButton.setDefaultAction(self.actionButton.actions()[0]) self.rubber = QgsRubberBand(self.iface.mapCanvas()) self.selectionChanged() if currentFeature == self.listCombo.currentIndex(): self.on_listCombo_currentIndexChanged(currentFeature) else: self.listCombo.setCurrentIndex(currentFeature) self.layer.willBeDeleted.connect(self.close) self.layer.selectionChanged.connect(self.selectionChanged)
def __init__(self, parent, iface): QDockWidget.__init__(self, parent) self.setupUi(self) self.layerComboBox.currentIndexChanged.connect(self.layerChanged) self.stateButton.clicked.connect(self.stateChanged) self.iface = iface self.layerComboBox.insertItem(self.layerComboBox.count(), self.tr('Wastewater Structure'), 'wastewater_structure') self.layerComboBox.insertItem(self.layerComboBox.count(), self.tr('Reach'), 'reach') self.stateButton.setProperty('state', 'inactive') self.mapToolAddReach = QgepMapToolAddReach( self.iface, QgepLayerManager.layer('vw_qgep_reach'))
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 __init__(self, parent, iface1, mdl1): QDockWidget.__init__(self, parent) self.setAttribute(Qt.WA_DeleteOnClose) self.parent = parent self.location = Qt.RightDockWidgetArea self.iface = iface1 self.setupUi(self) #self.connect(self, SIGNAL("dockLocationChanged(Qt::DockWidgetArea)"), self.setLocation) self.mdl = mdl1 #self.showed = False self.mdl.rowsInserted.connect(self.addPersistentEditorForRows) self.cboXAxis.currentIndexChanged.connect(self.changeXAxisLabeling) self.butLoadXAxisSteps.clicked.connect(self.loadXAxisStepsFromFile) self.butSaveAs.clicked.connect(self.saveAs)
def __init__(self, iface, chart): dir_path = os.path.dirname(os.path.realpath(__file__)) qml = os.path.join(dir_path, "qml", "scatterplot.qml") self.view = QQuickView() self.view.setResizeMode(QQuickView.SizeRootObjectToView) self.view.rootContext().setContextProperty("pychart", chart) self.view.setColor(QColor("#000000")) self.view.setSource(QUrl.fromLocalFile(qml)) self.container = QWidget.createWindowContainer(self.view) self.widget = QDockWidget() self.widget.setWidget(self.container) iface.addDockWidget(Qt.BottomDockWidgetArea, self.widget) self.read_settings()
def eventFilter(self, source, event): ''' Event Filter ''' if (event.type() == QEvent.MouseButtonPress and source is self.VManager.viewport() and self.VManager.itemAt(event.pos()) is None): self.VManager.clearSelection() return QDockWidget.eventFilter(self, source, event)
def resizeEvent(self, event): fsize = max(8, event.size().width() / 50) if fsize != self.fontSize: self.fontSize = fsize self.dockWidgetContents.setStyleSheet( "font-weight: bold; font-size: {}pt".format(self.fontSize)) return QDockWidget.resizeEvent(self, event)
def __init__(self): QDockWidget.__init__(self) self.setWindowTitle('Shogun Editor') self.setContextMenuPolicy(Qt.DefaultContextMenu) self.setLayoutDirection(Qt.LeftToRight) self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea) self.setFloating(False) self.dockWidgetContents = QWidget(self) self.dockWidgetContents.setGeometry(QRect(20, 30, 320, 700)) self.newConnectionButton = QPushButton(self.dockWidgetContents) self.newConnectionButton.setGeometry(QRect(10, 0, 141, 27)) self.newConnectionButton.setText('New Connection') self.treeWidget = QTreeWidget(self.dockWidgetContents) self.treeWidget.setGeometry(QRect(10, 40, 300, 650)) self.treeWidget.setContextMenuPolicy(Qt.CustomContextMenu) self.treeWidget.setHeaderHidden(True) self.treeWidget.setColumnCount(1)
def _setDocWidget(self): self._dockwidget = QDockWidget(QApplication.translate( "OpenLayersOverviewWidget", "OpenLayers Overview"), self._iface.mainWindow()) self._dockwidget.setObjectName("dwOpenlayersOverview") self._oloWidget = OpenLayersOverviewWidget(self._iface, self._dockwidget, self._olLayerTypeRegistry) self._dockwidget.setWidget(self._oloWidget)
def __init__(self): QDockWidget.__init__(self) # Set up the user interface from Designer. self.ui = Ui_PDOKservices() self.ui.setupUi(self) self.servicesView = self.ui.servicesView # only select one row at a time: self.servicesView.setSelectionMode(self.servicesView.SingleSelection) # select whole row if an item is clicked self.servicesView.setSelectionBehavior(self.servicesView.SelectRows) self.servicesView.setAutoScroll(False) self.layerSearch = self.ui.layerSearch self.geocoderSearch = self.ui.geocoderSearch self.geocoderResultSearch = self.ui.geocoderResultSearch self.geocoderResultView = self.ui.geocoderResultView self.geocoderResultView.setSelectionMode(self.geocoderResultView.SingleSelection) # select whole row if an item is clicked self.geocoderResultView.setSelectionBehavior(self.geocoderResultView.SelectRows) self.tabs = self.ui.tabWidget self.radioDocked = self.ui.radio_docked_widget self.btnCheckPdokJson = self.ui.btn_check_pdokjson
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 initGui(self): # create the widget to display information self.searchwidget = SearchBox(self.iface) # create the dockwidget with the correct parent and add the valuewidget self.searchdockwidget = QDockWidget( "Geosearch DK", self.iface.mainWindow() ) self.searchdockwidget.setObjectName("Geosearch DK") self.searchdockwidget.setWidget(self.searchwidget) # add the dockwidget to iface self.iface.addDockWidget( Qt.TopDockWidgetArea, self.searchdockwidget ) # Make changed settings apply immediately self.settings.settings_updated.connect(self.searchwidget.readconfig)
def initGui(self): # Create action that will show plugin widget self.action = QAction( QIcon(os.path.join(self.plugin_dir,"icon.png")), u"AttributePainter", self.iface.mainWindow()) # connect the action to the run method self.action.triggered.connect(self.run) # Add toolbar button and menu item self.iface.addToolBarIcon(self.action) self.iface.addPluginToMenu(u"&foglioMappale", self.action) #creating dock view intance self.dock = attributePainterDialog(self.iface) self.apdockwidget=QDockWidget("AttributePainter" , self.iface.mainWindow() ) self.apdockwidget.setObjectName("AttributePainter") self.apdockwidget.setWidget(self.dock) self.layerHighlighted = None self.sourceFeat = None #setting dock view buttons behavior self.dock.PickSource.toggled.connect(self.setSourceMapTool) self.dock.ResetSource.clicked.connect(self.resetSource) self.dock.PickDestination.clicked.connect(self.applyToDestination) self.dock.PickDestination.setDisabled(True) self.dock.PickApply.setDisabled(True) self.dock.PickApply.toggled.connect(self.setDestinationMapTool) self.dock.checkBox.clicked.connect(self.selectAllCheckbox) self.dock.tableWidget.setColumnCount(3) self.initTable() #setting interface behaviours self.session = destinationLayerState() try: #QGIS2 API self.iface.legendInterface().currentLayerChanged.connect(self.checkOnLayerChange) except: #QGIS3 API self.iface.currentLayerChanged.connect(self.checkOnLayerChange) self.iface.addDockWidget( Qt.LeftDockWidgetArea, self.apdockwidget ) self.iface.projectRead.connect(self.resetSource) self.iface.newProjectCreated.connect(self.resetSource) self.canvas.mapToolSet.connect(self.toggleMapTool) self.sourceMapTool = IdentifyGeometry(self.canvas,pickMode='selection') self.destinationMapTool = IdentifyGeometry(self.canvas,pickMode='active') self.sourceMapTool.geomIdentified.connect(self.setSourceFeature) self.destinationMapTool.geomIdentified.connect(self.setDestinationFeature) #Call reset procedure to initialize widget self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride) self.resetSource() self.actualLayer = None
class OLOverview(object): def __init__(self, iface, olLayerTypeRegistry): self._iface = iface self._olLayerTypeRegistry = olLayerTypeRegistry self._dockwidget = None self._oloWidget = None # Private def _setDocWidget(self): self._dockwidget = QDockWidget(QApplication.translate( "OpenLayersOverviewWidget", "OpenLayers Overview"), self._iface.mainWindow()) self._dockwidget.setObjectName("dwOpenlayersOverview") self._oloWidget = OpenLayersOverviewWidget(self._iface, self._dockwidget, self._olLayerTypeRegistry) self._dockwidget.setWidget(self._oloWidget) def _initGui(self): self._setDocWidget() self._iface.addDockWidget(Qt.LeftDockWidgetArea, self._dockwidget) def _unload(self): self._dockwidget.close() self._iface.removeDockWidget(self._dockwidget) del self._oloWidget self._dockwidget = None # Public def setVisible(self, visible): if visible: if self._dockwidget is None: self._initGui() else: if self._dockwidget is not None: self._unload()
class attributePainter: 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__) # Source feature rubberband definition colorSource = QColor(250,0,0,200) self.sourceEvid = QgsRubberBand(self.canvas) self.sourceEvid.setColor(colorSource) self.sourceEvid.setWidth(3) def initGui(self): # Create action that will show plugin widget self.action = QAction( QIcon(os.path.join(self.plugin_dir,"icon.png")), u"AttributePainter", self.iface.mainWindow()) # connect the action to the run method self.action.triggered.connect(self.run) # Add toolbar button and menu item self.iface.addToolBarIcon(self.action) self.iface.addPluginToMenu(u"&foglioMappale", self.action) #creating dock view intance self.dock = attributePainterDialog(self.iface) self.apdockwidget=QDockWidget("AttributePainter" , self.iface.mainWindow() ) self.apdockwidget.setObjectName("AttributePainter") self.apdockwidget.setWidget(self.dock) self.layerHighlighted = None self.sourceFeat = None #setting dock view buttons behavior self.dock.PickSource.toggled.connect(self.setSourceMapTool) self.dock.ResetSource.clicked.connect(self.resetSource) self.dock.PickDestination.clicked.connect(self.applyToDestination) self.dock.PickDestination.setDisabled(True) self.dock.PickApply.setDisabled(True) self.dock.PickApply.toggled.connect(self.setDestinationMapTool) self.dock.checkBox.clicked.connect(self.selectAllCheckbox) self.dock.tableWidget.setColumnCount(3) self.initTable() #setting interface behaviours self.session = destinationLayerState() try: #QGIS2 API self.iface.legendInterface().currentLayerChanged.connect(self.checkOnLayerChange) except: #QGIS3 API self.iface.currentLayerChanged.connect(self.checkOnLayerChange) self.iface.addDockWidget( Qt.LeftDockWidgetArea, self.apdockwidget ) self.iface.projectRead.connect(self.resetSource) self.iface.newProjectCreated.connect(self.resetSource) self.canvas.mapToolSet.connect(self.toggleMapTool) self.sourceMapTool = IdentifyGeometry(self.canvas,pickMode='selection') self.destinationMapTool = IdentifyGeometry(self.canvas,pickMode='active') self.sourceMapTool.geomIdentified.connect(self.setSourceFeature) self.destinationMapTool.geomIdentified.connect(self.setDestinationFeature) #Call reset procedure to initialize widget self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride) self.resetSource() self.actualLayer = None def selectAllCheckbox(self): ''' select or deselect items in qtablewidget on "select all attributes" checkbox clicked ''' for rowTabWidget in range(0,self.dock.tableWidget.rowCount()): self.dock.tableWidget.item(rowTabWidget,0).setCheckState(self.dock.checkBox.checkState()) def initTable(self): ''' QTableWidget initialization ''' header = QTableWidgetItem(" ") header.setTextAlignment(Qt.AlignLeft) self.dock.tableWidget.setHorizontalHeaderItem(0,header) header = QTableWidgetItem("FIELD") header.setTextAlignment(Qt.AlignLeft) self.dock.tableWidget.setHorizontalHeaderItem(1,header) header = QTableWidgetItem("VALUE") header.setTextAlignment(Qt.AlignLeft) self.dock.tableWidget.setHorizontalHeaderItem(2,header) self.dock.tableWidget.resizeColumnsToContents() def setComboField(self,content,type,layer): ''' returns a qcombobox loaded with compatible field names (depending on selected layer) ''' combo = QComboBox(); fieldNames = self.scanLayerFieldsNames(layer) fieldTypes = self.scanLayerFieldsTypes(layer) choices = [] for n in range(0,len(fieldTypes)): if fieldTypes[n] == type: choices.append(fieldNames[n]) combo.addItems(choices) if content in choices: combo.setCurrentIndex(choices.index(content)) else: combo.addItem(content) combo.setCurrentIndex(combo.count()-1) combo.activated.connect(lambda: self.highlightCompatibleFields(LayerChange=None)) return combo def getFieldsIterator(self,layer): try: return layer.pendingFields except: return layer.fields def scanLayerFieldsNames(self,layer): ''' returns fields names as strings list ''' if layer: return [field.name() for field in self.getFieldsIterator(layer)()] else: return [] def scanLayerFieldsTypes(self,layer): ''' returns fields types as qvariant list ''' if layer: return [field.type() for field in self.getFieldsIterator(layer)()] else: return [] def selectSource(self): ''' source feature selection procedure ''' if self.layerHighlighted: self.resetSource() try: self.dock.tableWidget.itemChanged.disconnect(self.highLightCellOverride) except: pass #take first selected feature as source feature self.sourceFeat = self.selectedFeature #hightlight source feature with rubberband self.sourceEvid.setToGeometry(self.sourceFeat.geometry(),self.selectedLayer) #get current layer attributes labels list field_names = self.scanLayerFieldsNames(self.selectedLayer) field_types = self.scanLayerFieldsTypes(self.selectedLayer) self.sourceAttrsTab=[] self.dock.tableWidget.setRowCount(len(field_names)) #loading attributes labels and values in QTableWidget for n in range(0,len(field_names)): item=QTableWidgetItem() item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Unchecked) item.setText("") #set first column as checkbox self.dock.tableWidget.setItem(n,0,item) #set second colunm as attribute label as qcombobox widget self.dock.tableWidget.setCellWidget(n,1,self.setComboField(field_names[n],field_types[n],self.canvas.currentLayer())) #set third column as attribute value item = QTableWidgetItem() item.setData(Qt.DisplayRole,self.sourceFeat.attributes()[n]) self.dock.tableWidget.setItem(n,2,item) #resize table to contents self.dock.tableWidget.resizeColumnsToContents() self.dock.tableWidget.horizontalHeader().setStretchLastSection(True) #procedure to recover same field selection if current source feature has the same layer of the precedent one if self.selectedLayer.id() != self.activeLayer: self.sourceAttrs={} self.activeLayer = self.selectedLayer.id() else: for Attr in self.sourceAttrs: self.dock.tableWidget.item(Attr,0).setCheckState(Qt.Checked) #Enable button to apply or reset self.dock.ResetSource.setEnabled(True) self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride) self.checkOnLayerChange(self.canvas.currentLayer()) def highLightCellOverride(obj,item): ''' landing method on cell value change ''' if item.column() == 2: item.setBackground(QBrush(QColor(183,213,225))) #item.setForeground (QBrush(QColor(255,0,0))) def toggleMapTool(self,mapTool): ''' landing method on canvas maptool change ''' self.dock.PickSource.blockSignals(True) self.dock.PickApply.blockSignals(True) if mapTool != self.sourceMapTool and mapTool != self.destinationMapTool: self.dock.PickSource.setChecked(False) self.dock.PickApply.setChecked(False) elif mapTool == self.sourceMapTool: self.dock.PickApply.setChecked(False) elif mapTool == self.destinationMapTool: self.dock.PickSource.setChecked(False) self.dock.PickSource.blockSignals(False) self.dock.PickApply.blockSignals(False) def checkOnLayerChange(self,cLayer): ''' landing method on current layer change ''' if cLayer and cLayer.type() == QgsMapLayer.VectorLayer: self.session.backupState(self.layerHighlighted, self.dock.tableWidget) # Restore a session for the current layer or custom table items to it if self.layerHighlighted: self.layerHighlighted.editingStarted.disconnect(self.checkEditable) self.layerHighlighted.editingStopped.disconnect(self.checkEditable) if cLayer: self.layerHighlighted = cLayer self.checkEditable() cLayer.editingStarted.connect(self.checkEditable) cLayer.editingStopped.connect(self.checkEditable) self.session.restoreState(cLayer,self.dock.tableWidget) def highlightCompatibleFields(self, LayerChange = True): ''' method to highlight compatible field on selected feature (even on different layer) ''' if self.dock.tableWidget.rowCount()>0: source_field_names = self.scanLayerFieldsNames(self.selectedLayer) source_field_types = self.scanLayerFieldsTypes(self.selectedLayer) destination_field_names = self.scanLayerFieldsNames(self.canvas.currentLayer()) self.dock.tableWidget.itemChanged.disconnect(self.highLightCellOverride) for row in range (0,self.dock.tableWidget.rowCount()): if LayerChange: self.dock.tableWidget.setCellWidget(row,1,self.setComboField(source_field_names[row],source_field_types[row],self.canvas.currentLayer())) if self.dock.tableWidget.cellWidget(row,1).currentText() in destination_field_names: #self.dock.tableWidget.item(row,1).setForeground(QBrush(QColor(0,0,0))) self.dock.tableWidget.item(row,2).setForeground(QBrush(QColor(0,0,0))) else: #self.dock.tableWidget.item(row,1).setForeground(QBrush(QColor(130,130,130))) self.dock.tableWidget.item(row,2).setForeground(QBrush(QColor(130,130,130))) self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride) def checkEditable(self): ''' method to enable or disable apply to destination button ''' if self.layerHighlighted: self.highlightCompatibleFields() if self.layerHighlighted.isEditable() and self.sourceFeat: self.dock.PickDestination.setEnabled(True) self.dock.PickApply.setEnabled(True) else: self.dock.PickDestination.setDisabled(True) self.dock.PickApply.setDisabled(True) def resetSource(self): ''' method to clear source and reset attribute table ''' self.dock.tableWidget.itemChanged.disconnect(self.highLightCellOverride) self.doReset() #if self.canvas.layers()!=[]: # self.iface.activeLayer().removeSelection() self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride) def doReset(self): ''' method to clear source and reset attribute table ''' self.dock.PickDestination.setDisabled(True) #clear source highlight self.sourceEvid.reset() #clear source definition self.sourceFeat = None self.sourceAttrs={} self.activeLayer = "nn" self.session.removeState(self.canvas.currentLayer()) self.layerHighlighted = None #clear dock widget while self.dock.tableWidget.rowCount()>0: self.dock.tableWidget.removeRow(0) self.dock.PickDestination.setEnabled(False) self.dock.ResetSource.setEnabled(False) def applyToDestination(self): ''' method to apply selected fields to selected destination features ''' if self.canvas.currentLayer().selectedFeatures()!=[]: self.sourceAttributes = self.getSourceAttrs() #apply source attribute values to selected destination features for f in self.canvas.currentLayer().selectedFeatures(): self.applyToFeature(f,self.sourceAttributes) self.iface.activeLayer().removeSelection() self.canvas.currentLayer().triggerRepaint() else: pass #print ("nothing selected") def getSourceAttrs(self): ''' rebuild source attribute dict set to apply to destination features ''' sourceAttrs={} for rowTabWidget in range(0,self.dock.tableWidget.rowCount()): rowCheckbox = self.dock.tableWidget.item(rowTabWidget,0) #take only checked attributes if rowCheckbox.checkState() == Qt.Checked: sourceAttrs.update({rowTabWidget:[self.dock.tableWidget.cellWidget(rowTabWidget,1).currentText(),self.dock.tableWidget.item(rowTabWidget,2).data(Qt.DisplayRole)]}) return sourceAttrs def applyToFeature(self,feature,sourceSet): ''' method to apply destination fields cyclying between feature fields ''' #print (sourceSet.items()) for attrId,attrValue in sourceSet.items(): try: feature[attrValue[0]]=attrValue[1] self.canvas.currentLayer().updateFeature(feature) self.canvas.currentLayer().triggerRepaint() except Exception as e: print ('Exception in applyToFeature',e) self.highlight(feature.geometry()) def highlight(self,geometry): def processEvents(): try: qApp.processEvents() except: QApplication.processEvents() highlight = QgsRubberBand(self.canvas, geometry.type()) highlight.setColor(QColor("#36AF6C")) highlight.setFillColor(QColor("#36AF6C")) highlight.setWidth(2) highlight.setToGeometry(geometry,self.canvas.currentLayer()) processEvents() sleep(.1) highlight.hide() processEvents() sleep(.1) highlight.show() processEvents() sleep(.1) highlight.reset() processEvents() def run(self): ''' show/hide the widget ''' if self.apdockwidget.isVisible(): self.apdockwidget.hide() self.resetSource() else: self.apdockwidget.show() def unload(self): ''' Remove the plugin widget and clear source feature highlight ''' if self.sourceFeat: self.sourceEvid.reset() self.iface.removeToolBarIcon(self.action) self.iface.removeDockWidget(self.apdockwidget) self.canvas.mapToolSet.disconnect(self.toggleMapTool) try: self.iface.legendInterface().currentLayerChanged.disconnect(self.checkOnLayerChange) except: self.iface.currentLayerChanged.disconnect(self.checkOnLayerChange) self.iface.projectRead.disconnect(self.resetSource) def setSourceFeature(self, layer, feature): ''' landing method on source maptool identify ''' self.selectedLayer = layer self.selectedFeature = feature self.dock.PickSource.setChecked(False) self.canvas.setMapTool(self.oldMapTool) self.selectSource() def setDestinationFeature(self, layer, feature): ''' landing method on destination maptool identify ''' sourceAttributes = self.getSourceAttrs() self.applyToFeature(feature,sourceAttributes) def setSourceMapTool(self, checked): ''' landing method on pick source button toggle ''' if checked: self.oldMapTool = self.canvas.mapTool() self.canvas.setMapTool(self.sourceMapTool) else: self.oldMapTool = self.canvas.mapTool() def setDestinationMapTool(self,checked): ''' landing method on pick apply button toggle ''' if checked: self.oldMapTool = self.canvas.mapTool() self.canvas.setMapTool(self.destinationMapTool) else: self.canvas.setMapTool(self.oldMapTool)
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 __init__(self, iface): QMainWindow.__init__(self) self.resize(600, 600) self.layer = None self.iface = iface self.dstpoints = [] self.srcpoints = [] self.filename = None self.cursrc = None self.curdst = None self.xform_m2r = None self.xform_r2m = None self.canvas = QgsMapCanvas(self) #self.canvas.setCachingEnabled(True) self.canvas.setCanvasColor(Qt.white) self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor) self.setCentralWidget(self.canvas) def t(name): return QgsApplication.getThemeIcon('/' + name) actionZoomIn = QAction(t('mActionZoomIn.svg'), "Zoom in", self) actionZoomOut = QAction(t('mActionZoomOut.svg'), "Zoom out", self) actionZoomToLayer = QAction(t('mActionZoomToLayer.svg'), "Zoom To Layer", self) actionZoomToDest = QAction("Zoom To Map", self) actionPan = QAction(t('mActionPan.svg'), "Pan", self) actionOpen = QAction(t('mActionFileOpen.svg'), "Open", self) actionSave = QAction(t('mActionFileSaveAs.svg'), "Save", self) actionAdd = QAction("Add GCP", self) actionDeleteAll = QAction("Delete All GCPs", self) actionZoomIn.setCheckable(True) actionZoomOut.setCheckable(True) actionPan.setCheckable(True) actionAdd.setCheckable(True) actionZoomIn.triggered.connect(self.zoomIn) actionZoomOut.triggered.connect(self.zoomOut) actionZoomToLayer.triggered.connect(self.zoomToLayer) actionZoomToDest.triggered.connect(self.zoomToDest) actionPan.triggered.connect(self.pan) actionOpen.triggered.connect(self.showOpen) actionSave.triggered.connect(self.savePoints) actionAdd.triggered.connect(self.addGcp) actionDeleteAll.triggered.connect(self.deleteAll) self.toolbar = self.addToolBar("Canvas actions") self.toolbar.addAction(actionOpen) self.toolbar.addAction(actionSave) self.toolbar.addSeparator() self.toolbar.addAction(actionPan) self.toolbar.addAction(actionZoomIn) self.toolbar.addAction(actionZoomOut) self.toolbar.addAction(actionZoomToLayer) self.toolbar.addAction(actionZoomToDest) self.toolbar.addSeparator() self.toolbar.addAction(actionAdd) self.toolbar.addSeparator() self.toolbar.addAction(actionDeleteAll) self.toolPan = QgsMapToolPan(self.canvas) self.toolPan.setAction(actionPan) self.toolZoomIn = QgsMapToolZoom(self.canvas, False) self.toolZoomIn.setAction(actionZoomIn) self.toolZoomOut = QgsMapToolZoom(self.canvas, True) self.toolZoomOut.setAction(actionZoomOut) self.toolSrcAdd = CaptureTool(self.canvas, self.iface.cadDockWidget()) self.toolSrcAdd.pointSelected.connect(self.addSrcPoint) self.toolSrcAdd.pointDeleted.connect(self.delSrcPoint) self.toolDestAdd = CaptureTool(self.iface.mapCanvas(), self.iface.cadDockWidget()) self.toolDestAdd.pointSelected.connect(self.addDestPoint) self.toolDestAdd.pointDeleted.connect(self.delDestPoint) #self.toolDestAdd.setAction(actionAdd) self.pan() self.overview = QgsMapOverviewCanvas(None, self.canvas) self.overview_dock = QDockWidget("Overview") self.overview_dock.setWidget(self.overview) self.addDockWidget(Qt.BottomDockWidgetArea, self.overview_dock) self.canvas.enableOverviewMode(self.overview) statusbar = self.statusBar() self.coordslabel = QLabel(statusbar) self.canvas.xyCoordinates.connect(self.showMouseCoordinates) statusbar.addPermanentWidget(self.coordslabel)
def setupUi(self): self.setWindowTitle(self.tr("DB Manager")) self.setWindowIcon(QIcon(":/db_manager/icon")) self.resize(QSize(700, 500).expandedTo(self.minimumSizeHint())) # create central tab widget and add the first 3 tabs: info, table and preview self.tabs = QTabWidget() self.info = InfoViewer(self) self.tabs.addTab(self.info, self.tr("Info")) self.table = TableViewer(self) self.tabs.addTab(self.table, self.tr("Table")) self.preview = LayerPreview(self) self.tabs.addTab(self.preview, self.tr("Preview")) self.setCentralWidget(self.tabs) # display close button for all tabs but the first 3 ones, i.e. # HACK: just hide the close button where not needed (GS) self.tabs.setTabsClosable(True) self.tabs.tabCloseRequested.connect(self.close_tab) tabbar = self.tabs.tabBar() for i in range(3): btn = tabbar.tabButton(i, QTabBar.RightSide) if tabbar.tabButton(i, QTabBar.RightSide) else tabbar.tabButton(i, QTabBar.LeftSide) btn.resize(0, 0) btn.hide() # Creates layout for message bar self.layout = QGridLayout(self.info) self.layout.setContentsMargins(0, 0, 0, 0) spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.layout.addItem(spacerItem, 1, 0, 1, 1) # init messageBar instance self.infoBar = QgsMessageBar(self.info) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.infoBar.setSizePolicy(sizePolicy) self.layout.addWidget(self.infoBar, 0, 0, 1, 1) # create database tree self.dock = QDockWidget("Tree", self) self.dock.setObjectName("DB_Manager_DBView") self.dock.setFeatures(QDockWidget.DockWidgetMovable) self.tree = DBTree(self) self.dock.setWidget(self.tree) self.addDockWidget(Qt.LeftDockWidgetArea, self.dock) # create status bar self.statusBar = QStatusBar(self) self.setStatusBar(self.statusBar) # create menus self.menuBar = QMenuBar(self) self.menuDb = QMenu(self.tr("&Database"), self) self.menuBar.addMenu(self.menuDb) self.menuSchema = QMenu(self.tr("&Schema"), self) actionMenuSchema = self.menuBar.addMenu(self.menuSchema) self.menuTable = QMenu(self.tr("&Table"), self) actionMenuTable = self.menuBar.addMenu(self.menuTable) self.menuHelp = None # QMenu(self.tr("&Help"), self) # actionMenuHelp = self.menuBar.addMenu(self.menuHelp) self.setMenuBar(self.menuBar) # create toolbar self.toolBar = QToolBar("Default", self) self.toolBar.setObjectName("DB_Manager_ToolBar") self.addToolBar(self.toolBar) # create menus' actions # menu DATABASE sep = self.menuDb.addSeparator() sep.setObjectName("DB_Manager_DbMenu_placeholder") sep.setVisible(False) self.actionRefresh = self.menuDb.addAction(QIcon(":/db_manager/actions/refresh"), self.tr("&Refresh"), self.refreshActionSlot, QKeySequence("F5")) self.actionSqlWindow = self.menuDb.addAction(QIcon(":/db_manager/actions/sql_window"), self.tr("&SQL window"), self.runSqlWindow, QKeySequence("F2")) self.menuDb.addSeparator() self.actionClose = self.menuDb.addAction(QIcon(), self.tr("&Exit"), self.close, QKeySequence("CTRL+Q")) # menu SCHEMA sep = self.menuSchema.addSeparator() sep.setObjectName("DB_Manager_SchemaMenu_placeholder") sep.setVisible(False) actionMenuSchema.setVisible(False) # menu TABLE sep = self.menuTable.addSeparator() sep.setObjectName("DB_Manager_TableMenu_placeholder") sep.setVisible(False) self.actionImport = self.menuTable.addAction(QIcon(":/db_manager/actions/import"), self.tr("&Import layer/file"), self.importActionSlot) self.actionExport = self.menuTable.addAction(QIcon(":/db_manager/actions/export"), self.tr("&Export to file"), self.exportActionSlot) self.menuTable.addSeparator() #self.actionShowSystemTables = self.menuTable.addAction(self.tr("Show system tables/views"), self.showSystemTables) #self.actionShowSystemTables.setCheckable(True) #self.actionShowSystemTables.setChecked(True) actionMenuTable.setVisible(False) # add actions to the toolbar self.toolBar.addAction(self.actionRefresh) self.toolBar.addAction(self.actionSqlWindow) self.toolBar.addAction(self.actionImport) self.toolBar.addAction(self.actionExport)
def __init__(self, iface, version): QDockWidget.__init__(self, None) self.iface = iface self.clouddb = True self.version = version # Set up the user interface from Designer. self.ui = Ui_QgisCloudPlugin() self.ui.setupUi(self) self.storage_exceeded = True myAbout = DlgAbout() self.ui.aboutText.setText( myAbout.aboutString() + myAbout.contribString() + myAbout.licenseString() + "<p>Versions:<ul>" + "<li>QGIS: %s</li>" % str(Qgis.QGIS_VERSION).encode("utf-8") + "<li>Python: %s</li>" % sys.version.replace("\n", " ") + "<li>OS: %s</li>" % platform.platform() + "</ul></p>") data_protection_link = """<a href="http://qgiscloud.com/pages/privacy">%s</a>""" % (self.tr("Privacy Policy")) self.ui.lblVersionPlugin.setText("%s %s" % (self.version, data_protection_link)) self.ui.lblVersionPlugin.setOpenExternalLinks(True) self.ui.tblLocalLayers.setColumnCount(6) header = ["Layers","Table Schema","Table name", "Geometry type", "SRID","Data Source"] self.ui.tblLocalLayers.setHorizontalHeaderLabels(header) self.ui.tblLocalLayers.resizeColumnsToContents() # self.ui.tblLocalLayers.setEditTriggers(QAbstractItemView.NoEditTriggers) self.ui.btnUploadData.setEnabled(False) self.ui.btnPublishMap.setEnabled(False) self.ui.btnMapDelete.setEnabled(False) self.ui.progressWidget.hide() self.ui.btnLogout.hide() self.ui.lblLoginStatus.hide() self.ui.widgetServices.hide() self.ui.widgetDatabases.setEnabled(False) self.ui.widgetMaps.setEnabled(False) self.ui.labelOpenLayersPlugin.hide() try: from .openlayers_menu import OpenlayersMenu self.ui.btnBackgroundLayer.setMenu(OpenlayersMenu(self.iface)) except: self.ui.btnBackgroundLayer.hide() self.ui.labelOpenLayersPlugin.show() # map<data source, table name> self.data_sources_table_names = {} # flag to disable update of local data sources during upload self.do_update_local_data_sources = True self.ui.btnLogin.clicked.connect(self.check_login) self.ui.btnDbCreate.clicked.connect(self.create_database) self.ui.btnDbDelete.clicked.connect(self.delete_database) self.ui.btnDbRefresh.clicked.connect(self.refresh_databases) self.ui.btnMapDelete.clicked.connect(self.delete_map) self.ui.btnMapLoad.clicked.connect(self.map_load) self.ui.tabMaps.itemDoubleClicked.connect(self.map_load) self.ui.tabDatabases.itemSelectionChanged.connect(self.select_database) self.ui.tabMaps.itemSelectionChanged.connect(self.select_map) self.ui.btnPublishMap.clicked.connect(self.publish_map) self.ui.btnRefreshLocalLayers.clicked.connect(self.refresh_local_data_sources) self.ui.cbUploadDatabase.currentTextChanged.connect(self.update_data_sources_table_names) self.iface.newProjectCreated.connect(self.reset_load_data) self.iface.projectRead.connect(self.reset_load_data) self.PROJECT_INSTANCE.layerWillBeRemoved.connect(self.remove_layer) self.PROJECT_INSTANCE.layerWasAdded.connect(self.add_layer) self.ui.cbUploadDatabase.currentIndexChanged.connect(lambda idx: self.activate_upload_button()) self.ui.btnUploadData.clicked.connect(self.upload_data) self.ui.editServer.textChanged.connect(self.serverURL) self.ui.resetUrlBtn.clicked.connect(self.resetApiUrl) self.read_settings() self.api = API() self.db_connections = DbConnections() self.local_data_sources = LocalDataSources() self.data_upload = DataUpload( self.iface, self.statusBar(), self.ui.lblProgress, self.api, self.db_connections) if self.URL == "": self.ui.editServer.setText(self.api.api_url()) else: self.ui.editServer.setText(self.URL) self.palette_red = QPalette(self.ui.lblVersionPlugin.palette()) self.palette_red.setColor(QPalette.WindowText, Qt.red)
def activate(self): self.activateWindow() self.raise_() QDockWidget.setFocus(self)
def __init__(self, parent): QDockWidget.__init__(self, parent) self.setWidget(Widget(self)) self.setWindowTitle("Azimuth and distance")
class DBManager(QMainWindow): def __init__(self, iface, parent=None): QMainWindow.__init__(self, parent) self.setAttribute(Qt.WA_DeleteOnClose) self.setupUi() self.iface = iface # restore the window state settings = QgsSettings() self.restoreGeometry(settings.value("/DB_Manager/mainWindow/geometry", QByteArray(), type=QByteArray)) self.restoreState(settings.value("/DB_Manager/mainWindow/windowState", QByteArray(), type=QByteArray)) self.tabs.currentChanged.connect(self.tabChanged) self.tree.selectedItemChanged.connect(self.itemChanged) self.itemChanged(None) def closeEvent(self, e): self.unregisterAllActions() # clear preview, this will delete the layer in preview tab self.preview.loadPreview(None) # save the window state settings = QgsSettings() settings.setValue("/DB_Manager/mainWindow/windowState", self.saveState()) settings.setValue("/DB_Manager/mainWindow/geometry", self.saveGeometry()) QMainWindow.closeEvent(self, e) def refreshItem(self, item=None): with OverrideCursor(Qt.WaitCursor): try: if item is None: item = self.tree.currentItem() self.tree.refreshItem(item) # refresh item children in the db tree except BaseError as e: DlgDbError.showError(e, self) def itemChanged(self, item): with OverrideCursor(Qt.WaitCursor): try: self.reloadButtons() # clear preview, this will delete the layer in preview tab self.preview.loadPreview(None) self.refreshTabs() except BaseError as e: DlgDbError.showError(e, self) def reloadButtons(self): db = self.tree.currentDatabase() if not hasattr(self, '_lastDb'): self._lastDb = db elif db == self._lastDb: return # remove old actions if self._lastDb is not None: self.unregisterAllActions() # add actions of the selected database self._lastDb = db if self._lastDb is not None: self._lastDb.registerAllActions(self) def tabChanged(self, index): with OverrideCursor(Qt.WaitCursor): try: self.refreshTabs() except BaseError as e: DlgDbError.showError(e, self) def refreshTabs(self): index = self.tabs.currentIndex() item = self.tree.currentItem() table = self.tree.currentTable() # enable/disable tabs self.tabs.setTabEnabled(self.tabs.indexOf(self.table), table is not None) self.tabs.setTabEnabled(self.tabs.indexOf(self.preview), table is not None and table.type in [table.VectorType, table.RasterType] and table.geomColumn is not None) # show the info tab if the current tab is disabled if not self.tabs.isTabEnabled(index): self.tabs.setCurrentWidget(self.info) current_tab = self.tabs.currentWidget() if current_tab == self.info: self.info.showInfo(item) elif current_tab == self.table: self.table.loadData(item) elif current_tab == self.preview: self.preview.loadPreview(item) def refreshActionSlot(self): self.info.setDirty() self.table.setDirty() self.preview.setDirty() self.refreshItem() def importActionSlot(self): db = self.tree.currentDatabase() if db is None: self.infoBar.pushMessage(self.tr("No database selected or you are not connected to it."), QgsMessageBar.INFO, self.iface.messageTimeout()) return outUri = db.uri() schema = self.tree.currentSchema() if schema: outUri.setDataSource(schema.name, "", "", "") from .dlg_import_vector import DlgImportVector dlg = DlgImportVector(None, db, outUri, self) dlg.exec_() def exportActionSlot(self): table = self.tree.currentTable() if table is None: self.infoBar.pushMessage(self.tr("Select the table you want export to file."), QgsMessageBar.INFO, self.iface.messageTimeout()) return inLayer = table.toMapLayer() if inLayer.type() != QgsMapLayer.VectorLayer: self.infoBar.pushMessage( self.tr("Select a vector or a tabular layer you want export."), QgsMessageBar.WARNING, self.iface.messageTimeout()) return from .dlg_export_vector import DlgExportVector dlg = DlgExportVector(inLayer, table.database(), self) dlg.exec_() inLayer.deleteLater() def runSqlWindow(self): db = self.tree.currentDatabase() if db is None: self.infoBar.pushMessage(self.tr("No database selected or you are not connected to it."), QgsMessageBar.INFO, self.iface.messageTimeout()) # force displaying of the message, it appears on the first tab (i.e. Info) self.tabs.setCurrentIndex(0) return from .dlg_sql_window import DlgSqlWindow query = DlgSqlWindow(self.iface, db, self) dbname = db.connection().connectionName() tabname = self.tr("Query ({0})").format(dbname) index = self.tabs.addTab(query, tabname) self.tabs.setTabIcon(index, db.connection().icon()) self.tabs.setCurrentIndex(index) query.nameChanged.connect(functools.partial(self.update_query_tab_name, index, dbname)) def runSqlLayerWindow(self, layer): from .dlg_sql_layer_window import DlgSqlLayerWindow query = DlgSqlLayerWindow(self.iface, layer, self) lname = layer.name() tabname = self.tr("Layer ({0})").format(lname) index = self.tabs.addTab(query, tabname) # self.tabs.setTabIcon(index, db.connection().icon()) self.tabs.setCurrentIndex(index) def update_query_tab_name(self, index, dbname, queryname): if not queryname: queryname = self.tr("Query") tabname = u"%s (%s)" % (queryname, dbname) self.tabs.setTabText(index, tabname) def showSystemTables(self): self.tree.showSystemTables(self.actionShowSystemTables.isChecked()) def registerAction(self, action, menuName, callback=None): """ register an action to the manager's main menu """ if not hasattr(self, '_registeredDbActions'): self._registeredDbActions = {} if callback is not None: def invoke_callback(x): return self.invokeCallback(callback) if menuName is None or menuName == "": self.addAction(action) if menuName not in self._registeredDbActions: self._registeredDbActions[menuName] = list() self._registeredDbActions[menuName].append(action) if callback is not None: action.triggered.connect(invoke_callback) return True # search for the menu actionMenu = None helpMenuAction = None for a in self.menuBar.actions(): if not a.menu() or a.menu().title() != menuName: continue if a.menu() != self.menuHelp: helpMenuAction = a actionMenu = a break # not found, add a new menu before the help menu if actionMenu is None: menu = QMenu(menuName, self) if helpMenuAction is not None: actionMenu = self.menuBar.insertMenu(helpMenuAction, menu) else: actionMenu = self.menuBar.addMenu(menu) menu = actionMenu.menu() menuActions = menu.actions() # get the placeholder's position to insert before it pos = 0 for pos in range(len(menuActions)): if menuActions[pos].isSeparator() and menuActions[pos].objectName().endswith("_placeholder"): menuActions[pos].setVisible(True) break if pos < len(menuActions): before = menuActions[pos] menu.insertAction(before, action) else: menu.addAction(action) actionMenu.setVisible(True) # show the menu if menuName not in self._registeredDbActions: self._registeredDbActions[menuName] = list() self._registeredDbActions[menuName].append(action) if callback is not None: action.triggered.connect(invoke_callback) return True def invokeCallback(self, callback, *params): """ Call a method passing the selected item in the database tree, the sender (usually a QAction), the plugin mainWindow and optionally additional parameters. This method takes care to override and restore the cursor, but also catches exceptions and displays the error dialog. """ with OverrideCursor(Qt.WaitCursor): try: callback(self.tree.currentItem(), self.sender(), self, *params) except BaseError as e: # catch database errors and display the error dialog DlgDbError.showError(e, self) def unregisterAction(self, action, menuName): if not hasattr(self, '_registeredDbActions'): return if menuName is None or menuName == "": self.removeAction(action) if menuName in self._registeredDbActions: if self._registeredDbActions[menuName].count(action) > 0: self._registeredDbActions[menuName].remove(action) action.deleteLater() return True for a in self.menuBar.actions(): if not a.menu() or a.menu().title() != menuName: continue menu = a.menu() menuActions = menu.actions() menu.removeAction(action) if menu.isEmpty(): # hide the menu a.setVisible(False) if menuName in self._registeredDbActions: if self._registeredDbActions[menuName].count(action) > 0: self._registeredDbActions[menuName].remove(action) # hide the placeholder if there're no other registered actions if len(self._registeredDbActions[menuName]) <= 0: for i in range(len(menuActions)): if menuActions[i].isSeparator() and menuActions[i].objectName().endswith("_placeholder"): menuActions[i].setVisible(False) break action.deleteLater() return True return False def unregisterAllActions(self): if not hasattr(self, '_registeredDbActions'): return for menuName in self._registeredDbActions: for action in list(self._registeredDbActions[menuName]): self.unregisterAction(action, menuName) del self._registeredDbActions def close_tab(self, index): widget = self.tabs.widget(index) if widget not in [self.info, self.table, self.preview]: self.tabs.removeTab(index) widget.deleteLater() def setupUi(self): self.setWindowTitle(self.tr("DB Manager")) self.setWindowIcon(QIcon(":/db_manager/icon")) self.resize(QSize(700, 500).expandedTo(self.minimumSizeHint())) # create central tab widget and add the first 3 tabs: info, table and preview self.tabs = QTabWidget() self.info = InfoViewer(self) self.tabs.addTab(self.info, self.tr("Info")) self.table = TableViewer(self) self.tabs.addTab(self.table, self.tr("Table")) self.preview = LayerPreview(self) self.tabs.addTab(self.preview, self.tr("Preview")) self.setCentralWidget(self.tabs) # display close button for all tabs but the first 3 ones, i.e. # HACK: just hide the close button where not needed (GS) self.tabs.setTabsClosable(True) self.tabs.tabCloseRequested.connect(self.close_tab) tabbar = self.tabs.tabBar() for i in range(3): btn = tabbar.tabButton(i, QTabBar.RightSide) if tabbar.tabButton(i, QTabBar.RightSide) else tabbar.tabButton(i, QTabBar.LeftSide) btn.resize(0, 0) btn.hide() # Creates layout for message bar self.layout = QGridLayout(self.info) self.layout.setContentsMargins(0, 0, 0, 0) spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.layout.addItem(spacerItem, 1, 0, 1, 1) # init messageBar instance self.infoBar = QgsMessageBar(self.info) sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.infoBar.setSizePolicy(sizePolicy) self.layout.addWidget(self.infoBar, 0, 0, 1, 1) # create database tree self.dock = QDockWidget("Tree", self) self.dock.setObjectName("DB_Manager_DBView") self.dock.setFeatures(QDockWidget.DockWidgetMovable) self.tree = DBTree(self) self.dock.setWidget(self.tree) self.addDockWidget(Qt.LeftDockWidgetArea, self.dock) # create status bar self.statusBar = QStatusBar(self) self.setStatusBar(self.statusBar) # create menus self.menuBar = QMenuBar(self) self.menuDb = QMenu(self.tr("&Database"), self) self.menuBar.addMenu(self.menuDb) self.menuSchema = QMenu(self.tr("&Schema"), self) actionMenuSchema = self.menuBar.addMenu(self.menuSchema) self.menuTable = QMenu(self.tr("&Table"), self) actionMenuTable = self.menuBar.addMenu(self.menuTable) self.menuHelp = None # QMenu(self.tr("&Help"), self) # actionMenuHelp = self.menuBar.addMenu(self.menuHelp) self.setMenuBar(self.menuBar) # create toolbar self.toolBar = QToolBar("Default", self) self.toolBar.setObjectName("DB_Manager_ToolBar") self.addToolBar(self.toolBar) # create menus' actions # menu DATABASE sep = self.menuDb.addSeparator() sep.setObjectName("DB_Manager_DbMenu_placeholder") sep.setVisible(False) self.actionRefresh = self.menuDb.addAction(QIcon(":/db_manager/actions/refresh"), self.tr("&Refresh"), self.refreshActionSlot, QKeySequence("F5")) self.actionSqlWindow = self.menuDb.addAction(QIcon(":/db_manager/actions/sql_window"), self.tr("&SQL window"), self.runSqlWindow, QKeySequence("F2")) self.menuDb.addSeparator() self.actionClose = self.menuDb.addAction(QIcon(), self.tr("&Exit"), self.close, QKeySequence("CTRL+Q")) # menu SCHEMA sep = self.menuSchema.addSeparator() sep.setObjectName("DB_Manager_SchemaMenu_placeholder") sep.setVisible(False) actionMenuSchema.setVisible(False) # menu TABLE sep = self.menuTable.addSeparator() sep.setObjectName("DB_Manager_TableMenu_placeholder") sep.setVisible(False) self.actionImport = self.menuTable.addAction(QIcon(":/db_manager/actions/import"), self.tr("&Import layer/file"), self.importActionSlot) self.actionExport = self.menuTable.addAction(QIcon(":/db_manager/actions/export"), self.tr("&Export to file"), self.exportActionSlot) self.menuTable.addSeparator() #self.actionShowSystemTables = self.menuTable.addAction(self.tr("Show system tables/views"), self.showSystemTables) #self.actionShowSystemTables.setCheckable(True) #self.actionShowSystemTables.setChecked(True) actionMenuTable.setVisible(False) # add actions to the toolbar self.toolBar.addAction(self.actionRefresh) self.toolBar.addAction(self.actionSqlWindow) self.toolBar.addAction(self.actionImport) self.toolBar.addAction(self.actionExport)
class MainWindow(QMainWindow): def __init__(self, iface): QMainWindow.__init__(self) self.resize(600, 600) self.layer = None self.iface = iface self.dstpoints = [] self.srcpoints = [] self.filename = None self.cursrc = None self.curdst = None self.xform_m2r = None self.xform_r2m = None self.canvas = QgsMapCanvas(self) #self.canvas.setCachingEnabled(True) self.canvas.setCanvasColor(Qt.white) self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor) self.setCentralWidget(self.canvas) def t(name): return QgsApplication.getThemeIcon('/' + name) actionZoomIn = QAction(t('mActionZoomIn.svg'), "Zoom in", self) actionZoomOut = QAction(t('mActionZoomOut.svg'), "Zoom out", self) actionZoomToLayer = QAction(t('mActionZoomToLayer.svg'), "Zoom To Layer", self) actionZoomToDest = QAction("Zoom To Map", self) actionPan = QAction(t('mActionPan.svg'), "Pan", self) actionOpen = QAction(t('mActionFileOpen.svg'), "Open", self) actionSave = QAction(t('mActionFileSaveAs.svg'), "Save", self) actionAdd = QAction("Add GCP", self) actionDeleteAll = QAction("Delete All GCPs", self) actionZoomIn.setCheckable(True) actionZoomOut.setCheckable(True) actionPan.setCheckable(True) actionAdd.setCheckable(True) actionZoomIn.triggered.connect(self.zoomIn) actionZoomOut.triggered.connect(self.zoomOut) actionZoomToLayer.triggered.connect(self.zoomToLayer) actionZoomToDest.triggered.connect(self.zoomToDest) actionPan.triggered.connect(self.pan) actionOpen.triggered.connect(self.showOpen) actionSave.triggered.connect(self.savePoints) actionAdd.triggered.connect(self.addGcp) actionDeleteAll.triggered.connect(self.deleteAll) self.toolbar = self.addToolBar("Canvas actions") self.toolbar.addAction(actionOpen) self.toolbar.addAction(actionSave) self.toolbar.addSeparator() self.toolbar.addAction(actionPan) self.toolbar.addAction(actionZoomIn) self.toolbar.addAction(actionZoomOut) self.toolbar.addAction(actionZoomToLayer) self.toolbar.addAction(actionZoomToDest) self.toolbar.addSeparator() self.toolbar.addAction(actionAdd) self.toolbar.addSeparator() self.toolbar.addAction(actionDeleteAll) self.toolPan = QgsMapToolPan(self.canvas) self.toolPan.setAction(actionPan) self.toolZoomIn = QgsMapToolZoom(self.canvas, False) self.toolZoomIn.setAction(actionZoomIn) self.toolZoomOut = QgsMapToolZoom(self.canvas, True) self.toolZoomOut.setAction(actionZoomOut) self.toolSrcAdd = CaptureTool(self.canvas, self.iface.cadDockWidget()) self.toolSrcAdd.pointSelected.connect(self.addSrcPoint) self.toolSrcAdd.pointDeleted.connect(self.delSrcPoint) self.toolDestAdd = CaptureTool(self.iface.mapCanvas(), self.iface.cadDockWidget()) self.toolDestAdd.pointSelected.connect(self.addDestPoint) self.toolDestAdd.pointDeleted.connect(self.delDestPoint) #self.toolDestAdd.setAction(actionAdd) self.pan() self.overview = QgsMapOverviewCanvas(None, self.canvas) self.overview_dock = QDockWidget("Overview") self.overview_dock.setWidget(self.overview) self.addDockWidget(Qt.BottomDockWidgetArea, self.overview_dock) self.canvas.enableOverviewMode(self.overview) statusbar = self.statusBar() self.coordslabel = QLabel(statusbar) self.canvas.xyCoordinates.connect(self.showMouseCoordinates) statusbar.addPermanentWidget(self.coordslabel) def __del__(self): for x in self.dstpoints: self.iface.mapCanvas().scene().removeItem(x) def zoomIn(self): self.canvas.setMapTool(self.toolZoomIn) def zoomOut(self): self.canvas.setMapTool(self.toolZoomOut) def addGcp(self): self.canvas.setMapTool(self.toolSrcAdd) self.iface.mapCanvas().setMapTool(self.toolDestAdd) def addDestPoint(self, pt): if self.curdst: self.curdst.setPoint(pt) else: self.curdst = CanvasItem(self.iface.mapCanvas(), pt) self.curdst.setCompleted(False) self.registerPoint() def addSrcPoint(self, pt): if self.cursrc: self.cursrc.setPoint(pt) else: self.cursrc = CanvasItem(self.canvas, pt) self.cursrc.setCompleted(False) self.registerPoint() def delDestPoint(self, pt): idx = self.dstpoints.index(pt) self.iface.mapCanvas().scene().removeItem(self.dstpoints[idx]) del self.dstpoints[idx] self.canvas.scene().removeItem(self.srcpoints[idx]) del self.srcpoints[idx] def delSrcPoint(self, pt): idx = self.srcpoints.index(pt) self.iface.mapCanvas().scene().removeItem(self.dstpoints[idx]) del self.dstpoints[idx] self.canvas.scene().removeItem(self.srcpoints[idx]) del self.srcpoints[idx] def registerPoint(self): if not self.cursrc or not self.curdst: return self.cursrc.setCompleted(True) self.cursrc.setDirty(True) self.curdst.setCompleted(True) self.curdst.setDirty(True) self.srcpoints.append(self.cursrc) self.dstpoints.append(self.curdst) self.cursrc = None self.curdst = None def deleteAll(self): for x in self.dstpoints: self.iface.mapCanvas().scene().removeItem(x) for x in self.srcpoints: self.canvas.scene().removeItem(x) self.dstpoints = [] self.srcpoints = [] def zoomToLayer(self): if self.layer: self.canvas.setExtent(self.layer.extent()) self.canvas.refresh() def zoomToDest(self): pts = [x.pt for x in self.dstpoints] if len(pts) < 2: return r = QgsRectangle(pts[0], pts[1]) for pt in pts[2:]: r.include(pt) self.iface.mapCanvas().setExtent(r) self.iface.mapCanvas().refresh() def pan(self): self.canvas.setMapTool(self.toolPan) def showOpen(self): startdir = '.' filters = QgsProviderRegistry.instance().fileRasterFilters() lastFilter = "Multi-resolution Seamless Image Database (*.sid *.SID)" dlg = QFileDialog(self) dlg.setWindowTitle("Open raster") dlg.setFileMode(QFileDialog.ExistingFile) dlg.setNameFilter(filters) dlg.selectNameFilter(lastFilter) dlg.fileSelected.connect(self.openFile) dlg.show() def openFile(self, filename): if not filename: return if self.layer: QgsMapLayerRegistry.instance().removeMapLayers([self.layer.id()]) self.deleteAll() self.setWindowTitle(os.path.basename(filename)) self.filename = filename with CrsDialogSuspender(): self.layer = QgsRasterLayer(filename, "Raster") QgsMapLayerRegistry.instance().addMapLayers([self.layer], False) self.canvas.setLayerSet([QgsMapCanvasLayer(self.layer, True, True)]) self.canvas.setExtent(self.layer.extent()) # figure out source file transform ds = gdal.Open(filename) xform = ds.GetGeoTransform(True) if not xform: # qgis inverts y when the transform does not exist xform = [0.0, 1.0, 0.0, 0.0, 0.0, -1.0] self.xform_r2m = xform invxform = gdal.InvGeoTransform(xform) if len(invxform) == 2: invxform = invxform[1] self.xform_m2r = invxform # load points gcp_filename = filename + ".gcps" if os.path.exists(gcp_filename): self.loadPoints(gcp_filename) self.zoomToLayer() def map2raster(self, x, y): return gdal.ApplyGeoTransform(self.xform_m2r, x, y) def raster2map(self, x, y): return gdal.ApplyGeoTransform(self.xform_r2m, x, y) def loadPoints(self, filename): self.srcpoints = [] self.dstpoints = [] for line in open(filename, 'rt').readlines(): line.strip() if line.startswith('map'): continue parts = line.split(',') if len(parts) < 4: continue dstpt = QgsPoint(float(parts[0]), float(parts[1])) oldsrcx, oldsrcy = float(parts[2]), float(parts[3]) newsrcx, newsrcy = self.raster2map(oldsrcx, oldsrcy) srcpt = QgsPoint(newsrcx, newsrcy) self.srcpoints.append(CanvasItem(self.canvas, srcpt)) self.dstpoints.append(CanvasItem(self.iface.mapCanvas(), dstpt)) def savePoints(self): if not self.filename: return filename = self.filename + ".gcps" out = open(filename, "wt") out.write("mapX,mapY,pixelX,pixelY\n") for i in range(len(self.srcpoints)): self.dstpoints[i].setDirty(False) self.srcpoints[i].setDirty(False) dstpt = self.dstpoints[i].pt srcpt = self.srcpoints[i].pt newsrcx, newsrcy = self.map2raster(srcpt.x(), srcpt.y()) outpts = [dstpt.x(), dstpt.y(), newsrcx, newsrcy] out.write("%s,%s,%s,%s\n" % tuple([qgsDoubleToString(x) for x in outpts])) def showMouseCoordinates(self, coords): self.coordslabel.setText("Coords: %f, %f" % (coords.x(), coords.y()))