def do_init_baselayer_menu(self): """Initialize baselayer menu: Adds the menu and reads all baselayers from the yaml file and adds them into the menu. Language support is working! """ menubar = QMenuBar(self.toolbar) menubar.setObjectName("VeriSOModule.LoadBaselayerMenuBar") menubar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) menu = QMenu(menubar) menu.setTitle(_translate(self.module, "Baselayer", None)) locale = QSettings().value('locale/userLocale')[0:2] baselayers = get_baselayers(self.module) if not baselayers: message = "Could not load baselayer definitions file." self.message_bar.pushMessage("Error", _translate(self.module, message, None), level=Qgis.Critical, duration=0) return for baselayer in baselayers["baselayer"]: baselayer_title = baselayer["title"] try: keys = list(baselayer_title.keys()) try: baselayer_title = str(baselayer_title[locale]) # language found except: # language *not* found baselayer_title = str(list(baselayer_title.values())[0]) except: baselayer_title = str(baselayer_title) baselayer["title"] = baselayer_title action = QAction(baselayer_title, self.iface.mainWindow()) menu.addAction(action) action.triggered.connect( lambda checked, layer=baselayer: self.do_show_baselayer(layer)) menubar.addMenu(menu) self.toolbar.insertWidget(self.beforeAction, menubar) if (sys.platform == 'darwin'): menubar.setNativeMenuBar(False)
def run(self): """Run method that loads and starts the plugin""" if not self.pluginIsActive: self.pluginIsActive = True # print "** STARTING WBNMViewer" # dockwidget may not exist if: # first run of plugin # removed on close (see self.onClosePlugin method) if self.dockwidget == None: # Create the dockwidget (after translation) and keep reference self.dockwidget = WBNMViewerDockWidget() self.dockwidget.plotButton.clicked.connect( self.plot_hydrograph) self.dockwidget.filterEdit.textChanged.connect( self.filter_storms) self.dockwidget.boxButton.clicked.connect( self.plot_box_whisker) self.dockwidget.ensembleButton.clicked.connect( self.plot_ensembles) # set up menubar self.window = QWidget() self.vbox = QVBoxLayout() self.window.setLayout(self.vbox) self.menuBar = QMenuBar() self.vbox.addWidget(self.menuBar) self.dockwidget.dockWidgetContents.layout().setSpacing(0) self.dockwidget.dockWidgetContents.layout().setMargin(0) self.dockwidget.dockWidgetContents.layout().setContentsMargins( 0, 0, 0, 0) self.dockwidget.dockWidgetContents.layout().insertWidget( 0, self.window) fileMenu = self.menuBar.addMenu("&File") self.loadWBNMMetaFile = QAction("Load WBNM *_Meta.out file", self.window) fileMenu.addAction(self.loadWBNMMetaFile) self.loadWBNMMetaFile.triggered.connect(self.process_meta_file) # set up data tab # connect to provide cleanup on closing of dockwidget self.dockwidget.closingPlugin.connect(self.onClosePlugin) # show the dockwidget # TODO: fix to allow choice of dock location self.iface.addDockWidget(Qt.BottomDockWidgetArea, self.dockwidget) self.dockwidget.show()
def doShowProjectId(self): menuBar = QMenuBar(self.toolbar) menuBar.setObjectName("VeriSOModule.ShowProjectIdMenuBar") menuBar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) menu = QMenu(menuBar) self.project_id = self.settings.value("project/id") menu.setTitle( QCoreApplication.translate(self.module, "Aktives Projekt: " + self.project_id)) menuBar.addMenu(menu) menuBar.setEnabled(False) self.toolbar.addWidget(menuBar)
def do_init_defects_menu(self): """Inititializes the defects menu: - load defects - export defects Export defects uses some external python excel library. """ menubar = QMenuBar(self.toolbar) menubar.setObjectName("VeriSOModule.LoadDefectsMenuBar") menubar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) menu = QMenu(menubar) menu.setTitle(_translate(self.module, "Bemerkungen", None)) action = QAction(_translate(self.module, "Bemerkungen laden", None), self.iface.mainWindow()) action.triggered.connect(self.do_load_defects) menu.addAction(action) action = QAction( _translate(self.module, "Bemerkungen exportieren", None), self.iface.mainWindow()) action.triggered.connect(self.do_export_defects) menu.addAction(action) menubar.addMenu(menu) self.toolbar.insertWidget(self.beforeAction, menubar)
def do_init_topics_tables_menu(self): """Creates the topics and tables loader menu. Topics and tables are sorted alphanumerically. I'm not sure if ili2pg saves enough information in the database to find out the interlis model order. At the moment there is no locale support here. Seems to be not very handy without mapping tables anyway... """ menubar = QMenuBar(self.toolbar) menubar.setObjectName("VeriSOModule.LoadTopicsTablesMenuBar") menubar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) menu = QMenu(menubar) menu.setTitle(_translate(self.module, "Tables", None)) topics = get_topics_tables(self.module_name) if not topics: message = "Something went wrong catching the topics/tables list " \ "from the database." self.message_bar.pushMessage(self.module_name, _translate(self.module, message, None), Qgis.Critical, duration=0) return for topic in topics: topic_menu = menu.addMenu(str(topic["topic"])) action = QAction(_translate(self.module, "Load Topic", None), self.iface.mainWindow()) topic_menu.addAction(action) topic_menu.addSeparator() action.triggered.connect( lambda checked, topic=topic: self.do_show_topic(topic)) layers = get_layers_from_topic(topic) for my_layer in layers: action = QAction(my_layer["title"], self.iface.mainWindow()) topic_menu.addAction(action) action.triggered.connect(lambda checked, layer=my_layer: self. do_show_single_topic_layer(layer)) menubar.addMenu(menu) self.toolbar.insertWidget(self.beforeAction, menubar) if (sys.platform == 'darwin'): menubar.setNativeMenuBar(False)
def get_checks_menubar(self, check_topics): menubar = QMenuBar(self.toolbar) menubar.setObjectName("VeriSOModule.LoadChecksMenuBar") menubar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) menu = QMenu(menubar) menu.setTitle(_translate(self.module, "Checks", None)) locale = QSettings().value('locale/userLocale')[0:2] for check_topic in check_topics: checks = check_topics[check_topic]["checks"] if not checks: message = "The topic %s has no valid checks: skiping." % ( check_topic) self.message_bar.pushWarning( "Warning", _translate(self.module, message, None)) # this topic has no valid checks continue single_check_menu = menu.addMenu(str(check_topic)) for check in checks: check_name = check["name"] # Same multilingual strategy as in get_check_topics(). try: keys = list(check_name.keys()) try: check_name = str(check_name[locale]) # language found except: # language *not* found check_name = str(list(check_name.values())[0]) except: check_name = str(check_name) if check_name == "separator": single_check_menu.addSeparator() else: action = QAction(check_name, self.iface.mainWindow()) try: shortcut = check["shortcut"] action.setShortcut(shortcut) except: pass single_check_menu.addAction(action) topic_dir = check_topics[check_topic]['topic_dir'] action.triggered.connect( lambda checked, complex_check=check, folder=topic_dir: self.do_show_complex_check(folder, complex_check)) menubar.addMenu(menu) return menubar
def initTopMenu(self): #adding #topMenu=self.titleBarWidget() #topMenu=self.layout().menuBar() topMenu = QMenuBar() #self.layout().setMenuBar(self.topMenu) #topMenu=QMenuBar(self)#works but need to click '>>' button addMenu = topMenu.addMenu("add") loadSecAct = addMenu.addAction('load .sec...') loadSecAct.triggered.connect(self.loadSec) loadRteAct = addMenu.addAction('load .rte...') loadRteAct.triggered.connect(self.loadRTE) loadSrAct = addMenu.addAction('load .sr...') loadSrAct.triggered.connect(self.loadSr) #save saveMenu = topMenu.addMenu("save") saveSrAct = saveMenu.addAction('save as .sr...') saveSrAct.triggered.connect(self.saveAsSr) saveSecAct = saveMenu.addAction('save as .sec...') saveSecAct.triggered.connect(self.saveAsSec) saveSecAct = saveMenu.addAction('save as .rte...') saveSecAct.triggered.connect(self.saveAsRte) setingsMenu = topMenu.addMenu("settings") setDatabaseAct = setingsMenu.addAction('set database...') setDatabaseAct.triggered.connect(self.dd.show) #self.toolBar=QToolBar(self) #toolbar=self.addToolBar() #topMenu = QMenuBar(self) #topMenu.setDefaultUp(False) #addMenu=topMenu.addMenu("add") #saveMenu=topMenu.addMenu("save") #self.layout().addWidget(topMenu) self.main_widget.layout().setMenuBar(topMenu)
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.tree.model().dataChanged.connect(self.iface.reloadConnections) 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."), Qgis.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."), Qgis.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."), Qgis.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."), Qgis.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)
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 qgis_app(request): """ Creates a QGIS application, a QGIS Interface, a QGIS Settings and a set of loaded plugins. The fixture can be parametrized with the following options: - plugin_names: Plugin names to load - plugin_paths: Directories where the plugins are located - locale: Language code with the translation that the plugin has to be loaded :param request: Fixture request. It contains the indirect parameters for fixture setup :type request: FixtureRequest :return: The QGIS application objects :rtype: (QgsApplication, QgisInterface, QgsSettings, (list of object) or None) """ # Collect parameters plugin_names = request.param[ 'plugin_names'] if 'plugin_names' in request.param else None plugin_paths = request.param['plugin_paths'] if 'plugin_paths' in request.param \ else [str(Path(__file__).parent.parent.parent) + '/src'] locale = request.param['locale'] if 'locale' in request.param else 'EN' # Create a QGIS Application # noinspection PyTypeChecker QgsApplication.setPrefixPath('/usr', True) qgs = QgsApplication([], True) qgs.initQgis() # Mock the QGIS Interface iface = unittest.mock.Mock(spec=QgisInterface) main_window = QMainWindow() iface.mainWindow.return_value = main_window canvas = QgsMapCanvas(main_window) canvas.resize(QSize(400, 400)) iface.mapCanvas.return_value = canvas # Create the settings global_settings = QSettings() global_settings.setValue('locale/userLocale', locale) qgs_settings = QgsSettings() qgs_settings_file = qgs_settings.fileName() menu = QMenuBar() main_window.setMenuBar(menu) qgis.utils.iface = iface for plugin_path in plugin_paths: sys.path.insert(0, plugin_path) qgis.utils.plugin_paths.append(plugin_path) qgis.utils.updateAvailablePlugins() if plugin_names is not None: plugins = list() if isinstance(plugin_names, str): plugin_names = [plugin_names] for plugin_name in plugin_names: assert qgis.utils.loadPlugin(plugin_name) assert qgis.utils.startPlugin(plugin_name) plugins.append(qgis.utils.plugins[plugin_name]) yield qgs, iface, qgs_settings, plugins for plugin_name in plugin_names: qgis.utils.unloadPlugin(plugin_name) del qgis.utils.plugin_times[plugin_name] if plugin_paths is not None: for plugin_path in plugin_paths: sys.path.remove(plugin_path) qgis.utils.plugin_paths.remove(plugin_path) qgis.utils.updateAvailablePlugins() else: yield qgs, iface, qgs_settings, None os.remove(qgs_settings_file) del qgs
def initGui(self): icon_path = ':/plugins/veriso/icon.png' # Qt offers some themes which you also can change in QGIS settings. # Since the background color of the menu toolbar can be different than # the background color of the button toolbars, the veriso toolbar # doesn't suit well. So we change it manually by finding out the # background color of one (e.g. file) toolbar and applying it # to the veriso toolbar. # This approach works (well?) for xfce 4.12 and standard (gtk+) theme. # We need to do this also in other methods when we add new menus :-( # 20150406: Only change QToolBar background color. # Otherweise the later added menus will have white hover color and # other quirks. # Strange: QToolBar stylesheet seems to need an border. background_color = self.iface.mainWindow().menuBar().palette().color( QPalette.Window).name() # main toolbar self.toolbar = self.iface.addToolBar("VeriSO") self.toolbar.setStyleSheet("QToolBar {background-color: " + background_color + "; border: 0px solid " + background_color + ";}") self.toolbar.setObjectName("VeriSO.Main.ToolBar") self.toolbar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) # projects self.menubar_projects = QMenuBar() self.menubar_projects.setObjectName("VeriSO.Main.ProjectsMenuBar") self.menubar_projects.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)) self.menu_projects = QMenu() self.menu_projects.setTitle(tr("Projects")) self.menubar_projects.addMenu(self.menu_projects) # files self.menubar_file = QMenuBar() self.menubar_file.setObjectName("VeriSO.Main.FileMenuBar") self.menubar_file.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_file = QMenu() self.menu_file.setTitle(tr("File")) self.import_project = QAction(tr("Import project"), self.iface.mainWindow()) self.import_project.triggered.connect(self.do_import_project) self.delete_project = QAction(tr("Delete project"), self.iface.mainWindow()) self.delete_project.triggered.connect(self.do_delete_project) self.menu_file.addActions([self.import_project, self.delete_project]) self.menubar_file.addMenu(self.menu_file) # settings self.menubar_settings = QMenuBar() self.menubar_settings.setObjectName("VeriSO.Main.SettingsMenuBar") self.menubar_settings.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_settings = QMenu() self.menu_settings.setTitle(tr("Settings")) self.options = QAction(tr("Options"), self.iface.mainWindow()) self.options.triggered.connect(self.do_options) self.menu_settings.addActions([self.options]) self.menubar_settings.addMenu(self.menu_settings) # Add menus to toolbar. self.toolbar.addWidget(self.menubar_projects) self.toolbar.addWidget(self.menubar_file) self.toolbar.addWidget(self.menubar_settings) # Initial load of project menu entries. self.do_load_projects_database()
def initGui(self): # Prepare defects list dock self._create_defects_list_dock() # Prepare check results dock self._create_check_results_dock() # Qt offers some themes which you also can change in QGIS settings. # Since the background color of the menu toolbar can be different than # the background color of the button toolbars, the veriso toolbar # doesn't suit well. So we change it manually by finding out the # background color of one (e.g. file) toolbar and applying it # to the veriso toolbar. # This approach works (well?) for xfce 4.12 and standard (gtk+) theme. # We need to do this also in other methods when we add new menus :-( # 20150406: Only change QToolBar background color. # Otherweise the later added menus will have white hover color and # other quirks. # Strange: QToolBar stylesheet seems to need an border. background_color = self.iface.mainWindow().menuBar().palette().color( QPalette.Window).name() # main toolbar self.toolbar = self.iface.addToolBar("VeriSO") self.toolbar.setStyleSheet( "QToolBar {background-color: " + background_color + "; border: 0px solid " + background_color + ";}") self.toolbar.setObjectName("VeriSO.Main.ToolBar") self.toolbar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) # trick for OSX compatibility if(sys.platform == 'darwin'): foobar = QMenuBar() # projects self.menubar_projects = QMenuBar() self.menubar_projects.setObjectName("VeriSO.Main.ProjectsMenuBar") self.menubar_projects.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)) self.menu_projects = QMenu() self.menu_projects.setTitle(tr("Projects")) self.menubar_projects.addMenu(self.menu_projects) # files self.menubar_file = QMenuBar() self.menubar_file.setObjectName("VeriSO.Main.FileMenuBar") self.menubar_file.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_file = QMenu() self.menu_file.setTitle(tr("File")) self.import_project = QAction(tr("Import project"), self.iface.mainWindow()) self.import_project.triggered.connect(self.do_import_project) self.export_project = QAction(tr("Export project"), self.iface.mainWindow()) self.export_project.triggered.connect(self.do_export_project) self.delete_project = QAction(tr("Delete project"), self.iface.mainWindow()) self.delete_project.triggered.connect(self.do_delete_project) self.menu_file.addActions([self.import_project, self.export_project, self.delete_project]) self.menubar_file.addMenu(self.menu_file) # defects self.menubar_defects = QMenuBar(self.toolbar) self.menubar_defects.setObjectName("VeriSO.Main.LoadDefectsMenuBar") self.menubar_defects.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_defects = QMenu(self.menubar_defects) self.menu_defects.setObjectName("VeriSO.Main.LoadDefectsMenu") self.menu_defects.setTitle(tr("Defects")) self.defects_list_action = QAction(tr("Show defects list dock"), self.iface.mainWindow()) self.defects_list_action.setCheckable(True) self.defects_list_action.setChecked(True) self.defects_list_action.triggered.connect( self.toggle_defects_list_dock_visibility) self.menu_defects.addAction(self.defects_list_action) self.menubar_defects.addMenu(self.menu_defects) # settings self.menubar_settings = QMenuBar() self.menubar_settings.setObjectName("VeriSO.Main.SettingsMenuBar") self.menubar_settings.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_settings = QMenu() self.menu_settings.setTitle(tr("Settings")) self.options = QAction(tr("Options"), self.iface.mainWindow()) self.options.triggered.connect(self.do_options) self.menu_settings.addActions([self.options]) self.menubar_settings.addMenu(self.menu_settings) # Add menus to toolbar. if(sys.platform == 'darwin'): self.toolbar.addWidget(foobar) self.toolbar.addWidget(self.menubar_projects) self.toolbar.addWidget(self.menubar_file) self.toolbar.addWidget(self.menubar_defects) self.toolbar.addWidget(self.menubar_settings) # for OSX compatibility. Without setNativeMenuBar(False) the veriso # menu will not appear if(sys.platform == 'darwin'): self.menubar_projects.setNativeMenuBar(False) self.menubar_file.setNativeMenuBar(False) self.menubar_defects.setNativeMenuBar(False) self.menubar_settings.setNativeMenuBar(False) # Initial load of project menu entries. self.do_load_projects_database() if(sys.platform == 'darwin'): self.iface.mainWindow().menuBar().setNativeMenuBar(False) self.iface.mainWindow().menuBar().setNativeMenuBar(True)
class VeriSO(object): def __init__(self, iface): self.iface = iface self.message_bar = self.iface.messageBar() self.plugin_dir = os.path.dirname(__file__) self.settings = QSettings("CatAIS", "VeriSO") locale = QSettings().value('locale/userLocale')[0:2] self.locale_path = os.path.join( self.plugin_dir, 'i18n', 'veriso_{}.qm'.format(locale)) if os.path.exists(self.locale_path): self.translator = QTranslator() self.translator.load(self.locale_path) QCoreApplication.installTranslator(self.translator) # members self.toolbar = None self.menubar_projects = None self.menubar_file = None self.menu_file = None self.import_project = None self.export_project = None self.delete_project = None self.menubar_settings = None self.menu_projects = None self.menu_settings = None self.menubar_defects = None self.menu_defects = None self.defects_list_action = None self.options = None self.import_dlg = None self.export_dlg = None self.delete_dlg = None self.options_dlg = None self.max_scale = None # noinspection PyPep8Naming def initGui(self): # Prepare defects list dock self._create_defects_list_dock() # Prepare check results dock self._create_check_results_dock() # Qt offers some themes which you also can change in QGIS settings. # Since the background color of the menu toolbar can be different than # the background color of the button toolbars, the veriso toolbar # doesn't suit well. So we change it manually by finding out the # background color of one (e.g. file) toolbar and applying it # to the veriso toolbar. # This approach works (well?) for xfce 4.12 and standard (gtk+) theme. # We need to do this also in other methods when we add new menus :-( # 20150406: Only change QToolBar background color. # Otherweise the later added menus will have white hover color and # other quirks. # Strange: QToolBar stylesheet seems to need an border. background_color = self.iface.mainWindow().menuBar().palette().color( QPalette.Window).name() # main toolbar self.toolbar = self.iface.addToolBar("VeriSO") self.toolbar.setStyleSheet( "QToolBar {background-color: " + background_color + "; border: 0px solid " + background_color + ";}") self.toolbar.setObjectName("VeriSO.Main.ToolBar") self.toolbar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) # trick for OSX compatibility if(sys.platform == 'darwin'): foobar = QMenuBar() # projects self.menubar_projects = QMenuBar() self.menubar_projects.setObjectName("VeriSO.Main.ProjectsMenuBar") self.menubar_projects.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)) self.menu_projects = QMenu() self.menu_projects.setTitle(tr("Projects")) self.menubar_projects.addMenu(self.menu_projects) # files self.menubar_file = QMenuBar() self.menubar_file.setObjectName("VeriSO.Main.FileMenuBar") self.menubar_file.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_file = QMenu() self.menu_file.setTitle(tr("File")) self.import_project = QAction(tr("Import project"), self.iface.mainWindow()) self.import_project.triggered.connect(self.do_import_project) self.export_project = QAction(tr("Export project"), self.iface.mainWindow()) self.export_project.triggered.connect(self.do_export_project) self.delete_project = QAction(tr("Delete project"), self.iface.mainWindow()) self.delete_project.triggered.connect(self.do_delete_project) self.menu_file.addActions([self.import_project, self.export_project, self.delete_project]) self.menubar_file.addMenu(self.menu_file) # defects self.menubar_defects = QMenuBar(self.toolbar) self.menubar_defects.setObjectName("VeriSO.Main.LoadDefectsMenuBar") self.menubar_defects.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_defects = QMenu(self.menubar_defects) self.menu_defects.setObjectName("VeriSO.Main.LoadDefectsMenu") self.menu_defects.setTitle(tr("Defects")) self.defects_list_action = QAction(tr("Show defects list dock"), self.iface.mainWindow()) self.defects_list_action.setCheckable(True) self.defects_list_action.setChecked(True) self.defects_list_action.triggered.connect( self.toggle_defects_list_dock_visibility) self.menu_defects.addAction(self.defects_list_action) self.menubar_defects.addMenu(self.menu_defects) # settings self.menubar_settings = QMenuBar() self.menubar_settings.setObjectName("VeriSO.Main.SettingsMenuBar") self.menubar_settings.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_settings = QMenu() self.menu_settings.setTitle(tr("Settings")) self.options = QAction(tr("Options"), self.iface.mainWindow()) self.options.triggered.connect(self.do_options) self.menu_settings.addActions([self.options]) self.menubar_settings.addMenu(self.menu_settings) # Add menus to toolbar. if(sys.platform == 'darwin'): self.toolbar.addWidget(foobar) self.toolbar.addWidget(self.menubar_projects) self.toolbar.addWidget(self.menubar_file) self.toolbar.addWidget(self.menubar_defects) self.toolbar.addWidget(self.menubar_settings) # for OSX compatibility. Without setNativeMenuBar(False) the veriso # menu will not appear if(sys.platform == 'darwin'): self.menubar_projects.setNativeMenuBar(False) self.menubar_file.setNativeMenuBar(False) self.menubar_defects.setNativeMenuBar(False) self.menubar_settings.setNativeMenuBar(False) # Initial load of project menu entries. self.do_load_projects_database() if(sys.platform == 'darwin'): self.iface.mainWindow().menuBar().setNativeMenuBar(False) self.iface.mainWindow().menuBar().setNativeMenuBar(True) def do_import_project(self): from .base.file.importproject import ImportProjectDialog self.import_dlg = ImportProjectDialog(self.iface) if self.import_dlg.init_gui(): self.import_dlg.show() self.import_dlg.projectsDatabaseHasChanged.connect( self.do_load_projects_database) def do_export_project(self): from .base.file.exportproject import ExportProjectDialog self.export_dlg = ExportProjectDialog(self.iface) if self.export_dlg.init_gui(): self.export_dlg.show() self.export_dlg.projectsDatabaseHasChanged.connect( self.do_load_projects_database) def do_delete_project(self): from .base.file.deleteproject import DeleteProjectDialog self.delete_dlg = DeleteProjectDialog(self.iface) if self.delete_dlg.init_gui(): self.delete_dlg.show() self.delete_dlg.projectsDatabaseHasChanged.connect( self.do_load_projects_database) def do_options(self): from .base.settings.options import OptionsDialog self.options_dlg = OptionsDialog(self.iface) self.options_dlg.init_gui() self.options_dlg.show() self.options_dlg.projectsDatabaseHasChanged.connect( self.do_load_projects_database) def do_load_projects_database(self): projects = get_projects() if projects is not None: grouped_projects = {} for project in projects: module_name = project["appmodulename"] try: module_list = grouped_projects[module_name] except KeyError: module_list = [] module_list.append(project) grouped_projects[module_name] = module_list self.menu_projects.clear() for key in sorted(grouped_projects): modules = grouped_projects[key] group_menu = self.menu_projects.addMenu(str(key)) sorted_projects_list = sorted(modules, key=lambda k: k['displayname']) for project in sorted_projects_list: action = QAction(str(project["displayname"]), self.iface.mainWindow()) group_menu.addAction(action) action.triggered.connect( lambda checked, active_project=project: self.do_load_project(active_project)) def do_load_project(self, project): # verified on osx, str(project[...]) return future.newstring, that # QSettings doesn't use it correctly. With native, use of standard # python string is forced. self.settings.setValue("project/id", str(project["id"])) self.settings.setValue("project/displayname", str(project["displayname"])) self.settings.setValue("project/appmodule", str(project["appmodule"])) self.settings.setValue("project/appmodulename", str(project["appmodulename"])) self.settings.setValue("project/ilimodelname", str(project["ilimodelname"])) self.settings.setValue("project/epsg", str(project["epsg"])) self.settings.setValue("project/provider", str(project["provider"])) if 'dbhost' in project: self.settings.setValue("project/dbhost", str(project["dbhost"])) if 'dbport' in project: self.settings.setValue("project/dbport", str(project["dbport"])) if 'dbname' in project: self.settings.setValue("project/dbname", str(project["dbname"])) self.settings.setValue("project/dbschema", str(project["dbschema"])) if 'dbuser' in project: self.settings.setValue("project/dbuser", str(project["dbuser"])) if 'dbpwd' in project: self.settings.setValue("project/dbpwd", str(project["dbpwd"])) if 'dbadmin' in project: self.settings.setValue("project/dbadmin", str(project["dbadmin"])) if 'dbadminpwd' in project: self.settings.setValue("project/dbadminpwd", str(project["dbadminpwd"])) if 'projectdir' in project: self.settings.setValue("project/projectdir", str(project["projectdir"])) self.settings.setValue("project/max_scale", str(project["max_scale"])) module_name = project["appmodule"].lower() try: module_name = "veriso.modules." + module_name + ".applicationmodule" module = dynamic_import(module_name) application_module = module.ApplicationModule(self) application_module.init_gui() if project["max_scale"]: self.set_max_scale(project["max_scale"]) else: self.unset_max_scale() except Exception as e: self.message_bar.pushMessage("VeriSO", str(e), level=Qgis.Critical, duration=0) def set_max_scale(self, scale): self.max_scale = scale self.iface.mapCanvas().scaleChanged.connect( self.zoom_to_max_scale) def unset_max_scale(self): self.max_scale = 0.0 try: self.iface.mapCanvas().scaleChanged.disconnect( self.zoom_to_max_scale) except TypeError: pass def zoom_to_max_scale(self): canvas = self.iface.mapCanvas() if int(canvas.scale()) < int(self.max_scale): canvas.scaleChanged.disconnect(self.zoom_to_max_scale) canvas.zoomScale(self.max_scale) canvas.scaleChanged.connect(self.zoom_to_max_scale) def unload(self): self.iface.mainWindow().removeToolBar(self.toolbar) def toggle_defects_list_dock_visibility(self): """Show or hide the dock widget.""" if self.defects_list_dock.isVisible(): self.defects_list_dock.setVisible(False) else: self.defects_list_dock.setVisible(True) self.defects_list_dock.raise_() def _create_defects_list_dock(self): """Create dockwidget and tabify it with the legend.""" self.defects_list_dock = DefectsListDock(self.iface) self.defects_list_dock.setObjectName('DefectsListDock') self.iface.addDockWidget(Qt.RightDockWidgetArea, self.defects_list_dock) legend_tab = self.iface.mainWindow().findChild(QApplication, 'Legend') if legend_tab: self.iface.mainWindow().tabifyDockWidget( legend_tab, self.defects_list_dock) self.defects_list_dock.setVisible(True) self.defects_list_dock.raise_() def _create_check_results_dock(self): """Create check results dockwidget""" self.CheckResultsDock = CheckResultsDock(self.iface) self.CheckResultsDock.setObjectName('CheckResultsDock') self.iface.addDockWidget(Qt.RightDockWidgetArea, self.CheckResultsDock) self.CheckResultsDock.clear_results() self.CheckResultsDock.setVisible(True) self.CheckResultsDock.raise_()
class WBNMViewer: """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # 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", "WBNMViewer_{}.qm".format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) QCoreApplication.installTranslator(self.translator) # Declare instance attributes self.actions = [] self.menu = self.tr(u"&WBNM Viewer") # TODO: We are going to let the user set this up in a future iteration self.toolbar = self.iface.addToolBar(u"WBNMViewer") self.toolbar.setObjectName(u"WBNMViewer") # print "** INITIALIZING WBNMViewer" self.pluginIsActive = False self.dockwidget = None # store processed data self.peaks = [] self.hydrographs = [] self.subareas = [] self.storms = [] # 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("WBNMViewer", message) def add_action( self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None, ): """Add a toolbar icon to the toolbar. :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to show in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu(self.menu, action) self.actions.append(action) return action def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ":/plugins/wbnm_viewer/icon.png" self.add_action( icon_path, text=self.tr(u"Open WBNM Viewer"), callback=self.run, parent=self.iface.mainWindow(), ) # -------------------------------------------------------------------------- def onClosePlugin(self): """Cleanup necessary items here when plugin dockwidget is closed""" # print "** CLOSING WBNMViewer" # disconnects self.dockwidget.closingPlugin.disconnect(self.onClosePlugin) # remove this statement if dockwidget is to remain # for reuse if plugin is reopened # Commented next statement since it causes QGIS crashe # when closing the docked window: # self.dockwidget = None self.pluginIsActive = False def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" # print "** UNLOAD WBNMViewer" for action in self.actions: self.iface.removePluginMenu(self.tr(u"&WBNM Viewer"), action) self.iface.removeToolBarIcon(action) # remove the toolbar del self.toolbar # -------------------------------------------------------------------------- def select_meta_file(self): filename, _filter = QFileDialog.getOpenFileName( self.dockwidget, "Select WBNM _Meta.out file", "", "*_Meta.out") return filename def populate_lists(self): processed_peaks = self.peaks[0] self.subareas = processed_peaks.subarea.sort_values().unique() self.storms = processed_peaks["storm"].sort_values().unique() self.aeps = processed_peaks["aep"].sort_values().unique() self.durations = processed_peaks["dur"].sort_values().unique() self.dockwidget.subareasListWidget.addItems(self.subareas) self.dockwidget.subareas2ListWidget.addItems(self.subareas) self.dockwidget.subareas3ListWidget.addItems(self.subareas) self.dockwidget.stormsListWidget.addItems(self.storms) self.dockwidget.aepsListWidget.addItems( sorted(self.aeps, key=lambda x: float(x))) self.dockwidget.aeps2ListWidget.addItems( sorted(self.aeps, key=lambda x: float(x))) self.dockwidget.durationsListWidget.addItems( sorted(self.durations, key=lambda x: int(x))) def process_meta_file(self): meta_file = self.select_meta_file() if meta_file: # process peaks processed_peaks = get_peaks(meta_file) self.peaks.append(processed_peaks) self.populate_lists() self.iface.messageBar().pushSuccess( "Success", "Meta file processed successfully!") # process hydrographs progressMessageBar = self.iface.messageBar().createMessage( "Processing hydrographs...") progress = QProgressBar() progress.setMaximum( len(self.peaks[0]["storm"].sort_values().unique())) progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) progressMessageBar.layout().addWidget(progress) self.iface.messageBar().pushWidget(progressMessageBar, Qgis.Info) processed_hydrographs = get_hydrographs(meta_file, progress=progress) self.hydrographs.append(processed_hydrographs) self.iface.messageBar().clearWidgets() self.iface.messageBar().pushSuccess( "Success", "Hydrographs processed successfully!") model = DataFrameModel(self.peaks[0]) self.dockwidget.dataTableView.setModel(model) def plot_hydrograph(self): subarea = self.dockwidget.subareasListWidget.selectedItems()[0].text() storm = self.dockwidget.stormsListWidget.selectedItems()[0].text() time = self.hydrographs[0][subarea][storm]["Time"] flow = self.hydrographs[0][subarea][storm]["Qout_OS"] fig = single_hydrograph(time, flow) update_plot(fig, self.dockwidget.chartWidget) def plot_box_whisker(self): subarea = self.dockwidget.subareas2ListWidget.selectedItems()[0].text() aep = self.dockwidget.aepsListWidget.selectedItems()[0].text() fig = box_plot(subarea, aep, self.peaks[0]) update_plot(fig, self.dockwidget.boxWidget) def plot_ensembles(self): subarea = self.dockwidget.subareas3ListWidget.selectedItems()[0].text() aep = self.dockwidget.aeps2ListWidget.selectedItems()[0].text() duration = self.dockwidget.durationsListWidget.selectedItems()[0].text( ) storms = self.peaks[0].loc[(self.peaks[0].subarea == subarea) & (self.peaks[0].aep == aep) & (self.peaks[0].dur == duration)].storm.unique() times = [] flows = [] for storm in storms: times.append(self.hydrographs[0][subarea][storm]["Time"]) flows.append(self.hydrographs[0][subarea][storm]["Qout_OS"]) fig = ensembles(times, flows, storms) update_plot(fig, self.dockwidget.ensembleWidget) def filter_storms(self): self.dockwidget.stormsListWidget.clear() filter_text = self.dockwidget.filterEdit.text() if filter_text == "": self.dockwidget.stormsListWidget.addItems(self.storms) else: filtered_storms = fnmatch.filter(self.storms, "*" + filter_text + "*") self.dockwidget.stormsListWidget.addItems(filtered_storms) def run(self): """Run method that loads and starts the plugin""" if not self.pluginIsActive: self.pluginIsActive = True # print "** STARTING WBNMViewer" # dockwidget may not exist if: # first run of plugin # removed on close (see self.onClosePlugin method) if self.dockwidget == None: # Create the dockwidget (after translation) and keep reference self.dockwidget = WBNMViewerDockWidget() self.dockwidget.plotButton.clicked.connect( self.plot_hydrograph) self.dockwidget.filterEdit.textChanged.connect( self.filter_storms) self.dockwidget.boxButton.clicked.connect( self.plot_box_whisker) self.dockwidget.ensembleButton.clicked.connect( self.plot_ensembles) # set up menubar self.window = QWidget() self.vbox = QVBoxLayout() self.window.setLayout(self.vbox) self.menuBar = QMenuBar() self.vbox.addWidget(self.menuBar) self.dockwidget.dockWidgetContents.layout().setSpacing(0) self.dockwidget.dockWidgetContents.layout().setMargin(0) self.dockwidget.dockWidgetContents.layout().setContentsMargins( 0, 0, 0, 0) self.dockwidget.dockWidgetContents.layout().insertWidget( 0, self.window) fileMenu = self.menuBar.addMenu("&File") self.loadWBNMMetaFile = QAction("Load WBNM *_Meta.out file", self.window) fileMenu.addAction(self.loadWBNMMetaFile) self.loadWBNMMetaFile.triggered.connect(self.process_meta_file) # set up data tab # connect to provide cleanup on closing of dockwidget self.dockwidget.closingPlugin.connect(self.onClosePlugin) # show the dockwidget # TODO: fix to allow choice of dock location self.iface.addDockWidget(Qt.BottomDockWidgetArea, self.dockwidget) self.dockwidget.show()
def initTopMenu(self): topMenu = QMenuBar() ######################load loadMenu = topMenu.addMenu("Load") loadSecAct = loadMenu.addAction('Load .sec...') loadSecAct.triggered.connect(lambda: self.loadSec(clear=True)) loadRteAct = loadMenu.addAction('Load .rte...') loadRteAct.triggered.connect( lambda: self.loadRteDialog.show(clearMode=True)) loadSrAct = loadMenu.addAction('Load .sr...') loadSrAct.triggered.connect(lambda: self.loadSr(clear=True)) ##################insert insertMenu = topMenu.addMenu("Insert") #insertMenu.setToolTipsVisible(True) insertMenu.hovered.connect( lambda action: action.parent().setToolTip(action.toolTip())) insertSecAct = insertMenu.addAction('Insert .sec...') insertSecAct.triggered.connect( lambda: self.loadSec(row=self.rowBox.value(), clear=False)) insertSecAct.setToolTip( 'insert .sec file using selected row and direction') insertRteAct = insertMenu.addAction('Insert .rte...') insertRteAct.triggered.connect( lambda: self.loadRteDialog.show(clearMode=False)) insertRteAct.setToolTip('insert .rte file at row') insertSrAct = insertMenu.addAction('Insert .sr...') insertSrAct.triggered.connect( lambda: self.loadSr(row=self.rowBox.value(), clear=False)) insertSrAct.setToolTip('insert .sr file at row') self.addFeatureAct = insertMenu.addAction('Add Selected Feature') self.addFeatureAct.setShortcut(QKeySequence( 'Alt+1')) #focus policy of dockwidget probably important here self.addFeatureAct.triggered.connect(self.addFeature) self.addFeatureAct.setToolTip( 'Insert selected feature of layer using selected row and direction' ) self.addDummyAct = insertMenu.addAction('Add Dummy') self.addDummyAct.setShortcut(QKeySequence( 'Alt+2')) #focus policy of dockwidget probably important here self.addDummyAct.triggered.connect(self.addDummy) self.addDummyAct.setToolTip('Insert dummy at row') ############################################save saveMenu = topMenu.addMenu("Save") saveSrAct = saveMenu.addAction('Save as .sr...') saveSrAct.triggered.connect(self.saveAsSr) saveSecAct = saveMenu.addAction('Save as .sec...') saveSecAct.triggered.connect(self.saveAsSec) saveRteAct = saveMenu.addAction('Save as .rte...') saveRteAct.triggered.connect(self.saveAsRte) #######################help helpMenu = topMenu.addMenu('Help') openHelpAct = helpMenu.addAction( 'Open help (in your default web browser)') openHelpAct.triggered.connect(self.openHelp) self.main_widget.layout().setMenuBar(topMenu)
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 VeriSO(object): def __init__(self, iface): self.iface = iface self.message_bar = self.iface.messageBar() self.plugin_dir = os.path.dirname(__file__) self.settings = QSettings("CatAIS", "VeriSO") locale = QSettings().value('locale/userLocale')[0:2] self.locale_path = os.path.join(self.plugin_dir, 'i18n', 'veriso_{}.qm'.format(locale)) if os.path.exists(self.locale_path): self.translator = QTranslator() self.translator.load(self.locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) # members self.toolbar = None self.menubar_projects = None self.menubar_file = None self.menu_file = None self.import_project = None self.delete_project = None self.menubar_settings = None self.menu_projects = None self.menu_settings = None self.options = None self.import_dlg = None self.delete_dlg = None self.options_dlg = None # noinspection PyPep8Naming def initGui(self): icon_path = ':/plugins/veriso/icon.png' # Qt offers some themes which you also can change in QGIS settings. # Since the background color of the menu toolbar can be different than # the background color of the button toolbars, the veriso toolbar # doesn't suit well. So we change it manually by finding out the # background color of one (e.g. file) toolbar and applying it # to the veriso toolbar. # This approach works (well?) for xfce 4.12 and standard (gtk+) theme. # We need to do this also in other methods when we add new menus :-( # 20150406: Only change QToolBar background color. # Otherweise the later added menus will have white hover color and # other quirks. # Strange: QToolBar stylesheet seems to need an border. background_color = self.iface.mainWindow().menuBar().palette().color( QPalette.Window).name() # main toolbar self.toolbar = self.iface.addToolBar("VeriSO") self.toolbar.setStyleSheet("QToolBar {background-color: " + background_color + "; border: 0px solid " + background_color + ";}") self.toolbar.setObjectName("VeriSO.Main.ToolBar") self.toolbar.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) # projects self.menubar_projects = QMenuBar() self.menubar_projects.setObjectName("VeriSO.Main.ProjectsMenuBar") self.menubar_projects.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)) self.menu_projects = QMenu() self.menu_projects.setTitle(tr("Projects")) self.menubar_projects.addMenu(self.menu_projects) # files self.menubar_file = QMenuBar() self.menubar_file.setObjectName("VeriSO.Main.FileMenuBar") self.menubar_file.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_file = QMenu() self.menu_file.setTitle(tr("File")) self.import_project = QAction(tr("Import project"), self.iface.mainWindow()) self.import_project.triggered.connect(self.do_import_project) self.delete_project = QAction(tr("Delete project"), self.iface.mainWindow()) self.delete_project.triggered.connect(self.do_delete_project) self.menu_file.addActions([self.import_project, self.delete_project]) self.menubar_file.addMenu(self.menu_file) # settings self.menubar_settings = QMenuBar() self.menubar_settings.setObjectName("VeriSO.Main.SettingsMenuBar") self.menubar_settings.setSizePolicy( QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)) self.menu_settings = QMenu() self.menu_settings.setTitle(tr("Settings")) self.options = QAction(tr("Options"), self.iface.mainWindow()) self.options.triggered.connect(self.do_options) self.menu_settings.addActions([self.options]) self.menubar_settings.addMenu(self.menu_settings) # Add menus to toolbar. self.toolbar.addWidget(self.menubar_projects) self.toolbar.addWidget(self.menubar_file) self.toolbar.addWidget(self.menubar_settings) # Initial load of project menu entries. self.do_load_projects_database() def do_import_project(self): from .base.file.importproject import ImportProjectDialog self.import_dlg = ImportProjectDialog(self.iface) if self.import_dlg.init_gui(): self.import_dlg.show() self.import_dlg.projectsDatabaseHasChanged.connect( self.do_load_projects_database) def do_delete_project(self): from .base.file.deleteproject import DeleteProjectDialog self.delete_dlg = DeleteProjectDialog(self.iface) if self.delete_dlg.init_gui(): self.delete_dlg.show() self.delete_dlg.projectsDatabaseHasChanged.connect( self.do_load_projects_database) def do_options(self): from .base.settings.options import OptionsDialog self.options_dlg = OptionsDialog(self.iface) self.options_dlg.init_gui() self.options_dlg.show() self.options_dlg.projectsDatabaseHasChanged.connect( self.do_load_projects_database) def do_load_projects_database(self): projects = get_projects() if projects is not None: grouped_projects = {} for project in projects: module_name = project["appmodulename"] try: module_list = grouped_projects[module_name] except KeyError: module_list = [] module_list.append(project) grouped_projects[module_name] = module_list self.menu_projects.clear() for key in sorted(grouped_projects): modules = grouped_projects[key] group_menu = self.menu_projects.addMenu(str(key)) sorted_projects_list = sorted(modules, key=lambda k: k['displayname']) for project in sorted_projects_list: action = QAction(str(project["displayname"]), self.iface.mainWindow()) group_menu.addAction(action) action.triggered.connect( lambda checked, active_project=project: self. do_load_project(active_project)) def do_load_project(self, project): self.settings.setValue("project/id", str(project["id"])) self.settings.setValue("project/displayname", str(project["displayname"])) self.settings.setValue("project/appmodule", str(project["appmodule"])) self.settings.setValue("project/appmodulename", str(project["appmodulename"])) self.settings.setValue("project/ilimodelname", str(project["ilimodelname"])) self.settings.setValue("project/epsg", str(project["epsg"])) self.settings.setValue("project/provider", str(project["provider"])) self.settings.setValue("project/dbhost", str(project["dbhost"])) self.settings.setValue("project/dbport", str(project["dbport"])) self.settings.setValue("project/dbname", str(project["dbname"])) self.settings.setValue("project/dbschema", str(project["dbschema"])) self.settings.setValue("project/dbuser", str(project["dbuser"])) self.settings.setValue("project/dbpwd", str(project["dbpwd"])) self.settings.setValue("project/dbadmin", str(project["dbadmin"])) self.settings.setValue("project/dbadminpwd", str(project["dbadminpwd"])) self.settings.setValue("project/projectdir", str(project["projectdir"])) module_name = str(project["appmodule"]).lower() try: module_name = "veriso.modules." + module_name + ".applicationmodule" module = dynamic_import(module_name) application_module = module.ApplicationModule( self.iface, self.toolbar, self.locale_path) application_module.init_gui() except Exception as e: self.message_bar.pushMessage("VeriSO", str(e), QgsMessageBar.CRITICAL, duration=0) def unload(self): self.iface.mainWindow().removeToolBar(self.toolbar)