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 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 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_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 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)
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 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)
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 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()
