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