def designer_opened(self, designer: QgsLayoutDesignerInterface):
"""
Called whenever a new layout designer window is opened
"""
toggle_unplaced_labels_action = QAction(
self.tr('Show Unplaced Labels on Maps'), parent=designer)
toggle_unplaced_labels_action.setCheckable(True)
toggle_unplaced_labels_action.setIcon(
GuiUtils.get_icon('show_unplaced_labels.svg'))
# determine initial check state
layout = designer.layout()
maps = [
item for item in layout.items()
if isinstance(item, QgsLayoutItemMap)
]
initial_checked = bool(maps) and all(
m.mapFlags() & QgsLayoutItemMap.ShowUnplacedLabels for m in maps)
toggle_unplaced_labels_action.setChecked(initial_checked)
toggle_unplaced_labels_action.toggled.connect(
partial(self.toggle_unplaced_labels, designer))
toggle_unplaced_labels_action.setShortcut(QKeySequence('Ctrl+Shift+U'))
tb = designer.actionsToolbar()
tb.addSeparator()
tb.addAction(toggle_unplaced_labels_action)
designer.viewMenu().addSeparator()
designer.viewMenu().addAction(toggle_unplaced_labels_action)
def add_plugin_pages(self, pages) -> None:
"""
Add pages from the plugin to the side pabel.
:param pages: List of plugin page classes to create and attach to the side panel.
"""
def safe_connect(method, to):
try:
method.connect(to)
except AttributeError:
pass
for PageClass in pages:
action = QAction(self.menutoolbar)
text = PageClass.title.ljust(13)
action.setIconText(text)
action.setIcon(QIcon(PageClass.icon))
action.setCheckable(True)
if PageClass.projectpage:
action.setVisible(False)
self.projectbuttons.append(action)
self.menutoolbar.insertAction(self.spaceraction, action)
else:
self.menutoolbar.insertAction(self.actionProject, action)
pagewidget = PageClass(plugins.api, self)
safe_connect(RoamEvents.selectionchanged,
pagewidget.selection_changed)
safe_connect(RoamEvents.projectloaded, pagewidget.project_loaded)
pageindex = self.stackedWidget.insertWidget(-1, pagewidget)
action.setProperty('page', pageindex)
self.pluginactions.append(action)
self.menuGroup.addAction(action)
class MainQtDialogUi(GwDialog, FORM_CLASS):
def __init__(self, subtag=None):
super().__init__()
self.txt_pass.setClearButtonEnabled(True)
icon_path = os.path.dirname(__file__) + os.sep + 'icons' + os.sep + 'eye_open.png'
self.action = QAction("show")
if os.path.exists(icon_path):
icon = QIcon(icon_path)
self.action = QAction(icon, "show")
self.action.triggered.connect(self.show_pass)
self.txt_pass.addAction(self.action, QLineEdit.TrailingPosition)
def show_pass(self):
icon_path = ""
text = ""
if self.txt_pass.echoMode() == 0:
self.txt_pass.setEchoMode(QLineEdit.Password)
icon_path = os.path.dirname(__file__) + os.sep + 'icons' + os.sep + 'eye_open.png'
text = "Show password"
elif self.txt_pass.echoMode() == 2:
self.txt_pass.setEchoMode(QLineEdit.Normal)
icon_path = os.path.dirname(__file__) + os.sep + 'icons' + os.sep + 'eye_close.png'
text = "Hide password"
if os.path.exists(icon_path):
icon = QIcon(icon_path)
self.action.setIcon(icon)
self.action.setText(text)
class QScatterPlugin:
def __init__(self, iface):
self.iface = iface
overrideLocale = QSettings().value('locale/overrideFlag', False, bool)
if not overrideLocale:
locale = QLocale.system().name()[:2]
else:
locale = QSettings().value('locale/userLocale', '')
qmPath = '{}/i18n/qscatter_{}.qm'.format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
self.actionRun = QAction(
self.tr('QScatter'), self.iface.mainWindow())
self.actionRun.setIcon(
QIcon(os.path.join(pluginPath, 'icons', 'qscatter.svg')))
self.actionRun.setWhatsThis(
self.tr('Interactive scatter plot'))
self.actionRun.setObjectName('runQScatter')
self.actionAbout = QAction(
self.tr('About...'), self.iface.mainWindow())
self.actionAbout.setIcon(
QgsApplication.getThemeIcon('/mActionHelpContents.svg'))
self.actionAbout.setWhatsThis(self.tr('About QScatter'))
self.actionRun.setObjectName('aboutQScatter')
self.iface.addPluginToVectorMenu(
self.tr('QScatter'), self.actionRun)
self.iface.addPluginToVectorMenu(
self.tr('QScatter'), self.actionAbout)
self.iface.addVectorToolBarIcon(self.actionRun)
self.actionRun.triggered.connect(self.run)
self.actionAbout.triggered.connect(self.about)
def unload(self):
self.iface.removePluginVectorMenu(
self.tr('QScatter'), self.actionRun)
self.iface.removePluginVectorMenu(
self.tr('QScatter'), self.actionAbout)
self.iface.removeVectorToolBarIcon(self.actionRun)
def run(self):
dlg = QScatterDialog(self.iface)
dlg.show()
dlg.exec_()
def about(self):
dlg = AboutDialog()
dlg.exec_()
def tr(self, text):
return QCoreApplication.translate('QScatter', text)
def createMenu(self):
self.menu.clear()
self.menu.setMinimumWidth(self.width())
fill_down_action = QAction(self.tr('Fill Down'), self.menu)
fill_down_action.triggered.connect(self.fillDown)
fill_down_action.setToolTip(self.tr('Copy the first value down to all other rows'))
self.menu.addAction(fill_down_action)
calculate_by_expression = QAction(QCoreApplication.translate('BatchPanel', 'Calculate by Expression…'),
self.menu)
calculate_by_expression.setIcon(QgsApplication.getThemeIcon('/mActionCalculateField.svg'))
calculate_by_expression.triggered.connect(self.calculateByExpression)
calculate_by_expression.setToolTip(self.tr('Calculates parameter values by evaluating an expression'))
self.menu.addAction(calculate_by_expression)
add_by_expression = QAction(QCoreApplication.translate('BatchPanel', 'Add Values by Expression…'),
self.menu)
add_by_expression.triggered.connect(self.addByExpression)
add_by_expression.setToolTip(self.tr('Adds new parameter values by evaluating an expression'))
self.menu.addAction(add_by_expression)
if isinstance(self.parameterDefinition, (QgsProcessingParameterFile,
QgsProcessingParameterMapLayer,
QgsProcessingParameterRasterLayer,
QgsProcessingParameterMeshLayer,
QgsProcessingParameterVectorLayer,
QgsProcessingParameterFeatureSource)):
self.menu.addSeparator()
find_by_pattern_action = QAction(QCoreApplication.translate('BatchPanel', 'Add Files by Pattern…'),
self.menu)
find_by_pattern_action.triggered.connect(self.addFilesByPattern)
find_by_pattern_action.setToolTip(self.tr('Adds files by a file pattern match'))
self.menu.addAction(find_by_pattern_action)
def createMenu(self):
self.menu.clear()
self.menu.setMinimumWidth(self.width())
fill_down_action = QAction(self.tr('Fill Down'), self.menu)
fill_down_action.triggered.connect(self.fillDown)
fill_down_action.setToolTip(self.tr('Copy the first value down to all other rows'))
self.menu.addAction(fill_down_action)
calculate_by_expression = QAction(QCoreApplication.translate('BatchPanel', 'Calculate by Expression…'),
self.menu)
calculate_by_expression.setIcon(QgsApplication.getThemeIcon('/mActionCalculateField.svg'))
calculate_by_expression.triggered.connect(self.calculateByExpression)
calculate_by_expression.setToolTip(self.tr('Calculates parameter values by evaluating an expression'))
self.menu.addAction(calculate_by_expression)
add_by_expression = QAction(QCoreApplication.translate('BatchPanel', 'Add Values by Expression…'),
self.menu)
add_by_expression.triggered.connect(self.addByExpression)
add_by_expression.setToolTip(self.tr('Adds new parameter values by evaluating an expression'))
self.menu.addAction(add_by_expression)
if isinstance(self.parameterDefinition, (QgsProcessingParameterFile,
QgsProcessingParameterMapLayer,
QgsProcessingParameterRasterLayer,
QgsProcessingParameterMeshLayer,
QgsProcessingParameterVectorLayer,
QgsProcessingParameterFeatureSource)):
self.menu.addSeparator()
find_by_pattern_action = QAction(QCoreApplication.translate('BatchPanel', 'Add Files by Pattern…'),
self.menu)
find_by_pattern_action.triggered.connect(self.addFilesByPattern)
find_by_pattern_action.setToolTip(self.tr('Adds files by a file pattern match'))
self.menu.addAction(find_by_pattern_action)
class Photo2ShapePlugin:
def __init__(self, iface):
self.iface = iface
overrideLocale = QSettings().value('locale/overrideFlag', False, bool)
if not overrideLocale:
locale = QLocale.system().name()[:2]
else:
locale = QSettings().value('locale/userLocale', '')
qmPath = '{}/i18n/photo2shape_{}.qm'.format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
self.actionRun = QAction(
self.tr('Photo2Shape'), self.iface.mainWindow())
self.actionRun.setIcon(
QIcon(os.path.join(pluginPath, 'icons', 'photo2shape.png')))
self.actionRun.setWhatsThis(
self.tr('Create a point shapefile from geotagged images'))
self.actionRun.setObjectName('runPhoto2Shape')
self.actionAbout = QAction(
self.tr('About Photo2Shape...'), self.iface.mainWindow())
self.actionAbout.setIcon(
QgsApplication.getThemeIcon('/mActionHelpContents.svg'))
self.actionAbout.setWhatsThis(self.tr('About Photo2Shape'))
self.actionRun.setObjectName('aboutPhoto2Shape')
self.iface.addPluginToVectorMenu(
self.tr('Photo2Shape'), self.actionRun)
self.iface.addPluginToVectorMenu(
self.tr('Photo2Shape'), self.actionAbout)
self.iface.addVectorToolBarIcon(self.actionRun)
self.actionRun.triggered.connect(self.run)
self.actionAbout.triggered.connect(self.about)
def unload(self):
self.iface.removePluginVectorMenu(
self.tr('Photo2Shape'), self.actionRun)
self.iface.removePluginVectorMenu(
self.tr('Photo2Shape'), self.actionAbout)
self.iface.removeVectorToolBarIcon(self.actionRun)
def run(self):
dlg = Photo2ShapeDialog(self.iface)
dlg.show()
dlg.exec_()
def about(self):
d = AboutDialog()
d.exec_()
def tr(self, text):
return QCoreApplication.translate('Photo2Shape', text)
def build_menu_tree(self):
# Main Menu
self.menu.clear()
self.groups_list = GroupsList()
self.ds_list = DataSourcesList()
data_sources = self.ds_list.data_sources.values()
data_sources = sorted(data_sources, key=lambda x: x.alias or x.id)
ds_hide_list = PluginSettings.get_hide_ds_id_list()
for ds in data_sources:
if ds.id in ds_hide_list:
continue
ds.action.triggered.connect(self.insert_layer)
gr_menu = self.groups_list.get_group_menu(ds.group)
gr_menu.addAction(ds.action)
if gr_menu not in self.menu.children():
self.menu.addMenu(gr_menu)
# QMS web service
self.menu.addSeparator()
self.service_actions.append(self.qms_search_action)
self.menu.addAction(self.qms_search_action)
icon_create_service_path = self.plugin_dir + '/icons/mActionCreate.svg'
qms_create_service_action = QAction(self.tr('Add to Search'), self.iface.mainWindow())
qms_create_service_action.setIcon(QIcon(icon_create_service_path))
qms_create_service_action.triggered.connect(self.openURL)
self.menu.addAction(qms_create_service_action)
# Scales, Settings and About actions
self.menu.addSeparator()
icon_set_nearest_scale_path = self.plugin_dir + '/icons/mActionSettings.svg' # TODO change icon
set_nearest_scale_act = QAction(QIcon(icon_set_nearest_scale_path), self.tr('Set proper scale'), self.iface.mainWindow())
set_nearest_scale_act.triggered.connect(self.set_nearest_scale)
self.menu.addAction(set_nearest_scale_act) # TODO: uncomment after fix
self.service_actions.append(set_nearest_scale_act)
icon_scales_path = self.plugin_dir + '/icons/mActionSettings.svg' # TODO change icon
scales_act = QAction(QIcon(icon_scales_path), self.tr('Set SlippyMap scales'), self.iface.mainWindow())
scales_act.triggered.connect(self.set_tms_scales)
#self.menu.addAction(scales_act) # TODO: uncomment after fix
self.service_actions.append(scales_act)
icon_settings_path = self.plugin_dir + '/icons/mActionSettings.svg'
settings_act = QAction(QIcon(icon_settings_path), self.tr('Settings'), self.iface.mainWindow())
self.service_actions.append(settings_act)
settings_act.triggered.connect(self.show_settings_dialog)
self.menu.addAction(settings_act)
icon_about_path = self.plugin_dir + '/icons/mActionAbout.svg'
info_act = QAction(QIcon(icon_about_path), self.tr('About'), self.iface.mainWindow())
self.service_actions.append(info_act)
info_act.triggered.connect(self.info_dlg.show)
self.menu.addAction(info_act)
def add_action(self, text, slot, icon=None):
action = QAction(self.iface.mainWindow())
action.setText(text)
if icon is not None:
action.setIcon(icon)
action.triggered.connect(slot)
self.menuToolBar.addAction(action)
self.iface.addPluginToMenu("&PreCourlis", action)
self.actions.append(action)
class QConsolidatePlugin:
def __init__(self, iface):
self.iface = iface
locale = QgsApplication.locale()
qmPath = '{}/i18n/qconsolidate_{}.qm'.format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
self.actionRun = QAction(self.tr('QConsolidate'), self.iface.mainWindow())
self.actionRun.setIcon(QIcon(os.path.join(pluginPath, 'icons', 'qconsolidate.svg')))
self.actionRun.setObjectName('runQConsolidate')
self.actionAbout = QAction(self.tr('About QConsolidate…'), self.iface.mainWindow())
self.actionAbout.setIcon(QgsApplication.getThemeIcon('/mActionHelpContents.svg'))
self.actionRun.setObjectName('aboutQConsolidate')
self.iface.addPluginToMenu(self.tr('QConsolidate'), self.actionRun)
self.iface.addPluginToMenu(self.tr('QConsolidate'), self.actionAbout)
self.iface.addToolBarIcon(self.actionRun)
self.actionRun.triggered.connect(self.run)
self.actionAbout.triggered.connect(self.about)
self.taskManager = QgsApplication.taskManager()
def unload(self):
self.iface.removePluginMenu(self.tr('QConsolidate'), self.actionRun)
self.iface.removePluginMenu(self.tr('QConsolidate'), self.actionAbout)
self.iface.removeToolBarIcon(self.actionRun)
def run(self):
dlg = QConsolidateDialog()
if dlg.exec_():
task = dlg.task()
task.consolidateComplete.connect(self.completed)
task.errorOccurred.connect(self.errored)
self.taskManager.addTask(task)
def about(self):
d = AboutDialog()
d.exec_()
def tr(self, text):
return QCoreApplication.translate('QConsolidate', text)
def completed(self):
self.iface.messageBar().pushSuccess(self.tr('QConsolidate'), self.tr('Project consolidated successfully.'))
def errored(self, error):
self.iface.messageBar().pushWarning(self.tr('QConsolidate'), error)
class Photo2ShapePlugin:
def __init__(self, iface):
self.iface = iface
locale = QgsApplication.locale()
qmPath = "{}/i18n/photo2shape_{}.qm".format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
self.actionRun = QAction(self.tr("Photo2Shape"),
self.iface.mainWindow())
self.actionRun.setIcon(
QIcon(os.path.join(pluginPath, "icons", "photo2shape.png")))
self.actionRun.setObjectName("runPhoto2Shape")
self.actionAbout = QAction(self.tr("About Photo2Shape…"),
self.iface.mainWindow())
self.actionAbout.setIcon(
QgsApplication.getThemeIcon("/mActionHelpContents.svg"))
self.actionRun.setObjectName("aboutPhoto2Shape")
self.iface.addPluginToVectorMenu(self.tr("Photo2Shape"),
self.actionRun)
self.iface.addPluginToVectorMenu(self.tr("Photo2Shape"),
self.actionAbout)
self.iface.addVectorToolBarIcon(self.actionRun)
self.actionRun.triggered.connect(self.run)
self.actionAbout.triggered.connect(self.about)
def unload(self):
self.iface.removePluginVectorMenu(self.tr("Photo2Shape"),
self.actionRun)
self.iface.removePluginVectorMenu(self.tr("Photo2Shape"),
self.actionAbout)
self.iface.removeVectorToolBarIcon(self.actionRun)
def run(self):
dlg = Photo2ShapeDialog(self.iface)
dlg.show()
dlg.exec_()
def about(self):
d = AboutDialog()
d.exec_()
def tr(self, text):
return QCoreApplication.translate("Photo2Shape", text)
class QMatplotlibWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.canvas = QMatplotlibCanvas()
self.ax = self.canvas.ax
self.figure = self.canvas.figure
self.toolBar = NavigationToolbar2QT(self.canvas, self)
bgColor = self.palette().color(QPalette.Background).name()
self.figure.set_facecolor(bgColor)
self.layout = QVBoxLayout()
self.layout.setSpacing(2)
self.layout.setMargin(0)
self.layout.addWidget(self.toolBar)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
self._setupToolbar()
def _setupToolbar(self):
self.actionToggleGrid = QAction(self.tr('Toggle grid'), self.toolBar)
self.actionToggleGrid.setIcon(
QIcon(os.path.join(pluginPath, 'icons', 'toggleGrid.svg')))
self.actionToggleGrid.setCheckable(True)
self.actionToggleGrid.triggered.connect(self.toggleGrid)
self.toolBar.insertAction(self.toolBar.actions()[7], self.actionToggleGrid)
self.toolBar.insertSeparator(self.toolBar.actions()[8])
def toggleGrid(self):
self.ax.grid()
self.canvas.draw()
def alignLabels(self):
self.figure.autofmt_xdate()
def clear(self):
self.ax.clear()
self.canvas.draw()
def setTitle(self, text):
self.ax.set_title(text)
def setXAxisCaption(self, text):
self.ax.set_xlabel(text)
def setYAxisCaption(self, text):
self.ax.set_ylabel(text)
def load_application_sync(self):
providers = list(roam.syncing.syncprovders())
if not providers:
return
actionwidget = ActionPickerWidget()
actionwidget.setTile("Roam Syncing")
for provider in providers:
action = QAction(None)
action.setText(provider.name)
action.setIcon(QIcon(":/icons/sync"))
action.triggered.connect(partial(self.run, action, provider))
actionwidget.addAction(action)
self.syncwidgets.layout().addWidget(actionwidget)
class StatistPlugin:
def __init__(self, iface):
self.iface = iface
locale = QgsApplication.locale()
qmPath = "{}/i18n/statist_{}.qm".format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
self.actionRun = QAction(self.tr("Statist"), self.iface.mainWindow())
self.actionRun.setIcon(QIcon(os.path.join(pluginPath, "icons", "statist.png")))
self.actionRun.setObjectName("runStatist")
self.iface.registerMainWindowAction(self.actionRun, "Shift+S")
self.actionAbout = QAction(self.tr("About Statist…"), self.iface.mainWindow())
self.actionAbout.setIcon(QgsApplication.getThemeIcon("/mActionHelpContents.svg"))
self.actionRun.setObjectName("aboutStatist")
self.iface.addPluginToVectorMenu(self.tr("Statist"), self.actionRun)
self.iface.addPluginToVectorMenu(self.tr("Statist"), self.actionAbout)
self.iface.addVectorToolBarIcon(self.actionRun)
self.actionRun.triggered.connect(self.run)
self.actionAbout.triggered.connect(self.about)
def unload(self):
self.iface.unregisterMainWindowAction(self.actionRun)
self.iface.removePluginVectorMenu(self.tr("Statist"), self.actionRun)
self.iface.removePluginVectorMenu(self.tr("Statist"), self.actionAbout)
self.iface.removeVectorToolBarIcon(self.actionRun)
def run(self):
dlg = StatistDialog()
dlg.show()
dlg.exec_()
def about(self):
d = AboutDialog()
d.exec_()
def tr(self, text):
return QCoreApplication.translate("Statist", text)
def loadprojects(self, projects):
# root = self.synctree.invisibleRootItem()
self.load_application_sync()
for project in projects:
providers = list(project.syncprovders())
if not providers:
continue
actionwidget = ActionPickerWidget()
actionwidget.setTile(project.name)
for provider in providers:
action = QAction(None)
action.setText(provider.name)
action.setIcon(QIcon(":/icons/sync"))
action.triggered.connect(partial(self.run, action, provider))
actionwidget.addAction(action)
self.syncwidgets.layout().addWidget(actionwidget)
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.syncwidgets.layout().addItem(spacerItem)
def showPopupMenu(self, point):
index = self.algorithmTree.indexAt(point)
popupmenu = QMenu()
alg = self.algorithmTree.algorithmForIndex(index)
if alg is not None:
executeAction = QAction(
QCoreApplication.translate('ProcessingToolbox', 'Execute…'),
popupmenu)
executeAction.triggered.connect(self.executeAlgorithm)
popupmenu.addAction(executeAction)
if alg.flags() & QgsProcessingAlgorithm.FlagSupportsBatch:
executeBatchAction = QAction(
QCoreApplication.translate('ProcessingToolbox',
'Execute as Batch Process…'),
popupmenu)
executeBatchAction.triggered.connect(
self.executeAlgorithmAsBatchProcess)
popupmenu.addAction(executeBatchAction)
popupmenu.addSeparator()
editRenderingStylesAction = QAction(
QCoreApplication.translate(
'ProcessingToolbox', 'Edit Rendering Styles for Outputs…'),
popupmenu)
editRenderingStylesAction.triggered.connect(
self.editRenderingStyles)
popupmenu.addAction(editRenderingStylesAction)
actions = ProviderContextMenuActions.actions
if len(actions) > 0:
popupmenu.addSeparator()
for action in actions:
action.setData(alg, self)
if action.is_separator:
popupmenu.addSeparator()
elif action.isEnabled():
contextMenuAction = QAction(action.name, popupmenu)
contextMenuAction.setIcon(action.icon())
contextMenuAction.triggered.connect(action.execute)
popupmenu.addAction(contextMenuAction)
popupmenu.exec_(self.algorithmTree.mapToGlobal(point))
def showPopupMenu(self, point):
index = self.algorithmTree.indexAt(point)
popupmenu = QMenu()
alg = self.algorithmTree.algorithmForIndex(index)
if alg is not None:
executeAction = QAction(QCoreApplication.translate('ProcessingToolbox', 'Execute…'), popupmenu)
executeAction.triggered.connect(self.executeAlgorithm)
popupmenu.addAction(executeAction)
if alg.flags() & QgsProcessingAlgorithm.FlagSupportsBatch:
executeBatchAction = QAction(
QCoreApplication.translate('ProcessingToolbox', 'Execute as Batch Process…'),
popupmenu)
executeBatchAction.triggered.connect(
self.executeAlgorithmAsBatchProcess)
popupmenu.addAction(executeBatchAction)
popupmenu.addSeparator()
editRenderingStylesAction = QAction(
QCoreApplication.translate('ProcessingToolbox', 'Edit Rendering Styles for Outputs…'),
popupmenu)
editRenderingStylesAction.triggered.connect(
self.editRenderingStyles)
popupmenu.addAction(editRenderingStylesAction)
actions = ProviderContextMenuActions.actions
if len(actions) > 0:
popupmenu.addSeparator()
for action in actions:
action.setData(alg, self)
if action.is_separator:
popupmenu.addSeparator()
elif action.isEnabled():
contextMenuAction = QAction(action.name,
popupmenu)
contextMenuAction.setIcon(action.icon())
contextMenuAction.triggered.connect(action.execute)
popupmenu.addAction(contextMenuAction)
popupmenu.exec_(self.algorithmTree.mapToGlobal(point))
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
self.menu = QMenu(self.tr('&QQuake'))
self.iface.pluginMenu().addMenu(self.menu)
show_dialog_action = QAction(self.tr('QQuake'))
show_dialog_action.setIcon(GuiUtils.get_icon('icon.svg'))
show_dialog_action.triggered.connect(self.show_dialog)
self.iface.addToolBarIcon(show_dialog_action)
self.menu.addAction(show_dialog_action)
self.actions.append(show_dialog_action)
show_options_action = QAction(self.tr('Options…'))
show_options_action.setIcon(GuiUtils.get_icon('options.svg'))
show_options_action.triggered.connect(self.show_options)
self.menu.addAction(show_options_action)
self.actions.append(show_options_action)
# will be set False in run()
self.first_start = True
self.options_factory = QQuakeOptionsFactory()
self.options_factory.setTitle(self.tr('QQuake'))
self.iface.registerOptionsWidgetFactory(self.options_factory)
class RasterTransparencyPlugin:
def __init__(self, iface):
self.iface = iface
locale = QgsApplication.locale()
qmPath = "{}/i18n/rastertransparency_{}.qm".format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
self.factory = TransparencyPanelFactory()
def initGui(self):
self.actionAbout = QAction(self.tr("About RasterTransparency…"), self.iface.mainWindow())
self.actionAbout.setIcon(QgsApplication.getThemeIcon("/mActionHelpContents.svg"))
self.actionAbout.setObjectName("aboutRasterTransparency")
self.actionAbout.triggered.connect(self.about)
self.iface.addPluginToRasterMenu(self.tr("Raster transparency"), self.actionAbout)
self.iface.registerMapLayerConfigWidgetFactory(self.factory)
def unload(self):
self.iface.removePluginRasterMenu(self.tr("Raster transparency"), self.actionAbout)
self.iface.unregisterMapLayerConfigWidgetFactory(self.factory)
def about(self):
d = AboutDialog()
d.exec_()
def tr(self, text):
return QCoreApplication.translate("RasterTransparency", text)
def showPopupMenu(self, point):
item = self.tree.currentItem()
if isinstance(item, TreeLogEntryItem):
popupmenu = QMenu()
python_command = item.as_python_command()
if python_command:
python_action = QAction(
QCoreApplication.translate('HistoryDialog',
'Copy as Python Command'),
self.tree)
python_action.setIcon(
QgsApplication.getThemeIcon("mIconPythonFile.svg"))
python_action.triggered.connect(
partial(self.copy_text, python_command))
popupmenu.addAction(python_action)
qgis_process_command = item.as_qgis_process_command()
if qgis_process_command:
qgis_process_action = QAction(
QCoreApplication.translate('HistoryDialog',
'Copy as qgis_process Command'),
self.tree)
qgis_process_action.setIcon(
QgsApplication.getThemeIcon("mActionTerminal.svg"))
qgis_process_action.triggered.connect(
partial(self.copy_text, qgis_process_command))
popupmenu.addAction(qgis_process_action)
inputs_json = item.inputs_map()
if inputs_json:
as_json_action = QAction(
QCoreApplication.translate('HistoryDialog',
'Copy as JSON'), self.tree)
as_json_action.setIcon(
QgsApplication.getThemeIcon("mActionEditCopy.svg"))
as_json_action.triggered.connect(
partial(self.copy_text, json.dumps(inputs_json, indent=2)))
popupmenu.addAction(as_json_action)
if not popupmenu.isEmpty():
popupmenu.addSeparator()
if python_command:
create_test_action = QAction(
QCoreApplication.translate('HistoryDialog',
'Create Test…'), self.tree)
create_test_action.triggered.connect(self.createTest)
popupmenu.addAction(create_test_action)
popupmenu.exec_(self.tree.mapToGlobal(point))
def addMenuItem(self, uri, filename, node, menu, absolute, mapLayersDict):
"""Add menu to an item."""
yaLayer = False
if node is None or node.nodeName() == "":
return yaLayer
element = node.toElement()
# if legendlayer tag
if node.nodeName() == "layer-tree-layer":
try:
name = element.attribute("name")
layerId = element.attribute("id")
visible = element.attribute("checked", "") == "Qt::Checked"
expanded = element.attribute("expanded", "0") == "1"
action = QAction(name, self.iface.mainWindow())
embedNd = getFirstChildByAttrValue(element, "property", "key",
"embedded")
# is layer embedded ?
if embedNd and embedNd.toElement().attribute("value") == "1":
# layer is embeded
efilename = None
eFileNd = getFirstChildByAttrValue(element, "property",
"key",
"embedded_project")
if eFileNd:
# get project file name
embeddedFile = eFileNd.toElement().attribute("value")
if not absolute and (embeddedFile.find(".") == 0):
efilename = QFileInfo(
filename).path() + "/" + embeddedFile
# if ok
if efilename:
# add menu item
action.triggered.connect(
lambda checked, uri=uri, f=efilename, lid=
layerId, m=menu, v=visible, x=expanded: self.
loadLayer(uri, f, lid, m, v, x))
menu.addAction(action)
yaLayer = True
if self.optionTooltip:
# search embeded maplayer (for title, abstract)
mapLayer = self.getMapLayerDomFromQgs(
efilename, layerId)
if mapLayer is not None:
self.addToolTip(mapLayer, action)
else:
self.log("Menu from layer: {} not found in project {}".
format(layerId, efilename))
# layer is not embedded
else:
efilename = filename
if self.optionTooltip:
self.addToolTip(mapLayersDict[layerId], action)
action.triggered.connect(
lambda checked, uri=uri, f=filename, lid=layerId, m=
menu, v=visible, x=expanded: self.loadLayer(
uri, f, lid, m, v, x))
menu.addAction(action)
yaLayer = True
# Add geometry type icon
try:
map_layer = self.getMapLayerDomFromQgs(
efilename, layerId).toElement()
geometry_type = map_layer.attribute("geometry")
if geometry_type == "":
# A TMS has not a geometry attribute.
# Let's read the "type"
geometry_type = map_layer.attribute("type")
action.setIcon(icon_per_geometry_type(geometry_type))
except Exception:
pass
except Exception as e:
for m in e.args:
self.log(m)
# / if element.tagName() == "layer-tree-layer":
# if legendgroup tag
if node.nodeName() == "layer-tree-group":
name = element.attribute("name")
propertiesNode = node.firstChild()
embedNd = getFirstChildByAttrValue(propertiesNode.toElement(),
"property", "key", "embedded")
# is group embedded ?
if embedNd and embedNd.toElement().attribute("value") == "1":
# group is embeded
efilename = None
eFileNd = getFirstChildByAttrValue(element, "property", "key",
"embedded_project")
if eFileNd:
# get project file name
embeddedFile = eFileNd.toElement().attribute("value")
if not absolute and (embeddedFile.find(".") == 0):
efilename = QFileInfo(
filename).path() + "/" + embeddedFile
# if ok
if efilename:
# add menu group
doc, _ = self.getQgsDoc(efilename)
groupNode = getFirstChildByAttrValue(
doc.documentElement(), "layer-tree-group", "name",
name)
# and do recursion
r = self.addMenuItem(
efilename,
efilename,
groupNode,
menu,
absolute,
getMapLayersDict(doc),
)
yaLayer = yaLayer or r
else:
self.log(
"Menu from layer: {} not found in project {}".format(
layerId, efilename))
# group is not embedded
else:
if name == "-":
menu.addSeparator()
elif name.startswith("-"):
action = QAction(name[1:], self.iface.mainWindow())
font = QFont()
font.setBold(True)
action.setFont(font)
menu.addAction(action)
else:
# sub-menu
sousmenu = menu.addMenu("&" + element.attribute("name"))
sousmenu.menuAction().setToolTip("")
sousmenu.setToolTipsVisible(self.optionTooltip)
childNode = node.firstChild()
# ! recursion
r = self.addMenuItem(uri, filename, childNode, sousmenu,
absolute, mapLayersDict)
if r and self.optionLoadAll and (len(sousmenu.actions()) >
1):
action = QAction(self.tr("Load all"),
self.iface.mainWindow())
font = QFont()
font.setBold(True)
action.setFont(font)
sousmenu.addAction(action)
action.triggered.connect(
lambda checked, f=None, w=None, m=sousmenu: self.
loadLayer(uri, f, w, m))
# / if element.tagName() == "legendgroup":
nextNode = node.nextSibling()
if nextNode is not None:
# ! recursion
r = self.addMenuItem(uri, filename, nextNode, menu, absolute,
mapLayersDict)
yaLayer = yaLayer or r
return yaLayer
def build_menu_tree(self):
# Main Menu
self.menu.clear()
self.groups_list = GroupsList()
self.ds_list = DataSourcesList()
data_sources = self.ds_list.data_sources.values()
data_sources = sorted(data_sources, key=lambda x: x.alias or x.id)
ds_hide_list = PluginSettings.get_hide_ds_id_list()
for ds in data_sources:
if ds.id in ds_hide_list:
continue
ds.action.triggered.connect(self.insert_layer)
gr_menu = self.groups_list.get_group_menu(ds.group)
gr_menu.addAction(ds.action)
if gr_menu not in self.menu.children():
self.menu.addMenu(gr_menu)
# QMS web service
self.menu.addSeparator()
self.service_actions.append(self.qms_search_action)
self.menu.addAction(self.qms_search_action)
icon_create_service_path = self.plugin_dir + '/icons/mActionCreate.svg'
qms_create_service_action = QAction(self.tr('Add to Search'),
self.iface.mainWindow())
qms_create_service_action.setIcon(QIcon(icon_create_service_path))
qms_create_service_action.triggered.connect(self.openURL)
self.menu.addAction(qms_create_service_action)
# Scales, Settings and About actions
self.menu.addSeparator()
icon_set_nearest_scale_path = self.plugin_dir + '/icons/mActionSettings.svg' # TODO change icon
set_nearest_scale_act = QAction(QIcon(icon_set_nearest_scale_path),
self.tr('Set proper scale'),
self.iface.mainWindow())
set_nearest_scale_act.triggered.connect(self.set_nearest_scale)
self.menu.addAction(set_nearest_scale_act) # TODO: uncomment after fix
self.service_actions.append(set_nearest_scale_act)
icon_scales_path = self.plugin_dir + '/icons/mActionSettings.svg' # TODO change icon
scales_act = QAction(QIcon(icon_scales_path),
self.tr('Set SlippyMap scales'),
self.iface.mainWindow())
scales_act.triggered.connect(self.set_tms_scales)
#self.menu.addAction(scales_act) # TODO: uncomment after fix
self.service_actions.append(scales_act)
icon_settings_path = self.plugin_dir + '/icons/mActionSettings.svg'
settings_act = QAction(QIcon(icon_settings_path), self.tr('Settings'),
self.iface.mainWindow())
self.service_actions.append(settings_act)
settings_act.triggered.connect(self.show_settings_dialog)
self.menu.addAction(settings_act)
icon_about_path = self.plugin_dir + '/icons/mActionAbout.svg'
info_act = QAction(QIcon(icon_about_path), self.tr('About'),
self.iface.mainWindow())
self.service_actions.append(info_act)
info_act.triggered.connect(self.info_dlg.show)
self.menu.addAction(info_act)
class PythonConsoleWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle(QCoreApplication.translate("PythonConsole", "Python Console"))
self.settings = QgsSettings()
self.shell = ShellScintilla(self)
self.setFocusProxy(self.shell)
self.shellOut = ShellOutputScintilla(self)
self.tabEditorWidget = EditorTabWidget(self)
# ------------ UI -------------------------------
self.splitterEditor = QSplitter(self)
self.splitterEditor.setOrientation(Qt.Horizontal)
self.splitterEditor.setHandleWidth(6)
self.splitterEditor.setChildrenCollapsible(True)
self.shellOutWidget = QWidget(self)
self.shellOutWidget.setLayout(QVBoxLayout())
self.shellOutWidget.layout().setContentsMargins(0, 0, 0, 0)
self.shellOutWidget.layout().addWidget(self.shellOut)
self.splitter = QSplitter(self.splitterEditor)
self.splitter.setOrientation(Qt.Vertical)
self.splitter.setHandleWidth(3)
self.splitter.setChildrenCollapsible(False)
self.splitter.addWidget(self.shellOutWidget)
self.splitter.addWidget(self.shell)
# self.splitterEditor.addWidget(self.tabEditorWidget)
self.splitterObj = QSplitter(self.splitterEditor)
self.splitterObj.setHandleWidth(3)
self.splitterObj.setOrientation(Qt.Horizontal)
# self.splitterObj.setSizes([0, 0])
# self.splitterObj.setStretchFactor(0, 1)
self.widgetEditor = QWidget(self.splitterObj)
self.widgetFind = QWidget(self)
self.listClassMethod = QTreeWidget(self.splitterObj)
self.listClassMethod.setColumnCount(2)
objInspLabel = QCoreApplication.translate("PythonConsole", "Object Inspector")
self.listClassMethod.setHeaderLabels([objInspLabel, ''])
self.listClassMethod.setColumnHidden(1, True)
self.listClassMethod.setAlternatingRowColors(True)
# self.splitterEditor.addWidget(self.widgetEditor)
# self.splitterObj.addWidget(self.listClassMethod)
# self.splitterObj.addWidget(self.widgetEditor)
# Hide side editor on start up
self.splitterObj.hide()
self.listClassMethod.hide()
# Hide search widget on start up
self.widgetFind.hide()
icon_size = iface.iconSize(dockedToolbar=True) if iface else QSize(16, 16)
sizes = self.splitter.sizes()
self.splitter.setSizes(sizes)
# ----------------Restore Settings------------------------------------
self.restoreSettingsConsole()
# ------------------Toolbar Editor-------------------------------------
# Action for Open File
openFileBt = QCoreApplication.translate("PythonConsole", "Open Script…")
self.openFileButton = QAction(self)
self.openFileButton.setCheckable(False)
self.openFileButton.setEnabled(True)
self.openFileButton.setIcon(QgsApplication.getThemeIcon("console/iconOpenConsole.svg"))
self.openFileButton.setMenuRole(QAction.PreferencesRole)
self.openFileButton.setIconVisibleInMenu(True)
self.openFileButton.setToolTip(openFileBt)
self.openFileButton.setText(openFileBt)
openExtEditorBt = QCoreApplication.translate("PythonConsole", "Open in External Editor")
self.openInEditorButton = QAction(self)
self.openInEditorButton.setCheckable(False)
self.openInEditorButton.setEnabled(True)
self.openInEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.svg"))
self.openInEditorButton.setMenuRole(QAction.PreferencesRole)
self.openInEditorButton.setIconVisibleInMenu(True)
self.openInEditorButton.setToolTip(openExtEditorBt)
self.openInEditorButton.setText(openExtEditorBt)
# Action for Save File
saveFileBt = QCoreApplication.translate("PythonConsole", "Save")
self.saveFileButton = QAction(self)
self.saveFileButton.setCheckable(False)
self.saveFileButton.setEnabled(False)
self.saveFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveConsole.svg"))
self.saveFileButton.setMenuRole(QAction.PreferencesRole)
self.saveFileButton.setIconVisibleInMenu(True)
self.saveFileButton.setToolTip(saveFileBt)
self.saveFileButton.setText(saveFileBt)
# Action for Save File As
saveAsFileBt = QCoreApplication.translate("PythonConsole", "Save As…")
self.saveAsFileButton = QAction(self)
self.saveAsFileButton.setCheckable(False)
self.saveAsFileButton.setEnabled(True)
self.saveAsFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveAsConsole.svg"))
self.saveAsFileButton.setMenuRole(QAction.PreferencesRole)
self.saveAsFileButton.setIconVisibleInMenu(True)
self.saveAsFileButton.setToolTip(saveAsFileBt)
self.saveAsFileButton.setText(saveAsFileBt)
# Action Cut
cutEditorBt = QCoreApplication.translate("PythonConsole", "Cut")
self.cutEditorButton = QAction(self)
self.cutEditorButton.setCheckable(False)
self.cutEditorButton.setEnabled(True)
self.cutEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditCut.svg"))
self.cutEditorButton.setMenuRole(QAction.PreferencesRole)
self.cutEditorButton.setIconVisibleInMenu(True)
self.cutEditorButton.setToolTip(cutEditorBt)
self.cutEditorButton.setText(cutEditorBt)
# Action Copy
copyEditorBt = QCoreApplication.translate("PythonConsole", "Copy")
self.copyEditorButton = QAction(self)
self.copyEditorButton.setCheckable(False)
self.copyEditorButton.setEnabled(True)
self.copyEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditCopy.svg"))
self.copyEditorButton.setMenuRole(QAction.PreferencesRole)
self.copyEditorButton.setIconVisibleInMenu(True)
self.copyEditorButton.setToolTip(copyEditorBt)
self.copyEditorButton.setText(copyEditorBt)
# Action Paste
pasteEditorBt = QCoreApplication.translate("PythonConsole", "Paste")
self.pasteEditorButton = QAction(self)
self.pasteEditorButton.setCheckable(False)
self.pasteEditorButton.setEnabled(True)
self.pasteEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditPaste.svg"))
self.pasteEditorButton.setMenuRole(QAction.PreferencesRole)
self.pasteEditorButton.setIconVisibleInMenu(True)
self.pasteEditorButton.setToolTip(pasteEditorBt)
self.pasteEditorButton.setText(pasteEditorBt)
# Action Run Script (subprocess)
runScriptEditorBt = QCoreApplication.translate("PythonConsole", "Run Script")
self.runScriptEditorButton = QAction(self)
self.runScriptEditorButton.setCheckable(False)
self.runScriptEditorButton.setEnabled(True)
self.runScriptEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconRunScriptConsole.svg"))
self.runScriptEditorButton.setMenuRole(QAction.PreferencesRole)
self.runScriptEditorButton.setIconVisibleInMenu(True)
self.runScriptEditorButton.setToolTip(runScriptEditorBt)
self.runScriptEditorButton.setText(runScriptEditorBt)
# Action Run Script (subprocess)
commentEditorBt = QCoreApplication.translate("PythonConsole", "Comment")
self.commentEditorButton = QAction(self)
self.commentEditorButton.setCheckable(False)
self.commentEditorButton.setEnabled(True)
self.commentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconCommentEditorConsole.svg"))
self.commentEditorButton.setMenuRole(QAction.PreferencesRole)
self.commentEditorButton.setIconVisibleInMenu(True)
self.commentEditorButton.setToolTip(commentEditorBt)
self.commentEditorButton.setText(commentEditorBt)
# Action Run Script (subprocess)
uncommentEditorBt = QCoreApplication.translate("PythonConsole", "Uncomment")
self.uncommentEditorButton = QAction(self)
self.uncommentEditorButton.setCheckable(False)
self.uncommentEditorButton.setEnabled(True)
self.uncommentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconUncommentEditorConsole.svg"))
self.uncommentEditorButton.setMenuRole(QAction.PreferencesRole)
self.uncommentEditorButton.setIconVisibleInMenu(True)
self.uncommentEditorButton.setToolTip(uncommentEditorBt)
self.uncommentEditorButton.setText(uncommentEditorBt)
# Action for Object browser
objList = QCoreApplication.translate("PythonConsole", "Object Inspector…")
self.objectListButton = QAction(self)
self.objectListButton.setCheckable(True)
self.objectListButton.setEnabled(self.settings.value("pythonConsole/enableObjectInsp",
False, type=bool))
self.objectListButton.setIcon(QgsApplication.getThemeIcon("console/iconClassBrowserConsole.svg"))
self.objectListButton.setMenuRole(QAction.PreferencesRole)
self.objectListButton.setIconVisibleInMenu(True)
self.objectListButton.setToolTip(objList)
self.objectListButton.setText(objList)
# Action for Find text
findText = QCoreApplication.translate("PythonConsole", "Find Text")
self.findTextButton = QAction(self)
self.findTextButton.setCheckable(True)
self.findTextButton.setEnabled(True)
self.findTextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchEditorConsole.svg"))
self.findTextButton.setMenuRole(QAction.PreferencesRole)
self.findTextButton.setIconVisibleInMenu(True)
self.findTextButton.setToolTip(findText)
self.findTextButton.setText(findText)
# ----------------Toolbar Console-------------------------------------
# Action Show Editor
showEditor = QCoreApplication.translate("PythonConsole", "Show Editor")
self.showEditorButton = QAction(self)
self.showEditorButton.setEnabled(True)
self.showEditorButton.setCheckable(True)
self.showEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.svg"))
self.showEditorButton.setMenuRole(QAction.PreferencesRole)
self.showEditorButton.setIconVisibleInMenu(True)
self.showEditorButton.setToolTip(showEditor)
self.showEditorButton.setText(showEditor)
# Action for Clear button
clearBt = QCoreApplication.translate("PythonConsole", "Clear Console")
self.clearButton = QAction(self)
self.clearButton.setCheckable(False)
self.clearButton.setEnabled(True)
self.clearButton.setIcon(QgsApplication.getThemeIcon("console/iconClearConsole.svg"))
self.clearButton.setMenuRole(QAction.PreferencesRole)
self.clearButton.setIconVisibleInMenu(True)
self.clearButton.setToolTip(clearBt)
self.clearButton.setText(clearBt)
# Action for settings
optionsBt = QCoreApplication.translate("PythonConsole", "Options…")
self.optionsButton = QAction(self)
self.optionsButton.setCheckable(False)
self.optionsButton.setEnabled(True)
self.optionsButton.setIcon(QgsApplication.getThemeIcon("console/iconSettingsConsole.svg"))
self.optionsButton.setMenuRole(QAction.PreferencesRole)
self.optionsButton.setIconVisibleInMenu(True)
self.optionsButton.setToolTip(optionsBt)
self.optionsButton.setText(optionsBt)
# Action for Run script
runBt = QCoreApplication.translate("PythonConsole", "Run Command")
self.runButton = QAction(self)
self.runButton.setCheckable(False)
self.runButton.setEnabled(True)
self.runButton.setIcon(QgsApplication.getThemeIcon("console/mIconRunConsole.svg"))
self.runButton.setMenuRole(QAction.PreferencesRole)
self.runButton.setIconVisibleInMenu(True)
self.runButton.setToolTip(runBt)
self.runButton.setText(runBt)
# Help action
helpBt = QCoreApplication.translate("PythonConsole", "Help…")
self.helpButton = QAction(self)
self.helpButton.setCheckable(False)
self.helpButton.setEnabled(True)
self.helpButton.setIcon(QgsApplication.getThemeIcon("console/iconHelpConsole.svg"))
self.helpButton.setMenuRole(QAction.PreferencesRole)
self.helpButton.setIconVisibleInMenu(True)
self.helpButton.setToolTip(helpBt)
self.helpButton.setText(helpBt)
self.toolBar = QToolBar()
self.toolBar.setEnabled(True)
self.toolBar.setFocusPolicy(Qt.NoFocus)
self.toolBar.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBar.setLayoutDirection(Qt.LeftToRight)
self.toolBar.setIconSize(icon_size)
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
self.toolBar.addAction(self.clearButton)
self.toolBar.addAction(self.runButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.showEditorButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.optionsButton)
self.toolBar.addAction(self.helpButton)
self.toolBarEditor = QToolBar()
self.toolBarEditor.setEnabled(False)
self.toolBarEditor.setFocusPolicy(Qt.NoFocus)
self.toolBarEditor.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBarEditor.setLayoutDirection(Qt.LeftToRight)
self.toolBarEditor.setIconSize(icon_size)
self.toolBarEditor.setMovable(False)
self.toolBarEditor.setFloatable(False)
self.toolBarEditor.addAction(self.openFileButton)
self.toolBarEditor.addAction(self.openInEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.saveFileButton)
self.toolBarEditor.addAction(self.saveAsFileButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.runScriptEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.findTextButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.cutEditorButton)
self.toolBarEditor.addAction(self.copyEditorButton)
self.toolBarEditor.addAction(self.pasteEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.commentEditorButton)
self.toolBarEditor.addAction(self.uncommentEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.objectListButton)
self.widgetButton = QWidget()
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widgetButton.sizePolicy().hasHeightForWidth())
self.widgetButton.setSizePolicy(sizePolicy)
self.widgetButtonEditor = QWidget(self.widgetEditor)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widgetButtonEditor.sizePolicy().hasHeightForWidth())
self.widgetButtonEditor.setSizePolicy(sizePolicy)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.shellOut.sizePolicy().hasHeightForWidth())
self.shellOut.setSizePolicy(sizePolicy)
self.shellOut.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.shell.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
# ------------ Layout -------------------------------
self.mainLayout = QGridLayout(self)
self.mainLayout.setMargin(0)
self.mainLayout.setSpacing(0)
self.mainLayout.addWidget(self.widgetButton, 0, 0, 1, 1)
self.mainLayout.addWidget(self.splitterEditor, 0, 1, 1, 1)
self.shellOutWidget.layout().insertWidget(0, self.toolBar)
self.layoutEditor = QGridLayout(self.widgetEditor)
self.layoutEditor.setMargin(0)
self.layoutEditor.setSpacing(0)
self.layoutEditor.addWidget(self.toolBarEditor, 0, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetButtonEditor, 1, 0, 2, 1)
self.layoutEditor.addWidget(self.tabEditorWidget, 1, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetFind, 2, 1, 1, 1)
# Layout for the find widget
self.layoutFind = QGridLayout(self.widgetFind)
self.layoutFind.setContentsMargins(0, 0, 0, 0)
self.lineEditFind = QgsFilterLineEdit()
placeHolderTxt = QCoreApplication.translate("PythonConsole", "Enter text to find…")
self.lineEditFind.setPlaceholderText(placeHolderTxt)
self.toolBarFindText = QToolBar()
self.toolBarFindText.setIconSize(icon_size)
self.findNextButton = QAction(self)
self.findNextButton.setEnabled(False)
toolTipfindNext = QCoreApplication.translate("PythonConsole", "Find Next")
self.findNextButton.setToolTip(toolTipfindNext)
self.findNextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchNextEditorConsole.svg"))
self.findPrevButton = QAction(self)
self.findPrevButton.setEnabled(False)
toolTipfindPrev = QCoreApplication.translate("PythonConsole", "Find Previous")
self.findPrevButton.setToolTip(toolTipfindPrev)
self.findPrevButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchPrevEditorConsole.svg"))
self.caseSensitive = QCheckBox()
caseSensTr = QCoreApplication.translate("PythonConsole", "Case Sensitive")
self.caseSensitive.setText(caseSensTr)
self.wholeWord = QCheckBox()
wholeWordTr = QCoreApplication.translate("PythonConsole", "Whole Word")
self.wholeWord.setText(wholeWordTr)
self.wrapAround = QCheckBox()
self.wrapAround.setChecked(True)
wrapAroundTr = QCoreApplication.translate("PythonConsole", "Wrap Around")
self.wrapAround.setText(wrapAroundTr)
self.toolBarFindText.addWidget(self.lineEditFind)
self.toolBarFindText.addAction(self.findPrevButton)
self.toolBarFindText.addAction(self.findNextButton)
self.toolBarFindText.addWidget(self.caseSensitive)
self.toolBarFindText.addWidget(self.wholeWord)
self.toolBarFindText.addWidget(self.wrapAround)
self.layoutFind.addWidget(self.toolBarFindText, 0, 1, 1, 1)
# ------------ Add first Tab in Editor -------------------------------
# self.tabEditorWidget.newTabEditor(tabName='first', filename=None)
# ------------ Signal -------------------------------
self.findTextButton.triggered.connect(self._toggleFind)
self.objectListButton.toggled.connect(self.toggleObjectListWidget)
self.commentEditorButton.triggered.connect(self.commentCode)
self.uncommentEditorButton.triggered.connect(self.uncommentCode)
self.runScriptEditorButton.triggered.connect(self.runScriptEditor)
self.cutEditorButton.triggered.connect(self.cutEditor)
self.copyEditorButton.triggered.connect(self.copyEditor)
self.pasteEditorButton.triggered.connect(self.pasteEditor)
self.showEditorButton.toggled.connect(self.toggleEditor)
self.clearButton.triggered.connect(self.shellOut.clearConsole)
self.optionsButton.triggered.connect(self.openSettings)
self.runButton.triggered.connect(self.shell.entered)
self.openFileButton.triggered.connect(self.openScriptFile)
self.openInEditorButton.triggered.connect(self.openScriptFileExtEditor)
self.saveFileButton.triggered.connect(self.saveScriptFile)
self.saveAsFileButton.triggered.connect(self.saveAsScriptFile)
self.helpButton.triggered.connect(self.openHelp)
self.listClassMethod.itemClicked.connect(self.onClickGoToLine)
self.lineEditFind.returnPressed.connect(self._findNext)
self.findNextButton.triggered.connect(self._findNext)
self.findPrevButton.triggered.connect(self._findPrev)
self.lineEditFind.textChanged.connect(self._textFindChanged)
self.findScut = QShortcut(QKeySequence.Find, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._openFind)
self.findNextScut = QShortcut(QKeySequence.FindNext, self.widgetEditor)
self.findNextScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findNextScut.activated.connect(self._findNext)
self.findPreviousScut = QShortcut(QKeySequence.FindPrevious, self.widgetEditor)
self.findPreviousScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findPreviousScut.activated.connect(self._findPrev)
# Escape on editor hides the find bar
self.findScut = QShortcut(Qt.Key_Escape, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._closeFind)
def _toggleFind(self):
self.tabEditorWidget.currentWidget().newEditor.toggleFindWidget()
def _openFind(self):
self.tabEditorWidget.currentWidget().newEditor.openFindWidget()
def _closeFind(self):
self.tabEditorWidget.currentWidget().newEditor.closeFindWidget()
def _findNext(self):
self.tabEditorWidget.currentWidget().newEditor.findText(True)
def _findPrev(self):
self.tabEditorWidget.currentWidget().newEditor.findText(False)
def _textFindChanged(self):
if self.lineEditFind.text():
self.findNextButton.setEnabled(True)
self.findPrevButton.setEnabled(True)
self.tabEditorWidget.currentWidget().newEditor.findText(True, showMessage=False, findFirst=True)
else:
self.lineEditFind.setStyleSheet('')
self.findNextButton.setEnabled(False)
self.findPrevButton.setEnabled(False)
def onClickGoToLine(self, item, column):
tabEditor = self.tabEditorWidget.currentWidget().newEditor
if item.text(1) == 'syntaxError':
check = tabEditor.syntaxCheck(fromContextMenu=False)
if check and not tabEditor.isReadOnly():
self.tabEditorWidget.currentWidget().save()
return
linenr = int(item.text(1))
itemName = str(item.text(0))
charPos = itemName.find(' ')
if charPos != -1:
objName = itemName[0:charPos]
else:
objName = itemName
tabEditor.goToLine(objName, linenr)
def toggleEditor(self, checked):
self.splitterObj.show() if checked else self.splitterObj.hide()
if not self.tabEditorWidget:
self.tabEditorWidget.enableToolBarEditor(checked)
self.tabEditorWidget.restoreTabsOrAddNew()
def toggleObjectListWidget(self, checked):
self.listClassMethod.show() if checked else self.listClassMethod.hide()
def pasteEditor(self):
self.tabEditorWidget.currentWidget().newEditor.paste()
def cutEditor(self):
self.tabEditorWidget.currentWidget().newEditor.cut()
def copyEditor(self):
self.tabEditorWidget.currentWidget().newEditor.copy()
def runScriptEditor(self):
self.tabEditorWidget.currentWidget().newEditor.runScriptCode()
def commentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(True)
def uncommentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(False)
def openScriptFileExtEditor(self):
tabWidget = self.tabEditorWidget.currentWidget()
path = tabWidget.path
import subprocess
try:
subprocess.Popen([os.environ['EDITOR'], path])
except KeyError:
QDesktopServices.openUrl(QUrl.fromLocalFile(path))
def openScriptFile(self):
lastDirPath = self.settings.value("pythonConsole/lastDirPath", QDir.homePath())
openFileTr = QCoreApplication.translate("PythonConsole", "Open File")
fileList, selected_filter = QFileDialog.getOpenFileNames(
self, openFileTr, lastDirPath, "Script file (*.py)")
if fileList:
for pyFile in fileList:
for i in range(self.tabEditorWidget.count()):
tabWidget = self.tabEditorWidget.widget(i)
if tabWidget.path == pyFile:
self.tabEditorWidget.setCurrentWidget(tabWidget)
break
else:
tabName = QFileInfo(pyFile).fileName()
self.tabEditorWidget.newTabEditor(tabName, pyFile)
lastDirPath = QFileInfo(pyFile).path()
self.settings.setValue("pythonConsole/lastDirPath", pyFile)
self.updateTabListScript(pyFile, action='append')
def saveScriptFile(self):
tabWidget = self.tabEditorWidget.currentWidget()
try:
tabWidget.save()
except (IOError, OSError) as error:
msgText = QCoreApplication.translate('PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}').format(tabWidget.path,
error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
def saveAsScriptFile(self, index=None):
tabWidget = self.tabEditorWidget.currentWidget()
if not index:
index = self.tabEditorWidget.currentIndex()
if not tabWidget.path:
fileName = self.tabEditorWidget.tabText(index) + '.py'
folder = self.settings.value("pythonConsole/lastDirPath", QDir.homePath())
pathFileName = os.path.join(folder, fileName)
fileNone = True
else:
pathFileName = tabWidget.path
fileNone = False
saveAsFileTr = QCoreApplication.translate("PythonConsole", "Save File As")
filename, filter = QFileDialog.getSaveFileName(self,
saveAsFileTr,
pathFileName, "Script file (*.py)")
if filename:
try:
tabWidget.save(filename)
except (IOError, OSError) as error:
msgText = QCoreApplication.translate('PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}').format(tabWidget.path,
error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
if fileNone:
tabWidget.path = None
else:
tabWidget.path = pathFileName
return
if not fileNone:
self.updateTabListScript(pathFileName, action='remove')
def openHelp(self):
QgsHelp.openHelp("plugins/python_console.html")
def openSettings(self):
if optionsDialog(self).exec_():
self.shell.refreshSettingsShell()
self.shellOut.refreshSettingsOutput()
self.tabEditorWidget.refreshSettingsEditor()
def callWidgetMessageBar(self, text):
self.shellOut.widgetMessageBar(iface, text)
def callWidgetMessageBarEditor(self, text, level, timed):
self.tabEditorWidget.widgetMessageBar(iface, text, level, timed)
def updateTabListScript(self, script, action=None):
if action == 'remove':
self.tabListScript.remove(script)
elif action == 'append':
if not self.tabListScript:
self.tabListScript = []
if script not in self.tabListScript:
self.tabListScript.append(script)
else:
self.tabListScript = []
self.settings.setValue("pythonConsole/tabScripts",
self.tabListScript)
def saveSettingsConsole(self):
self.settings.setValue("pythonConsole/splitterConsole", self.splitter.saveState())
self.settings.setValue("pythonConsole/splitterObj", self.splitterObj.saveState())
self.settings.setValue("pythonConsole/splitterEditor", self.splitterEditor.saveState())
self.shell.writeHistoryFile(True)
def restoreSettingsConsole(self):
storedTabScripts = self.settings.value("pythonConsole/tabScripts", [])
self.tabListScript = storedTabScripts
self.splitter.restoreState(self.settings.value("pythonConsole/splitterConsole", QByteArray()))
self.splitterEditor.restoreState(self.settings.value("pythonConsole/splitterEditor", QByteArray()))
self.splitterObj.restoreState(self.settings.value("pythonConsole/splitterObj", QByteArray()))
class MapWidget(Ui_CanvasWidget, QMainWindow):
def __init__(self, parent=None):
super(MapWidget, self).__init__(parent)
self.setupUi(self)
self.snapping = True
icon = roam_style.iconsize()
self.projecttoolbar.setIconSize(QSize(icon, icon))
self.defaultextent = None
self.current_form = None
self.last_form = None
self.layerbuttons = []
self.editfeaturestack = []
self.lastgpsposition = None
self.project = None
self.gps = None
self.gpslogging = None
self.selectionbands = defaultdict(partial(QgsRubberBand, self.canvas))
self.bridge = QgsLayerTreeMapCanvasBridge(
QgsProject.instance().layerTreeRoot(), self.canvas)
self.bridge.setAutoSetupOnFirstLayer(False)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.snappingutils = SnappingUtils(self.canvas, self)
self.canvas.setSnappingUtils(self.snappingutils)
threadcount = QThread.idealThreadCount()
threadcount = 2 if threadcount > 2 else 1
QgsApplication.setMaxThreads(threadcount)
self.canvas.setParallelRenderingEnabled(True)
self.canvas.setFrameStyle(QFrame.NoFrame)
self.editgroup = QActionGroup(self)
self.editgroup.setExclusive(True)
self.editgroup.addAction(self.actionPan)
self.editgroup.addAction(self.actionZoom_In)
self.editgroup.addAction(self.actionZoom_Out)
self.editgroup.addAction(self.actionInfo)
self.actionGPS = GPSAction(self.canvas, self)
self.projecttoolbar.addAction(self.actionGPS)
if roam.config.settings.get('north_arrow', False):
self.northarrow = NorthArrow(":/icons/north", self.canvas)
self.northarrow.setPos(10, 10)
self.canvas.scene().addItem(self.northarrow)
smallmode = roam.config.settings.get("smallmode", False)
self.projecttoolbar.setSmallMode(smallmode)
self.projecttoolbar.setContextMenuPolicy(Qt.CustomContextMenu)
gpsspacewidget = QWidget()
gpsspacewidget.setMinimumWidth(30)
gpsspacewidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.topspaceraction = self.projecttoolbar.insertWidget(
self.actionGPS, gpsspacewidget)
self.dataentryselection = QAction(self.projecttoolbar)
self.dataentryaction = self.projecttoolbar.insertAction(
self.topspaceraction, self.dataentryselection)
self.dataentryselection.triggered.connect(self.select_data_entry)
self.gpsMarker = GPSMarker(self.canvas)
self.gpsMarker.hide()
self.currentfeatureband = CurrentSelection(self.canvas)
self.currentfeatureband.setIconSize(30)
self.currentfeatureband.setWidth(10)
self.currentfeatureband.setColor(QColor(88, 64, 173, 50))
self.currentfeatureband.setOutlineColour(QColor(88, 64, 173))
self.gpsband = QgsRubberBand(self.canvas)
self.gpsband.setColor(QColor(165, 111, 212, 75))
self.gpsband.setWidth(5)
RoamEvents.refresh_map.connect(self.refresh_map)
RoamEvents.editgeometry.connect(self.queue_feature_for_edit)
RoamEvents.selectioncleared.connect(self.clear_selection)
RoamEvents.selectionchanged.connect(self.highlight_selection)
RoamEvents.openfeatureform.connect(self.feature_form_loaded)
RoamEvents.sync_complete.connect(self.refresh_map)
RoamEvents.snappingChanged.connect(self.snapping_changed)
self.snappingbutton = QToolButton()
self.snappingbutton.setText("Snapping: On")
self.snappingbutton.setAutoRaise(True)
self.snappingbutton.pressed.connect(self.toggle_snapping)
spacer = QWidget()
spacer2 = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.scalewidget = QgsScaleComboBox()
self.scalebutton = QToolButton()
self.scalebutton.setAutoRaise(True)
self.scalebutton.setMaximumHeight(self.statusbar.height())
self.scalebutton.pressed.connect(self.selectscale)
self.scalebutton.setText("Scale")
self.scalelist = BigList(parent=self.canvas,
centeronparent=True,
showsave=False)
self.scalelist.hide()
self.scalelist.setlabel("Map Scale")
self.scalelist.setmodel(self.scalewidget.model())
self.scalelist.closewidget.connect(self.scalelist.close)
self.scalelist.itemselected.connect(self.update_scale_from_item)
self.scalelist.itemselected.connect(self.scalelist.close)
self.positionlabel = QLabel('')
self.gpslabel = QLabel("GPS: Not active")
self.gpslabelposition = QLabel("")
self.statusbar.addWidget(self.snappingbutton)
self.statusbar.addWidget(spacer2)
self.statusbar.addWidget(self.gpslabel)
self.statusbar.addWidget(self.gpslabelposition)
self.statusbar.addPermanentWidget(self.scalebutton)
self.canvas.extentsChanged.connect(self.update_status_label)
self.canvas.scaleChanged.connect(self.update_status_label)
self.connectButtons()
scalebar_enabled = roam.config.settings.get('scale_bar', False)
self.scalebar_enabled = False
if scalebar_enabled:
roam.utils.warning(
"Unsupported feature: Scale bar support not ported to QGIS 3 API yet."
)
RoamEvents.raisemessage(
"Unsupported feature",
"Scale bar support not ported to QGIS 3 API yet",
level=RoamEvents.CRITICAL)
self.scalebar_enabled = False
# self.scalebar = ScaleBarItem(self.canvas)
# self.canvas.scene().addItem(self.scalebar)
def clear_plugins(self) -> None:
"""
Clear all the plugin added toolbars from the map interface.
"""
toolbars = self.findChildren(QToolBar)
for toolbar in toolbars:
if toolbar.property("plugin_toolbar"):
toolbar.unload()
self.removeToolBar(toolbar)
toolbar.deleteLater()
def add_plugins(self, pluginnames) -> None:
"""
Add the given plugins to to the mapping interface.
Adds the toolbars the plugin exposes as new toolbars for the user.
:param pluginnames: The names of the plugins to load. Must already be loaded
by the plugin loader
"""
for name in pluginnames:
# Get the plugin
try:
plugin_mod = plugins.loaded_plugins[name]
except KeyError:
continue
if not hasattr(plugin_mod, 'toolbars'):
roam.utils.warning(
"No toolbars() function found in {}".format(name))
continue
toolbars = plugin_mod.toolbars()
self.load_plugin_toolbars(toolbars)
def load_plugin_toolbars(self, toolbars):
"""
Load the plugin toolbars into the mapping interface.
:param toolbars: The list of toolbars class objects to load.
:return:
"""
for ToolBarClass in toolbars:
toolbar = ToolBarClass(plugins.api, self)
self.addToolBar(Qt.BottomToolBarArea, toolbar)
toolbar.setProperty("plugin_toolbar", True)
def snapping_changed(self, snapping):
"""
Called when the snapping settings have changed. Updates the label in the status bar.
:param snapping:
"""
self.snapping = snapping
if snapping:
self.snappingbutton.setText("Snapping: On")
else:
self.snappingbutton.setText("Snapping: Off")
def toggle_snapping(self):
"""
Toggle snapping on or off.
"""
self.snapping = not self.snapping
try:
self.canvas.mapTool().toggle_snapping()
except AttributeError:
pass
RoamEvents.snappingChanged.emit(self.snapping)
def selectscale(self):
"""
Show the select scale widget.
:return:
"""
self.scalelist.show()
def update_scale_from_item(self, index):
"""
Update the canvas scale from the selected scale item.
:param index: The index of the selected item.
"""
scale, _ = self.scalewidget.toDouble(index.data(Qt.DisplayRole))
self.canvas.zoomScale(1.0 / scale)
def update_gps_fixed_label(self, fixed, gpsinfo):
if not fixed:
self.gpslabel.setText("GPS: Acquiring fix")
self.gpslabelposition.setText("")
quality_mappings = {
0: "invalid",
1: "GPS",
2: "DGPS",
3: "PPS",
4: "Real Time Kinematic",
5: "Float RTK",
6: "Estimated",
7: "Manual input mode",
8: "Simulation mode"
}
def update_gps_label(self, position, gpsinfo):
"""
Update the GPS label in the status bar with the GPS status.
:param position: The current GPS position.
:param gpsinfo: The current extra GPS information.
"""
if not self.gps.connected:
return
fixtype = self.quality_mappings.get(gpsinfo.quality, "")
self.gpslabel.setText(
"DOP P:<b>{0:.2f}</b> H:<b>{1:.2f}</b> V:<b>{2:.2f}</b> "
"Fix: <b>{3}</b> "
"Sats: <b>{4}</b> ".format(gpsinfo.pdop, gpsinfo.hdop,
gpsinfo.vdop, fixtype,
gpsinfo.satellitesUsed))
places = roam.config.settings.get("gpsplaces", 8)
self.gpslabelposition.setText("X: <b>{x:.{places}f}</b> "
"Y: <b>{y:.{places}f}</b> "
"Z: <b>{z}m</b> ".format(
x=position.x(),
y=position.y(),
z=gpsinfo.elevation,
places=places))
def gps_disconnected(self):
self.gpslabel.setText("GPS: Not Active")
self.gpslabelposition.setText("")
self.gpsMarker.hide()
def zoom_to_feature(self, feature):
"""
Zoom to the given feature in the map.
:param feature:
:return:
"""
box = feature.geometry().boundingBox()
xmin, xmax, ymin, ymax = box.xMinimum(), box.xMaximum(), box.yMinimum(
), box.yMaximum()
xmin -= 5
xmax += 5
ymin -= 5
ymax += 5
box = QgsRectangle(xmin, ymin, xmax, ymax)
self.canvas.setExtent(box)
self.canvas.refresh()
def update_status_label(self, *args) -> None:
"""
Update the status bar labels when the information has changed.
"""
extent = self.canvas.extent()
self.positionlabel.setText("Map Center: {}".format(
extent.center().toString()))
scale = 1.0 / self.canvas.scale()
scale = self.scalewidget.toString(scale)
self.scalebutton.setText(scale)
def refresh_map(self) -> None:
"""
Refresh the map
"""
self.canvas.refresh()
def updatescale(self) -> None:
"""
Update the scale of the map with the current scale from the scale widget
:return:
"""
self.canvas.zoomScale(1.0 / self.scalewidget.scale())
@property
def crs(self) -> QgsCoordinateReferenceSystem:
"""
Get the CRS used that is being used in the canvas
:return: The QgsCoordinateReferenceSystem that is used by the canvas
"""
return self.canvas.mapSettings().destinationCrs()
def feature_form_loaded(self, form, feature, *args):
"""
Called when the feature form is loaded.
:param form: The Form object. Holds a reference to the forms layer.
:param feature: The current capture feature
"""
self.currentfeatureband.setToGeometry(feature.geometry(),
form.QGISLayer)
def highlight_selection(self, results):
"""
Highlight the selection on the canvas. This updates all selected objects based on the result set.
:param results: A dict-of-list of layer-features.
"""
self.clear_selection()
for layer, features in results.items():
band = self.selectionbands[layer]
band.setColor(QColor(255, 0, 0))
band.setIconSize(25)
band.setWidth(5)
band.setBrushStyle(Qt.NoBrush)
band.reset(layer.geometryType())
band.setZValue(self.currentfeatureband.zValue() - 1)
for feature in features:
band.addGeometry(feature.geometry(), layer)
self.canvas.update()
def highlight_active_selection(self, layer, feature, features):
"""
Update the current active selected feature.
:param layer: The layer of the active feature.
:param feature: The active feature.
:param features: The other features in the set to show as non active selection.
:return:
"""
self.clear_selection()
self.highlight_selection({layer: features})
self.currentfeatureband.setToGeometry(feature.geometry(), layer)
self.canvas.update()
def clear_selection(self):
"""
Clear the selection from the canvas. Resets all selection rubber bands.
:return:
"""
# Clear the main selection rubber band
self.canvas.scene().update()
self.currentfeatureband.reset()
# Clear the rest
for band in self.selectionbands.values():
band.reset()
self.canvas.update()
self.editfeaturestack = []
def queue_feature_for_edit(self, form, feature):
"""
Push a feature on the edit stack so the feature can have the geometry edited.
:note: This is a big hack and I don't like it!
:param form: The form for the current feature
:param feature: The active feature.
"""
def trigger_default_action():
for action in self.projecttoolbar.actions():
if action.property('dataentry') and action.isdefault:
action.trigger()
self.canvas.currentLayer().startEditing()
self.canvas.mapTool().setEditMode(True, feature.geometry(),
feature)
break
self.editfeaturestack.append((form, feature))
self.save_current_form()
self.load_form(form)
trigger_default_action()
def save_current_form(self):
self.last_form = self.current_form
def restore_last_form(self):
self.load_form(self.last_form)
def clear_temp_objects(self):
"""
Clear all temp objects from the canvas.
:return:
"""
def clear_tool_band():
"""
Clear the rubber band of the active tool if it has one
"""
tool = self.canvas.mapTool()
if hasattr(tool, "clearBand"):
tool.clearBand()
self.currentfeatureband.reset()
clear_tool_band()
def settings_updated(self, settings):
"""
Called when the settings have been updated in the Roam config.
:param settings: A dict of the settings.
"""
self.actionGPS.updateGPSPort()
gpslogging = settings.get('gpslogging', True)
if self.gpslogging:
self.gpslogging.logging = gpslogging
smallmode = settings.get("smallmode", False)
self.projecttoolbar.setSmallMode(smallmode)
def set_gps(self, gps, logging):
"""
Set the GPS for the map widget. Connects GPS signals
"""
self.gps = gps
self.gpslogging = logging
self.gps.gpsfixed.connect(self.update_gps_fixed_label)
self.gps.gpsposition.connect(self.update_gps_label)
self.gps.gpsposition.connect(self.gps_update_canvas)
self.gps.firstfix.connect(self.gps_first_fix)
self.gps.gpsdisconnected.connect(self.gps_disconnected)
self.gpsMarker.setgps(self.gps)
self.actionGPS.setgps(gps)
def gps_update_canvas(self, position, gpsinfo):
"""
Updates the map canvas based on the GPS position. By default if the GPS is outside the canvas
extent the canvas will move to center on the GPS. Can be turned off in settings.
:param postion: The current GPS position.
:param gpsinfo: The extra GPS information
"""
# Recenter map if we go outside of the 95% of the area
if self.gpslogging.logging:
self.gpsband.addPoint(position)
self.gpsband.show()
if roam.config.settings.get('gpscenter', True):
if not self.lastgpsposition == position:
self.lastgpsposition = position
rect = QgsRectangle(position, position)
extentlimt = QgsRectangle(self.canvas.extent())
extentlimt.scale(0.95)
if not extentlimt.contains(position):
self.zoom_to_location(position)
self.gpsMarker.show()
self.gpsMarker.setCenter(position, gpsinfo)
def gps_first_fix(self, postion, gpsinfo):
"""
Called the first time the GPS gets a fix. If set this will zoom to the GPS after the first fix
:param postion: The current GPS position.
:param gpsinfo: The extra GPS information
"""
zoomtolocation = roam.config.settings.get('gpszoomonfix', True)
if zoomtolocation:
self.canvas.zoomScale(1000)
self.zoom_to_location(postion)
def zoom_to_location(self, position):
"""
Zoom to ta given position on the map..
"""
rect = QgsRectangle(position, position)
self.canvas.setExtent(rect)
self.canvas.refresh()
def select_data_entry(self):
"""
Open the form selection widget to allow the user to pick the active capture form.
"""
def showformerror(form):
pass
def actions():
for form in self.project.forms:
if not self.form_valid_for_capture(form):
continue
action = form.createuiaction()
valid, failreasons = form.valid
if not valid:
roam.utils.warning("Form {} failed to load".format(
form.label))
roam.utils.warning("Reasons {}".format(failreasons))
action.triggered.connect(partial(showformerror, form))
else:
action.triggered.connect(partial(self.load_form, form))
yield action
formpicker = PickActionDialog(msg="Select data entry form", wrap=5)
formpicker.addactions(actions())
formpicker.exec_()
def project_loaded(self, project):
"""
Called when the project is loaded. Main entry point for a loade project.
:param project: The Roam project that has been loaded.
"""
self.snappingutils.setConfig(QgsProject.instance().snappingConfig())
self.project = project
self.actionPan.trigger()
firstform = self.first_capture_form()
if firstform:
self.load_form(firstform)
self.dataentryselection.setVisible(True)
else:
self.dataentryselection.setVisible(False)
# Enable the raster layers button only if the project contains a raster layer.
layers = roam.api.utils.layers()
hasrasters = any(layer.type() == QgsMapLayer.RasterLayer
for layer in layers)
self.actionRaster.setEnabled(hasrasters)
self.defaultextent = self.canvas.extent()
roam.utils.info("Extent: {}".format(self.defaultextent.toString()))
self.infoTool.selectionlayers = project.selectlayersmapping()
self.canvas.refresh()
projectscales, _ = QgsProject.instance().readBoolEntry(
"Scales", "/useProjectScales")
if projectscales:
projectscales, _ = QgsProject.instance().readListEntry(
"Scales", "/ScalesList")
self.scalewidget.updateScales(projectscales)
else:
scales = [
"1:50000", "1:25000", "1:10000", "1:5000", "1:2500", "1:1000",
"1:500", "1:250", "1:200", "1:100"
]
scales = roam.config.settings.get('scales', scales)
self.scalewidget.updateScales(scales)
if self.scalebar_enabled:
self.scalebar.update()
red = QgsProject.instance().readNumEntry("Gui", "/CanvasColorRedPart",
255)[0]
green = QgsProject.instance().readNumEntry("Gui",
"/CanvasColorGreenPart",
255)[0]
blue = QgsProject.instance().readNumEntry("Gui",
"/CanvasColorBluePart",
255)[0]
myColor = QColor(red, green, blue)
self.canvas.setCanvasColor(myColor)
self.actionPan.toggle()
self.clear_plugins()
self.add_plugins(project.enabled_plugins)
def setMapTool(self, tool, *args):
"""
Set the active map tool in the canvas.
:param tool: The QgsMapTool to set.
"""
if tool == self.canvas.mapTool():
return
if hasattr(tool, "setSnapping"):
tool.setSnapping(self.snapping)
self.canvas.setMapTool(tool)
def connectButtons(self):
"""
Connect the default buttons in the interface. Zoom, pan, etc
"""
def connectAction(action, tool):
action.toggled.connect(partial(self.setMapTool, tool))
def cursor(name):
pix = QPixmap(name)
pix = pix.scaled(QSize(24, 24))
return QCursor(pix)
self.zoomInTool = QgsMapToolZoom(self.canvas, False)
self.zoomOutTool = QgsMapToolZoom(self.canvas, True)
self.panTool = QgsMapToolPan(self.canvas)
self.infoTool = InfoTool(self.canvas)
self.infoTool.setAction(self.actionInfo)
self.zoomInTool.setAction(self.actionZoom_In)
self.zoomOutTool.setAction(self.actionZoom_Out)
self.panTool.setAction(self.actionPan)
connectAction(self.actionZoom_In, self.zoomInTool)
connectAction(self.actionZoom_Out, self.zoomOutTool)
connectAction(self.actionPan, self.panTool)
connectAction(self.actionInfo, self.infoTool)
self.zoomInTool.setCursor(cursor(':/icons/in'))
self.zoomOutTool.setCursor(cursor(':/icons/out'))
self.infoTool.setCursor(cursor(':/icons/select'))
self.actionRaster.triggered.connect(self.toggle_raster_layers)
self.actionHome.triggered.connect(self.homeview)
def homeview(self):
"""
Zoom the mapview canvas to the extents the project was opened at i.e. the
default extent.
"""
if self.defaultextent:
self.canvas.setExtent(self.defaultextent)
self.canvas.refresh()
def form_valid_for_capture(self, form):
"""
Check if the given form is valid for capture.
:param form: The form to check.
:return: True if valid form for capture
"""
return form.has_geometry and self.project.layer_can_capture(
form.QGISLayer)
def first_capture_form(self):
"""
Return the first valid form for capture.
"""
for form in self.project.forms:
if self.form_valid_for_capture(form):
return form
def load_form(self, form):
"""
Load the given form so it's the active one for capture
:param form: The form to load
"""
self.clear_capture_tools()
self.dataentryselection.setIcon(QIcon(form.icon))
self.dataentryselection.setText(form.icontext)
self.create_capture_buttons(form)
self.current_form = form
def create_capture_buttons(self, form):
"""
Create the capture buttons in the toolbar for the given form.
:param form: The active form.
"""
tool = form.getMaptool()(self.canvas, form.settings)
for action in tool.actions:
# Create the action here.
if action.ismaptool:
action.toggled.connect(partial(self.setMapTool, tool))
# Set the action as a data entry button so we can remove it later.
action.setProperty("dataentry", True)
self.editgroup.addAction(action)
self.layerbuttons.append(action)
self.projecttoolbar.insertAction(self.topspaceraction, action)
action.setChecked(action.isdefault)
if hasattr(tool, 'geometryComplete'):
add = partial(self.add_new_feature, form)
tool.geometryComplete.connect(add)
else:
tool.finished.connect(self.openForm)
tool.error.connect(self.show_invalid_geometry_message)
def show_invalid_geometry_message(self, message) -> None:
"""
Shows the message to the user if the there is a invalid geometry capture.
:param message: The message to show the user.
"""
RoamEvents.raisemessage("Invalid geometry capture",
message,
level=RoamEvents.CRITICAL)
if self.canvas.currentLayer() is not None:
self.canvas.currentLayer().rollBack()
RoamEvents.editgeometry_invalid.emit()
def add_new_feature(self, form, geometry: QgsGeometry):
"""
Add a new new feature to the given layer
:param form: The form to use for the new feature.
:param geometry: The new geometry to create the feature for.
"""
# NOTE This function is doing too much, acts as add and also edit.
layer = form.QGISLayer
if geometry.isMultipart():
geometry.convertToMultiType()
# Transform the new geometry back into the map layers geometry if it's needed
transform = self.canvas.mapSettings().layerTransform(layer)
if transform.isValid():
geometry.transform(transform,
QgsCoordinateTransform.ReverseTransform)
try:
form, feature = self.editfeaturestack.pop()
self.editfeaturegeometry(form, feature, newgeometry=geometry)
return
except IndexError:
pass
feature = form.new_feature(geometry=geometry)
RoamEvents.load_feature_form(form, feature, editmode=False)
def editfeaturegeometry(self, form, feature, newgeometry):
# TODO Extract into function.
layer = form.QGISLayer
layer.startEditing()
feature.setGeometry(newgeometry)
layer.updateFeature(feature)
saved = layer.commitChanges()
if not saved:
map(roam.utils.error, layer.commitErrors())
self.canvas.refresh()
self.currentfeatureband.setToGeometry(feature.geometry(), layer)
RoamEvents.editgeometry_complete.emit(form, feature)
self.canvas.mapTool().setEditMode(False, None, None)
self.restore_last_form()
def clear_capture_tools(self):
"""
Clear the capture tools from the toolbar.
:return: True if the capture button was active at the time of clearing.
"""
captureselected = False
for action in self.projecttoolbar.actions():
if action.objectName() == "capture" and action.isChecked():
captureselected = True
if action.property('dataentry'):
self.projecttoolbar.removeAction(action)
return captureselected
def toggle_raster_layers(self) -> None:
"""
Toggle all raster layers on or off.
"""
# Freeze the canvas to save on UI refresh
dlg = PickActionDialog(msg="Raster visibility")
actions = [
(":/icons/raster_0", "Off", partial(self._set_basemaps_opacity,
0), "photo_off"),
(":/icons/raster_25", "25%",
partial(self._set_basemaps_opacity, .25), "photo_25"),
(":/icons/raster_50", "50%",
partial(self._set_basemaps_opacity, .50), "photo_50"),
(":/icons/raster_75", "75%",
partial(self._set_basemaps_opacity, .75), "photo_75"),
(":/icons/raster_100", "100%",
partial(self._set_basemaps_opacity, 1), "photo_100"),
]
# ":/icons/raster_100"), "100%", self, triggered=partial(self._set_raster_layer_value, 1),
# objectName="photo_100")
dialog_actions = []
for action in actions:
icon = QIcon(action[0])
qaction = QAction(icon,
action[1],
self,
triggered=action[2],
objectName=action[3])
dialog_actions.append(qaction)
dlg.addactions(dialog_actions)
dlg.exec_()
def _set_basemaps_opacity(self, value=0) -> None:
"""
Set the opacity for all basemap raster layers.
:param value: The opacity value betwen 0 and 1
"""
tree = QgsProject.instance().layerTreeRoot()
for node in tree.findLayers():
layer = node.layer()
if node.layer().type() == QgsMapLayer.RasterLayer:
if value > 0:
node.setItemVisibilityChecked(Qt.Checked)
renderer = layer.renderer()
renderer.setOpacity(value)
if value == 0:
node.setItemVisibilityChecked(Qt.Unchecked)
self.canvas.refresh()
def cleanup(self):
"""
Clean up when the project has changed.
:return:
"""
# TODO Review cleanup
# self.bridge.clear()
self.gpsband.reset()
self.gpsband.hide()
self.clear_selection()
self.clear_temp_objects()
self.clear_capture_tools()
for action in self.layerbuttons:
self.editgroup.removeAction(action)
class PythonConsoleWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle(
QCoreApplication.translate("PythonConsole", "Python Console"))
self.settings = QgsSettings()
self.shell = ShellScintilla(self)
self.setFocusProxy(self.shell)
self.shellOut = ShellOutputScintilla(self)
self.tabEditorWidget = EditorTabWidget(self)
# ------------ UI -------------------------------
self.splitterEditor = QSplitter(self)
self.splitterEditor.setOrientation(Qt.Horizontal)
self.splitterEditor.setHandleWidth(6)
self.splitterEditor.setChildrenCollapsible(True)
self.shellOutWidget = QWidget(self)
self.shellOutWidget.setLayout(QVBoxLayout())
self.shellOutWidget.layout().setContentsMargins(0, 0, 0, 0)
self.shellOutWidget.layout().addWidget(self.shellOut)
self.splitter = QSplitter(self.splitterEditor)
self.splitter.setOrientation(Qt.Vertical)
self.splitter.setHandleWidth(3)
self.splitter.setChildrenCollapsible(False)
self.splitter.addWidget(self.shellOutWidget)
self.splitter.addWidget(self.shell)
# self.splitterEditor.addWidget(self.tabEditorWidget)
self.splitterObj = QSplitter(self.splitterEditor)
self.splitterObj.setHandleWidth(3)
self.splitterObj.setOrientation(Qt.Horizontal)
# self.splitterObj.setSizes([0, 0])
# self.splitterObj.setStretchFactor(0, 1)
self.widgetEditor = QWidget(self.splitterObj)
self.widgetFind = QWidget(self)
self.listClassMethod = QTreeWidget(self.splitterObj)
self.listClassMethod.setColumnCount(2)
objInspLabel = QCoreApplication.translate("PythonConsole",
"Object Inspector")
self.listClassMethod.setHeaderLabels([objInspLabel, ''])
self.listClassMethod.setColumnHidden(1, True)
self.listClassMethod.setAlternatingRowColors(True)
# self.splitterEditor.addWidget(self.widgetEditor)
# self.splitterObj.addWidget(self.listClassMethod)
# self.splitterObj.addWidget(self.widgetEditor)
# Hide side editor on start up
self.splitterObj.hide()
self.listClassMethod.hide()
# Hide search widget on start up
self.widgetFind.hide()
icon_size = iface.iconSize(
dockedToolbar=True) if iface else QSize(16, 16)
sizes = self.splitter.sizes()
self.splitter.setSizes(sizes)
# ----------------Restore Settings------------------------------------
self.restoreSettingsConsole()
# ------------------Toolbar Editor-------------------------------------
# Action for Open File
openFileBt = QCoreApplication.translate("PythonConsole",
"Open Script...")
self.openFileButton = QAction(self)
self.openFileButton.setCheckable(False)
self.openFileButton.setEnabled(True)
self.openFileButton.setIcon(
QgsApplication.getThemeIcon("console/iconOpenConsole.png"))
self.openFileButton.setMenuRole(QAction.PreferencesRole)
self.openFileButton.setIconVisibleInMenu(True)
self.openFileButton.setToolTip(openFileBt)
self.openFileButton.setText(openFileBt)
openExtEditorBt = QCoreApplication.translate(
"PythonConsole", "Open in External Editor")
self.openInEditorButton = QAction(self)
self.openInEditorButton.setCheckable(False)
self.openInEditorButton.setEnabled(True)
self.openInEditorButton.setIcon(
QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.openInEditorButton.setMenuRole(QAction.PreferencesRole)
self.openInEditorButton.setIconVisibleInMenu(True)
self.openInEditorButton.setToolTip(openExtEditorBt)
self.openInEditorButton.setText(openExtEditorBt)
# Action for Save File
saveFileBt = QCoreApplication.translate("PythonConsole", "Save")
self.saveFileButton = QAction(self)
self.saveFileButton.setCheckable(False)
self.saveFileButton.setEnabled(False)
self.saveFileButton.setIcon(
QgsApplication.getThemeIcon("console/iconSaveConsole.png"))
self.saveFileButton.setMenuRole(QAction.PreferencesRole)
self.saveFileButton.setIconVisibleInMenu(True)
self.saveFileButton.setToolTip(saveFileBt)
self.saveFileButton.setText(saveFileBt)
# Action for Save File As
saveAsFileBt = QCoreApplication.translate("PythonConsole",
"Save As...")
self.saveAsFileButton = QAction(self)
self.saveAsFileButton.setCheckable(False)
self.saveAsFileButton.setEnabled(True)
self.saveAsFileButton.setIcon(
QgsApplication.getThemeIcon("console/iconSaveAsConsole.png"))
self.saveAsFileButton.setMenuRole(QAction.PreferencesRole)
self.saveAsFileButton.setIconVisibleInMenu(True)
self.saveAsFileButton.setToolTip(saveAsFileBt)
self.saveAsFileButton.setText(saveAsFileBt)
# Action Cut
cutEditorBt = QCoreApplication.translate("PythonConsole", "Cut")
self.cutEditorButton = QAction(self)
self.cutEditorButton.setCheckable(False)
self.cutEditorButton.setEnabled(True)
self.cutEditorButton.setIcon(
QgsApplication.getThemeIcon("mActionEditCut.svg"))
self.cutEditorButton.setMenuRole(QAction.PreferencesRole)
self.cutEditorButton.setIconVisibleInMenu(True)
self.cutEditorButton.setToolTip(cutEditorBt)
self.cutEditorButton.setText(cutEditorBt)
# Action Copy
copyEditorBt = QCoreApplication.translate("PythonConsole", "Copy")
self.copyEditorButton = QAction(self)
self.copyEditorButton.setCheckable(False)
self.copyEditorButton.setEnabled(True)
self.copyEditorButton.setIcon(
QgsApplication.getThemeIcon("mActionEditCopy.svg"))
self.copyEditorButton.setMenuRole(QAction.PreferencesRole)
self.copyEditorButton.setIconVisibleInMenu(True)
self.copyEditorButton.setToolTip(copyEditorBt)
self.copyEditorButton.setText(copyEditorBt)
# Action Paste
pasteEditorBt = QCoreApplication.translate("PythonConsole", "Paste")
self.pasteEditorButton = QAction(self)
self.pasteEditorButton.setCheckable(False)
self.pasteEditorButton.setEnabled(True)
self.pasteEditorButton.setIcon(
QgsApplication.getThemeIcon("mActionEditPaste.svg"))
self.pasteEditorButton.setMenuRole(QAction.PreferencesRole)
self.pasteEditorButton.setIconVisibleInMenu(True)
self.pasteEditorButton.setToolTip(pasteEditorBt)
self.pasteEditorButton.setText(pasteEditorBt)
# Action Run Script (subprocess)
runScriptEditorBt = QCoreApplication.translate("PythonConsole",
"Run script")
self.runScriptEditorButton = QAction(self)
self.runScriptEditorButton.setCheckable(False)
self.runScriptEditorButton.setEnabled(True)
self.runScriptEditorButton.setIcon(
QgsApplication.getThemeIcon("console/iconRunScriptConsole.png"))
self.runScriptEditorButton.setMenuRole(QAction.PreferencesRole)
self.runScriptEditorButton.setIconVisibleInMenu(True)
self.runScriptEditorButton.setToolTip(runScriptEditorBt)
self.runScriptEditorButton.setText(runScriptEditorBt)
# Action Run Script (subprocess)
commentEditorBt = QCoreApplication.translate("PythonConsole",
"Comment")
self.commentEditorButton = QAction(self)
self.commentEditorButton.setCheckable(False)
self.commentEditorButton.setEnabled(True)
self.commentEditorButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconCommentEditorConsole.png"))
self.commentEditorButton.setMenuRole(QAction.PreferencesRole)
self.commentEditorButton.setIconVisibleInMenu(True)
self.commentEditorButton.setToolTip(commentEditorBt)
self.commentEditorButton.setText(commentEditorBt)
# Action Run Script (subprocess)
uncommentEditorBt = QCoreApplication.translate("PythonConsole",
"Uncomment")
self.uncommentEditorButton = QAction(self)
self.uncommentEditorButton.setCheckable(False)
self.uncommentEditorButton.setEnabled(True)
self.uncommentEditorButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconUncommentEditorConsole.png"))
self.uncommentEditorButton.setMenuRole(QAction.PreferencesRole)
self.uncommentEditorButton.setIconVisibleInMenu(True)
self.uncommentEditorButton.setToolTip(uncommentEditorBt)
self.uncommentEditorButton.setText(uncommentEditorBt)
# Action for Object browser
objList = QCoreApplication.translate("PythonConsole",
"Object Inspector...")
self.objectListButton = QAction(self)
self.objectListButton.setCheckable(True)
self.objectListButton.setEnabled(
self.settings.value("pythonConsole/enableObjectInsp",
False,
type=bool))
self.objectListButton.setIcon(
QgsApplication.getThemeIcon("console/iconClassBrowserConsole.png"))
self.objectListButton.setMenuRole(QAction.PreferencesRole)
self.objectListButton.setIconVisibleInMenu(True)
self.objectListButton.setToolTip(objList)
self.objectListButton.setText(objList)
# Action for Find text
findText = QCoreApplication.translate("PythonConsole", "Find Text")
self.findTextButton = QAction(self)
self.findTextButton.setCheckable(True)
self.findTextButton.setEnabled(True)
self.findTextButton.setIcon(
QgsApplication.getThemeIcon("console/iconSearchEditorConsole.png"))
self.findTextButton.setMenuRole(QAction.PreferencesRole)
self.findTextButton.setIconVisibleInMenu(True)
self.findTextButton.setToolTip(findText)
self.findTextButton.setText(findText)
# ----------------Toolbar Console-------------------------------------
# Action Show Editor
showEditor = QCoreApplication.translate("PythonConsole", "Show Editor")
self.showEditorButton = QAction(self)
self.showEditorButton.setEnabled(True)
self.showEditorButton.setCheckable(True)
self.showEditorButton.setIcon(
QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.showEditorButton.setMenuRole(QAction.PreferencesRole)
self.showEditorButton.setIconVisibleInMenu(True)
self.showEditorButton.setToolTip(showEditor)
self.showEditorButton.setText(showEditor)
# Action for Clear button
clearBt = QCoreApplication.translate("PythonConsole", "Clear Console")
self.clearButton = QAction(self)
self.clearButton.setCheckable(False)
self.clearButton.setEnabled(True)
self.clearButton.setIcon(
QgsApplication.getThemeIcon("console/iconClearConsole.png"))
self.clearButton.setMenuRole(QAction.PreferencesRole)
self.clearButton.setIconVisibleInMenu(True)
self.clearButton.setToolTip(clearBt)
self.clearButton.setText(clearBt)
# Action for settings
optionsBt = QCoreApplication.translate("PythonConsole", "Options...")
self.optionsButton = QAction(self)
self.optionsButton.setCheckable(False)
self.optionsButton.setEnabled(True)
self.optionsButton.setIcon(
QgsApplication.getThemeIcon("console/iconSettingsConsole.png"))
self.optionsButton.setMenuRole(QAction.PreferencesRole)
self.optionsButton.setIconVisibleInMenu(True)
self.optionsButton.setToolTip(optionsBt)
self.optionsButton.setText(optionsBt)
# Action for Run script
runBt = QCoreApplication.translate("PythonConsole", "Run Command")
self.runButton = QAction(self)
self.runButton.setCheckable(False)
self.runButton.setEnabled(True)
self.runButton.setIcon(
QgsApplication.getThemeIcon("console/iconRunConsole.png"))
self.runButton.setMenuRole(QAction.PreferencesRole)
self.runButton.setIconVisibleInMenu(True)
self.runButton.setToolTip(runBt)
self.runButton.setText(runBt)
# Help action
helpBt = QCoreApplication.translate("PythonConsole", "Help...")
self.helpButton = QAction(self)
self.helpButton.setCheckable(False)
self.helpButton.setEnabled(True)
self.helpButton.setIcon(
QgsApplication.getThemeIcon("console/iconHelpConsole.png"))
self.helpButton.setMenuRole(QAction.PreferencesRole)
self.helpButton.setIconVisibleInMenu(True)
self.helpButton.setToolTip(helpBt)
self.helpButton.setText(helpBt)
self.toolBar = QToolBar()
self.toolBar.setEnabled(True)
self.toolBar.setFocusPolicy(Qt.NoFocus)
self.toolBar.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBar.setLayoutDirection(Qt.LeftToRight)
self.toolBar.setIconSize(icon_size)
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
self.toolBar.addAction(self.clearButton)
self.toolBar.addAction(self.runButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.showEditorButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.optionsButton)
self.toolBar.addAction(self.helpButton)
self.toolBarEditor = QToolBar()
self.toolBarEditor.setEnabled(False)
self.toolBarEditor.setFocusPolicy(Qt.NoFocus)
self.toolBarEditor.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBarEditor.setLayoutDirection(Qt.LeftToRight)
self.toolBarEditor.setIconSize(icon_size)
self.toolBarEditor.setMovable(False)
self.toolBarEditor.setFloatable(False)
self.toolBarEditor.addAction(self.openFileButton)
self.toolBarEditor.addAction(self.openInEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.saveFileButton)
self.toolBarEditor.addAction(self.saveAsFileButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.runScriptEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.findTextButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.cutEditorButton)
self.toolBarEditor.addAction(self.copyEditorButton)
self.toolBarEditor.addAction(self.pasteEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.commentEditorButton)
self.toolBarEditor.addAction(self.uncommentEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.objectListButton)
self.widgetButton = QWidget()
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widgetButton.sizePolicy().hasHeightForWidth())
self.widgetButton.setSizePolicy(sizePolicy)
self.widgetButtonEditor = QWidget(self.widgetEditor)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widgetButtonEditor.sizePolicy().hasHeightForWidth())
self.widgetButtonEditor.setSizePolicy(sizePolicy)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.shellOut.sizePolicy().hasHeightForWidth())
self.shellOut.setSizePolicy(sizePolicy)
self.shellOut.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.shell.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
# ------------ Layout -------------------------------
self.mainLayout = QGridLayout(self)
self.mainLayout.setMargin(0)
self.mainLayout.setSpacing(0)
self.mainLayout.addWidget(self.widgetButton, 0, 0, 1, 1)
self.mainLayout.addWidget(self.splitterEditor, 0, 1, 1, 1)
self.shellOutWidget.layout().insertWidget(0, self.toolBar)
self.layoutEditor = QGridLayout(self.widgetEditor)
self.layoutEditor.setMargin(0)
self.layoutEditor.setSpacing(0)
self.layoutEditor.addWidget(self.toolBarEditor, 0, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetButtonEditor, 1, 0, 2, 1)
self.layoutEditor.addWidget(self.tabEditorWidget, 1, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetFind, 2, 1, 1, 1)
# Layout for the find widget
self.layoutFind = QGridLayout(self.widgetFind)
self.layoutFind.setContentsMargins(0, 0, 0, 0)
self.lineEditFind = QgsFilterLineEdit()
placeHolderTxt = QCoreApplication.translate("PythonConsole",
"Enter text to find...")
self.lineEditFind.setPlaceholderText(placeHolderTxt)
self.findNextButton = QToolButton()
self.findNextButton.setEnabled(False)
toolTipfindNext = QCoreApplication.translate("PythonConsole",
"Find Next")
self.findNextButton.setToolTip(toolTipfindNext)
self.findNextButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconSearchNextEditorConsole.png"))
self.findNextButton.setIconSize(QSize(24, 24))
self.findNextButton.setAutoRaise(True)
self.findPrevButton = QToolButton()
self.findPrevButton.setEnabled(False)
toolTipfindPrev = QCoreApplication.translate("PythonConsole",
"Find Previous")
self.findPrevButton.setToolTip(toolTipfindPrev)
self.findPrevButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconSearchPrevEditorConsole.png"))
self.findPrevButton.setIconSize(QSize(24, 24))
self.findPrevButton.setAutoRaise(True)
self.caseSensitive = QCheckBox()
caseSensTr = QCoreApplication.translate("PythonConsole",
"Case Sensitive")
self.caseSensitive.setText(caseSensTr)
self.wholeWord = QCheckBox()
wholeWordTr = QCoreApplication.translate("PythonConsole", "Whole Word")
self.wholeWord.setText(wholeWordTr)
self.wrapAround = QCheckBox()
self.wrapAround.setChecked(True)
wrapAroundTr = QCoreApplication.translate("PythonConsole",
"Wrap Around")
self.wrapAround.setText(wrapAroundTr)
self.layoutFind.addWidget(self.lineEditFind, 0, 1, 1, 1)
self.layoutFind.addWidget(self.findPrevButton, 0, 2, 1, 1)
self.layoutFind.addWidget(self.findNextButton, 0, 3, 1, 1)
self.layoutFind.addWidget(self.caseSensitive, 0, 4, 1, 1)
self.layoutFind.addWidget(self.wholeWord, 0, 5, 1, 1)
self.layoutFind.addWidget(self.wrapAround, 0, 6, 1, 1)
# ------------ Add first Tab in Editor -------------------------------
# self.tabEditorWidget.newTabEditor(tabName='first', filename=None)
# ------------ Signal -------------------------------
self.findTextButton.triggered.connect(self._toggleFind)
self.objectListButton.toggled.connect(self.toggleObjectListWidget)
self.commentEditorButton.triggered.connect(self.commentCode)
self.uncommentEditorButton.triggered.connect(self.uncommentCode)
self.runScriptEditorButton.triggered.connect(self.runScriptEditor)
self.cutEditorButton.triggered.connect(self.cutEditor)
self.copyEditorButton.triggered.connect(self.copyEditor)
self.pasteEditorButton.triggered.connect(self.pasteEditor)
self.showEditorButton.toggled.connect(self.toggleEditor)
self.clearButton.triggered.connect(self.shellOut.clearConsole)
self.optionsButton.triggered.connect(self.openSettings)
self.runButton.triggered.connect(self.shell.entered)
self.openFileButton.triggered.connect(self.openScriptFile)
self.openInEditorButton.triggered.connect(self.openScriptFileExtEditor)
self.saveFileButton.triggered.connect(self.saveScriptFile)
self.saveAsFileButton.triggered.connect(self.saveAsScriptFile)
self.helpButton.triggered.connect(self.openHelp)
self.listClassMethod.itemClicked.connect(self.onClickGoToLine)
self.lineEditFind.returnPressed.connect(self._findNext)
self.findNextButton.clicked.connect(self._findNext)
self.findPrevButton.clicked.connect(self._findPrev)
self.lineEditFind.textChanged.connect(self._textFindChanged)
self.findScut = QShortcut(QKeySequence.Find, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._openFind)
self.findNextScut = QShortcut(QKeySequence.FindNext, self.widgetEditor)
self.findNextScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findNextScut.activated.connect(self._findNext)
self.findPreviousScut = QShortcut(QKeySequence.FindPrevious,
self.widgetEditor)
self.findPreviousScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findPreviousScut.activated.connect(self._findPrev)
# Escape on editor hides the find bar
self.findScut = QShortcut(Qt.Key_Escape, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._closeFind)
def _toggleFind(self):
self.tabEditorWidget.currentWidget().newEditor.toggleFindWidget()
def _openFind(self):
self.tabEditorWidget.currentWidget().newEditor.openFindWidget()
def _closeFind(self):
self.tabEditorWidget.currentWidget().newEditor.closeFindWidget()
def _findNext(self):
self.tabEditorWidget.currentWidget().newEditor.findText(True)
def _findPrev(self):
self.tabEditorWidget.currentWidget().newEditor.findText(False)
def _textFindChanged(self):
if self.lineEditFind.text():
self.findNextButton.setEnabled(True)
self.findPrevButton.setEnabled(True)
self.tabEditorWidget.currentWidget().newEditor.findText(
True, showMessage=False, findFirst=True)
else:
self.lineEditFind.setStyleSheet('')
self.findNextButton.setEnabled(False)
self.findPrevButton.setEnabled(False)
def onClickGoToLine(self, item, column):
tabEditor = self.tabEditorWidget.currentWidget().newEditor
if item.text(1) == 'syntaxError':
check = tabEditor.syntaxCheck(fromContextMenu=False)
if check and not tabEditor.isReadOnly():
self.tabEditorWidget.currentWidget().save()
return
linenr = int(item.text(1))
itemName = str(item.text(0))
charPos = itemName.find(' ')
if charPos != -1:
objName = itemName[0:charPos]
else:
objName = itemName
tabEditor.goToLine(objName, linenr)
def toggleEditor(self, checked):
self.splitterObj.show() if checked else self.splitterObj.hide()
if not self.tabEditorWidget:
self.tabEditorWidget.enableToolBarEditor(checked)
self.tabEditorWidget.restoreTabsOrAddNew()
def toggleObjectListWidget(self, checked):
self.listClassMethod.show() if checked else self.listClassMethod.hide()
def pasteEditor(self):
self.tabEditorWidget.currentWidget().newEditor.paste()
def cutEditor(self):
self.tabEditorWidget.currentWidget().newEditor.cut()
def copyEditor(self):
self.tabEditorWidget.currentWidget().newEditor.copy()
def runScriptEditor(self):
self.tabEditorWidget.currentWidget().newEditor.runScriptCode()
def commentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(True)
def uncommentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(False)
def openScriptFileExtEditor(self):
tabWidget = self.tabEditorWidget.currentWidget()
path = tabWidget.path
import subprocess
try:
subprocess.Popen([os.environ['EDITOR'], path])
except KeyError:
QDesktopServices.openUrl(QUrl.fromLocalFile(path))
def openScriptFile(self):
lastDirPath = self.settings.value("pythonConsole/lastDirPath",
QDir.homePath())
openFileTr = QCoreApplication.translate("PythonConsole", "Open File")
fileList, selected_filter = QFileDialog.getOpenFileNames(
self, openFileTr, lastDirPath, "Script file (*.py)")
if fileList:
for pyFile in fileList:
for i in range(self.tabEditorWidget.count()):
tabWidget = self.tabEditorWidget.widget(i)
if tabWidget.path == pyFile:
self.tabEditorWidget.setCurrentWidget(tabWidget)
break
else:
tabName = QFileInfo(pyFile).fileName()
self.tabEditorWidget.newTabEditor(tabName, pyFile)
lastDirPath = QFileInfo(pyFile).path()
self.settings.setValue("pythonConsole/lastDirPath", pyFile)
self.updateTabListScript(pyFile, action='append')
def saveScriptFile(self):
tabWidget = self.tabEditorWidget.currentWidget()
try:
tabWidget.save()
except (IOError, OSError) as error:
msgText = QCoreApplication.translate(
'PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}').format(
tabWidget.path, error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
def saveAsScriptFile(self, index=None):
tabWidget = self.tabEditorWidget.currentWidget()
if not index:
index = self.tabEditorWidget.currentIndex()
if not tabWidget.path:
fileName = self.tabEditorWidget.tabText(index) + '.py'
folder = self.settings.value("pythonConsole/lastDirPath",
QDir.home())
pathFileName = os.path.join(folder, fileName)
fileNone = True
else:
pathFileName = tabWidget.path
fileNone = False
saveAsFileTr = QCoreApplication.translate("PythonConsole",
"Save File As")
filename, filter = QFileDialog.getSaveFileName(self, saveAsFileTr,
pathFileName,
"Script file (*.py)")
if filename:
try:
tabWidget.save(filename)
except (IOError, OSError) as error:
msgText = QCoreApplication.translate(
'PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}'
).format(tabWidget.path, error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
if fileNone:
tabWidget.path = None
else:
tabWidget.path = pathFileName
return
if not fileNone:
self.updateTabListScript(pathFileName, action='remove')
def openHelp(self):
QgsHelp.openHelp("plugins/python_console.html")
def openSettings(self):
if optionsDialog(self).exec_():
self.shell.refreshSettingsShell()
self.shellOut.refreshSettingsOutput()
self.tabEditorWidget.refreshSettingsEditor()
def callWidgetMessageBar(self, text):
self.shellOut.widgetMessageBar(iface, text)
def callWidgetMessageBarEditor(self, text, level, timed):
self.tabEditorWidget.widgetMessageBar(iface, text, level, timed)
def updateTabListScript(self, script, action=None):
if action == 'remove':
self.tabListScript.remove(script)
elif action == 'append':
if not self.tabListScript:
self.tabListScript = []
if script not in self.tabListScript:
self.tabListScript.append(script)
else:
self.tabListScript = []
self.settings.setValue("pythonConsole/tabScripts", self.tabListScript)
def saveSettingsConsole(self):
self.settings.setValue("pythonConsole/splitterConsole",
self.splitter.saveState())
self.settings.setValue("pythonConsole/splitterObj",
self.splitterObj.saveState())
self.settings.setValue("pythonConsole/splitterEditor",
self.splitterEditor.saveState())
self.shell.writeHistoryFile(True)
def restoreSettingsConsole(self):
storedTabScripts = self.settings.value("pythonConsole/tabScripts", [])
self.tabListScript = storedTabScripts
self.splitter.restoreState(
self.settings.value("pythonConsole/splitterConsole", QByteArray()))
self.splitterEditor.restoreState(
self.settings.value("pythonConsole/splitterEditor", QByteArray()))
self.splitterObj.restoreState(
self.settings.value("pythonConsole/splitterObj", QByteArray()))
class QConsolidatePlugin:
def __init__(self, iface):
self.iface = iface
locale = QgsApplication.locale()
qmPath = '{}/i18n/qconsolidate_{}.qm'.format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
self.actionRun = QAction(self.tr('QConsolidate'),
self.iface.mainWindow())
self.actionRun.setIcon(
QIcon(os.path.join(pluginPath, 'icons', 'qconsolidate.svg')))
self.actionRun.setObjectName('runQConsolidate')
self.actionAbout = QAction(self.tr('About QConsolidate...'),
self.iface.mainWindow())
self.actionAbout.setIcon(
QgsApplication.getThemeIcon('/mActionHelpContents.svg'))
self.actionRun.setObjectName('aboutQConsolidate')
self.iface.addPluginToMenu(self.tr('QConsolidate'), self.actionRun)
self.iface.addPluginToMenu(self.tr('QConsolidate'), self.actionAbout)
self.iface.addToolBarIcon(self.actionRun)
self.actionRun.triggered.connect(self.run)
self.actionAbout.triggered.connect(self.about)
self.taskManager = QgsApplication.taskManager()
def unload(self):
self.iface.removePluginMenu(self.tr('QConsolidate'), self.actionRun)
self.iface.removePluginMenu(self.tr('QConsolidate'), self.actionAbout)
self.iface.removeToolBarIcon(self.actionRun)
def run(self):
dlg = QConsolidateDialog()
if dlg.exec_():
task = dlg.task()
task.consolidateComplete.connect(self.completed)
task.errorOccurred.connect(self.errored)
self.taskManager.addTask(task)
def about(self):
d = AboutDialog()
d.exec_()
def tr(self, text):
return QCoreApplication.translate('QConsolidatePlugin', text)
def completed(self):
self.iface.messageBar().pushSuccess(
self.tr('QConsolidate'),
self.tr('Project consolidated successfully.'))
def errored(self, error):
self.iface.messageBar().pushWarning(self.tr('QConsolidate'), error)
def createMenu(self):
self.menu.clear()
self.menu.setMinimumWidth(self.width())
fill_down_action = QAction(self.tr('Fill Down'), self.menu)
fill_down_action.triggered.connect(self.fillDown)
fill_down_action.setToolTip(
self.tr('Copy the first value down to all other rows'))
self.menu.addAction(fill_down_action)
calculate_by_expression = QAction(
QCoreApplication.translate('BatchPanel',
'Calculate by Expression…'), self.menu)
calculate_by_expression.setIcon(
QgsApplication.getThemeIcon('/mActionCalculateField.svg'))
calculate_by_expression.triggered.connect(self.calculateByExpression)
calculate_by_expression.setToolTip(
self.tr('Calculates parameter values by evaluating an expression'))
self.menu.addAction(calculate_by_expression)
add_by_expression = QAction(
QCoreApplication.translate('BatchPanel',
'Add Values by Expression…'), self.menu)
add_by_expression.triggered.connect(self.addByExpression)
add_by_expression.setToolTip(
self.tr('Adds new parameter values by evaluating an expression'))
self.menu.addAction(add_by_expression)
if not self.parameterDefinition.isDestination() and isinstance(
self.parameterDefinition, QgsFileFilterGenerator):
self.menu.addSeparator()
find_by_pattern_action = QAction(
QCoreApplication.translate('BatchPanel',
'Add Files by Pattern…'), self.menu)
find_by_pattern_action.triggered.connect(self.addFilesByPattern)
find_by_pattern_action.setToolTip(
self.tr('Adds files by a file pattern match'))
self.menu.addAction(find_by_pattern_action)
select_file_action = QAction(
QCoreApplication.translate('BatchInputSelectionPanel',
'Select Files…'), self.menu)
select_file_action.triggered.connect(self.showFileSelectionDialog)
self.menu.addAction(select_file_action)
select_directory_action = QAction(
QCoreApplication.translate('BatchInputSelectionPanel',
'Add All Files from a Directory…'),
self.menu)
select_directory_action.triggered.connect(
self.showDirectorySelectionDialog)
self.menu.addAction(select_directory_action)
if not isinstance(self.parameterDefinition,
QgsProcessingParameterFile):
select_layer_action = QAction(
QCoreApplication.translate('BatchInputSelectionPanel',
'Select from Open Layers…'),
self.menu)
select_layer_action.triggered.connect(
self.showLayerSelectionDialog)
self.menu.addAction(select_layer_action)
class ProcessingPlugin(QObject):
def __init__(self, iface):
super().__init__()
self.iface = iface
self.options_factory = None
self.drop_handler = None
self.item_provider = None
self.locator_filter = None
self.edit_features_locator_filter = None
self.initialized = False
self.initProcessing()
def initProcessing(self):
if not self.initialized:
self.initialized = True
Processing.initialize()
def initGui(self):
# port old log, ONCE ONLY!
settings = QgsSettings()
if not settings.value("/Processing/hasPortedOldLog", False, bool):
processing_history_provider = QgsGui.historyProviderRegistry().providerById('processing')
if processing_history_provider:
processing_history_provider.portOldLog()
settings.setValue("/Processing/hasPortedOldLog", True)
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
# Invalidate the locator filter for in-place when active layer changes
iface.currentLayerChanged.connect(lambda _: self.iface.invalidateLocatorResults())
self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter()
iface.registerLocatorFilter(self.edit_features_locator_filter)
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.toolbox.executeWithGui.connect(self.executeAlgorithm)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin', '&Graphical Modeler…'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction,
QKeySequence('Ctrl+Alt+G').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QgsApplication.getThemeIcon("/mIconHistory.svg"),
QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setObjectName('resultsViewer')
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.toolbox.processingToolbar.addSeparator()
self.editInPlaceAction = QAction(
QgsApplication.getThemeIcon("/mActionProcessSelected.svg"),
self.tr('Edit Features In-Place'), self.iface.mainWindow())
self.editInPlaceAction.setObjectName('editInPlaceFeatures')
self.editInPlaceAction.setCheckable(True)
self.editInPlaceAction.toggled.connect(self.editSelected)
self.menu.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addSeparator()
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(
self.iface.firstRightStandardMenu().menuAction(), self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
createButtons()
# In-place editing button state sync
self.iface.currentLayerChanged.connect(self.sync_in_place_button_state)
self.iface.mapCanvas().selectionChanged.connect(self.sync_in_place_button_state)
self.iface.actionToggleEditing().triggered.connect(partial(self.sync_in_place_button_state, None))
self.sync_in_place_button_state()
# Sync project models
self.projectModelsMenu = None
self.projectMenuAction = None
self.projectMenuSeparator = None
self.projectProvider = QgsApplication.instance().processingRegistry().providerById("project")
self.projectProvider.algorithmsLoaded.connect(self.updateProjectModelMenu)
def updateProjectModelMenu(self):
"""Add projects models to menu"""
if self.projectMenuAction is None:
self.projectModelsMenu = QMenu(self.tr("Models"))
self.projectMenuAction = self.iface.projectMenu().insertMenu(self.iface.projectMenu().children()[-1], self.projectModelsMenu)
self.projectMenuAction.setParent(self.projectModelsMenu)
self.iface.projectMenu().insertSeparator(self.projectMenuAction)
self.projectModelsMenu.clear()
for model in self.projectProvider.algorithms():
modelSubMenu = self.projectModelsMenu.addMenu(model.name())
modelSubMenu.setParent(self.projectModelsMenu)
action = QAction(self.tr("Execute…"), modelSubMenu)
action.triggered.connect(partial(self.executeAlgorithm, model.id(), self.projectModelsMenu, self.toolbox.in_place_mode))
modelSubMenu.addAction(action)
if model.flags() & QgsProcessingAlgorithm.FlagSupportsBatch:
action = QAction(self.tr("Execute as Batch Process…"), modelSubMenu)
modelSubMenu.addAction(action)
action.triggered.connect(partial(self.executeAlgorithm, model.id(), self.projectModelsMenu, self.toolbox.in_place_mode, True))
@pyqtSlot(str, QWidget, bool, bool)
def executeAlgorithm(self, alg_id, parent, in_place=False, as_batch=False):
"""Executes a project model with GUI interaction if needed.
:param alg_id: algorithm id
:type alg_id: string
:param parent: parent widget
:type parent: QWidget
:param in_place: in place flag, defaults to False
:type in_place: bool, optional
:param as_batch: execute as batch flag, defaults to False
:type as_batch: bool, optional
"""
config = {}
if in_place:
config['IN_PLACE'] = True
alg = QgsApplication.instance().processingRegistry().createAlgorithmById(alg_id, config)
if alg is not None:
ok, message = alg.canExecute()
if not ok:
dlg = MessageDialog()
dlg.setTitle(self.tr('Error executing algorithm'))
dlg.setMessage(
self.tr('<h3>This algorithm cannot '
'be run :-( </h3>\n{0}').format(message))
dlg.exec_()
return
if as_batch:
dlg = BatchAlgorithmDialog(alg, iface.mainWindow())
dlg.show()
dlg.exec_()
else:
in_place_input_parameter_name = 'INPUT'
if hasattr(alg, 'inputParameterName'):
in_place_input_parameter_name = alg.inputParameterName()
if in_place and not [d for d in alg.parameterDefinitions() if d.name() not in (in_place_input_parameter_name, 'OUTPUT')]:
parameters = {}
feedback = MessageBarProgress(algname=alg.displayName())
ok, results = execute_in_place(alg, parameters, feedback=feedback)
if ok:
iface.messageBar().pushSuccess('', self.tr('{algname} completed. %n feature(s) processed.', n=results['__count']).format(algname=alg.displayName()))
feedback.close()
# MessageBarProgress handles errors
return
if alg.countVisibleParameters() > 0:
dlg = alg.createCustomParametersWidget(parent)
if not dlg:
dlg = AlgorithmDialog(alg, in_place, iface.mainWindow())
canvas = iface.mapCanvas()
prevMapTool = canvas.mapTool()
dlg.show()
dlg.exec_()
if canvas.mapTool() != prevMapTool:
try:
canvas.mapTool().reset()
except Exception:
pass
canvas.setMapTool(prevMapTool)
else:
feedback = MessageBarProgress(algname=alg.displayName())
context = dataobjects.createContext(feedback)
parameters = {}
ret, results = execute(alg, parameters, context, feedback)
handleAlgorithmResults(alg, context, feedback)
feedback.close()
def sync_in_place_button_state(self, layer=None):
"""Synchronise the button state with layer state"""
if layer is None:
layer = self.iface.activeLayer()
old_enabled_state = self.editInPlaceAction.isEnabled()
new_enabled_state = layer is not None and layer.type() == QgsMapLayerType.VectorLayer
self.editInPlaceAction.setEnabled(new_enabled_state)
if new_enabled_state != old_enabled_state:
self.toolbox.set_in_place_edit_mode(new_enabled_state and self.editInPlaceAction.isChecked())
def openProcessingOptions(self):
self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions')
def unload(self):
self.toolbox.setVisible(False)
self.iface.removeDockWidget(self.toolbox)
self.iface.attributesToolBar().removeAction(self.toolboxAction)
self.resultsDock.setVisible(False)
self.iface.removeDockWidget(self.resultsDock)
self.toolbox.deleteLater()
self.menu.deleteLater()
# also delete temporary help files
folder = tempHelpFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.toolboxAction)
self.iface.unregisterMainWindowAction(self.modelerAction)
self.iface.unregisterMainWindowAction(self.historyAction)
self.iface.unregisterMainWindowAction(self.resultsAction)
self.iface.unregisterOptionsWidgetFactory(self.options_factory)
self.iface.deregisterLocatorFilter(self.locator_filter)
self.iface.deregisterLocatorFilter(self.edit_features_locator_filter)
self.iface.unregisterCustomDropHandler(self.drop_handler)
QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider)
removeButtons()
removeMenus()
if self.projectMenuAction is not None:
self.iface.projectMenu().removeAction(self.projectMenuAction)
self.projectMenuAction = None
if self.projectMenuSeparator is not None:
self.iface.projectMenu().removeAction(self.projectMenuSeparator)
self.projectMenuSeparator = None
Processing.deinitialize()
def openToolbox(self, show):
self.toolbox.setUserVisible(show)
def toolboxVisibilityChanged(self, visible):
self.toolboxAction.setChecked(visible)
def openModeler(self):
dlg = ModelerDialog.create()
dlg.update_model.connect(self.updateModel)
dlg.show()
def updateModel(self):
model_provider = QgsApplication.processingRegistry().providerById('model')
model_provider.refreshAlgorithms()
def openResults(self):
if self.resultsDock.isVisible():
self.resultsDock.hide()
else:
self.resultsDock.show()
def openHistory(self):
dlg = HistoryDialog()
dlg.exec_()
def tr(self, message, disambiguation=None, n=-1):
return QCoreApplication.translate('ProcessingPlugin', message, disambiguation=disambiguation, n=n)
def editSelected(self, enabled):
self.toolbox.set_in_place_edit_mode(enabled)
class BoundlessConnectPlugin(object):
def __init__(self, iface):
self.iface = iface
try:
from boundlessconnect.tests import testerplugin
from qgistester.tests import addTestModule
addTestModule(testerplugin, 'Boundless Connect')
except Exception as e:
pass
self.dockWidget = None
readSettings()
self.iface.initializationCompleted.connect(self.checkFirstRun)
def initGui(self):
self.dockWidget = getConnectDockWidget()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockWidget)
self.dockWidget.hide()
utils.setRepositoryUrl()
self.actionRunWizard = self.dockWidget.toggleViewAction()
self.actionRunWizard.setText('Boundless Connect')
self.actionRunWizard.setIcon(
QIcon(os.path.join(pluginPath, 'icons', 'connect.svg')))
self.actionRunWizard.setWhatsThis('Boundless Connect')
self.actionRunWizard.setObjectName('actionRunWizard')
# If Boundless repository is a directory, add menu entry
# to start modified Plugin Manager which works with local repositories
if utils.isRepositoryInDirectory():
self.actionPluginManager = QAction(
'Manage plugins (local folder)', self.iface.mainWindow())
self.actionPluginManager.setIcon(
QIcon(os.path.join(pluginPath, 'icons', 'plugin.svg')))
self.actionPluginManager.setWhatsThis(
'Manage and install plugins from local repository')
self.actionPluginManager.setObjectName('actionPluginManager')
self.iface.addPluginToMenu(
'Boundless Connect', self.actionPluginManager)
self.actionPluginManager.triggered.connect(self.pluginManagerLocal)
actions = self.iface.mainWindow().menuBar().actions()
for action in actions:
if action.menu().objectName() == 'mPluginMenu':
menuPlugin = action.menu()
separator = menuPlugin.actions()[1]
menuPlugin.insertAction(separator, self.actionRunWizard)
if utils.isRepositoryInDirectory():
menuPlugin.insertAction(separator, self.actionPluginManager)
addSettingsMenu('Boundless Connect')
addHelpMenu('Boundless Connect')
addAboutMenu('Boundless Connect')
# Enable check for updates if it is not enabled
utils.addCheckForUpdates()
try:
from lessons import addLessonsFolder, addGroup
folder = os.path.join(os.path.dirname(__file__), "_lessons")
addLessonsFolder(folder, "boundlessconnect")
group_description = os.path.join(folder, "group.md")
addGroup("Boundless Connect plugin", group_description)
except:
pass
def unload(self):
actions = self.iface.mainWindow().menuBar().actions()
for action in actions:
if action.menu().objectName() == 'mPluginMenu':
menuPlugin = action.menu()
menuPlugin.removeAction(self.actionRunWizard)
if utils.isRepositoryInDirectory():
menuPlugin.removeAction(self.actionPluginManager)
removeSettingsMenu('Boundless Connect')
removeHelpMenu('Boundless Connect')
removeAboutMenu('Boundless Connect')
self.dockWidget.hide()
try:
from boundlessconnect.tests import testerplugin
from qgistester.tests import removeTestModule
removeTestModule(testerplugin, 'Boundless Connect')
except Exception as e:
pass
try:
from lessons import removeLessonsFolder
folder = os.path.join(pluginPath, '_lessons')
removeLessonsFolder(folder)
except:
pass
def checkFirstRun(self):
settings = QSettings()
firstRun = settings.value('boundlessconnect/firstRun', True, bool)
settings.setValue('boundlessconnect/firstRun', False)
if self.dockWidget is None:
self.dockWidget = getConnectDockWidget()
if firstRun:
self.dockWidget.show()
utils.installFromStandardPath()
def installPlugin(self):
fileName = askForFiles(self.iface.mainWindow(),
'Open file',
exts='zip')
if fileName is None:
return
result = utils.installFromZipFile(fileName)
if result is None:
self._showMessage('Plugin installed successfully',
QgsMessageBar.SUCCESS)
else:
self._showMessage(result, QgsMessageBar.WARNING)
settings.setValue('lastPluginDirectory',
QFileInfo(fileName).absoluteDir().absolutePath())
def pluginManagerLocal(self):
utils.showPluginManager(False)
def _showMessage(self, message, level=QgsMessageBar.INFO):
self.iface.messageBar().pushMessage(
message, level, self.iface.messageTimeout())
class TrackingDisplay(QToolBar):
'''
Display the position of a mobile and add action for centering
the map on the vehicle and erasing the track
'''
def __init__(self, mobile, parent=None):
super(TrackingDisplay, self).__init__(parent)
self.setMovable(True)
self.setFloatable(True)
self.mobile = mobile
self.timedOut = True
self.lastFix = 0.0
s = QSettings()
self.defFormat = s.value('PosiView/Misc/DefaultFormat',
defaultValue=0,
type=int)
self.format = self.defFormat & 3
self.withSuff = cf.FlagDegreesUseStringSuffix if bool(
self.defFormat & 4) else cf.FormatFlag(0)
try:
self.sep = cf.separator() + ' '
except AttributeError:
self.sep = ', '
self.createActions()
self.mobile.newPosition.connect(self.onNewPosition)
self.mobile.timeout.connect(self.onTimeout)
self.posText = '0.000000, 0.000000'
def createActions(self):
self.nameLabel = QLabel(self.mobile.name)
self.nameLabel.setMinimumSize(80, 23)
self.nameLabelAction = QWidgetAction(self)
self.nameLabelAction.setDefaultWidget(self.nameLabel)
self.addAction(self.nameLabelAction)
self.enableAction = QAction("Enable Display", self)
self.enableAction.setCheckable(True)
self.enableAction.setChecked(True)
icon = QIcon(':/plugins/PosiView/ledgrey.png')
icon.addFile(':/plugins/PosiView/ledgreen.png', QSize(), QIcon.Normal,
QIcon.On)
self.enableAction.setIcon(icon)
self.addAction(self.enableAction)
self.enableAction.triggered.connect(self.onEnableClicked)
self.enableAction.triggered.connect(self.mobile.setEnabled)
self.addSeparator()
self.posLabel = QLabel("--:--:-- 0.000000, 0.000000")
self.posLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
widths = (180, 196, 204, 180, 184, 200, 208, 184)
self.posLabel.setMinimumSize(widths[self.format], 23)
self.posLabel.setStyleSheet(
'background: red; font-size: 8pt; color: white;')
self.posLabelAction = QWidgetAction(self)
self.posLabelAction.setDefaultWidget(self.posLabel)
self.addAction(self.posLabelAction)
self.centerAction = QAction(QIcon(':/plugins/PosiView/center.png'),
"Center &Map", self)
self.addAction(self.centerAction)
self.deleteTrackAction = QAction(
QIcon(':/plugins/PosiView/deletetrack.png'), 'Delete &Track', self)
self.addAction(self.deleteTrackAction)
self.deleteTrackAction.triggered.connect(self.mobile.deleteTrack)
self.centerAction.triggered.connect(self.mobile.centerOnMap)
@pyqtSlot(float, QgsPointXY, float, float)
def onNewPosition(self, fix, pos, depth, altitude):
s = str()
if fix > 0:
s = strftime('%H:%M:%S ', gmtime(fix))
else:
s = '--:--:-- '
if self.format == 1:
f, pr = cf.FormatDegreesMinutes, 4
elif self.format == 2:
f, pr = cf.FormatDegreesMinutesSeconds, 2
else:
f, pr = cf.FormatDecimalDegrees, 6
self.posText = self.sep.join(
(cf.formatY(pos.y(), f, pr, self.withSuff),
cf.formatX(pos.x(), f, pr, self.withSuff)))
s += self.posText
if depth > -9999:
s += "\nd = {:.1f}".format(depth)
if altitude > -9999:
if depth > -9999:
s += " alt = {:.1f}".format(altitude)
else:
s += "\nalt = {:.1f}".format(altitude)
self.posLabel.setText(s)
if self.timedOut:
if fix > self.lastFix:
self.posLabel.setStyleSheet(
'background: lime; font-size: 8pt; color: black;')
self.timedOut = False
self.lastFix = fix
@pyqtSlot()
def onTimeout(self):
if not self.timedOut:
self.timedOut = True
self.posLabel.setStyleSheet(
'background: red; font-size: 8pt; color: white;')
@pyqtSlot(bool)
def onEnableClicked(self, enable):
self.timedOut = True
if enable:
self.posLabel.setStyleSheet(
'background: red; font-size: 8pt; color: white;')
else:
self.posLabel.setStyleSheet(
'background: white; font-size: 8pt; color: black;')
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
if event.modifiers() == Qt.ControlModifier:
QGuiApplication.clipboard().setText(self.posText)
else:
drag = QDrag(self)
mimeData = QMimeData()
mimeData.setText(self.posText)
drag.setMimeData(mimeData)
drag.exec_()
def releaseMobile(self):
self.mobile = None
class AttributesTable(QWidget):
def __init__(self, iface):
QWidget.__init__(self)
self.setWindowTitle(self.tr('Search results'))
self.resize(480,320)
self.setMinimumSize(320,240)
self.center()
# Results export button
self.btn_saveTab = QAction(QIcon(':/plugins/qgeric/resources/icon_save.png'), self.tr('Save this tab\'s results'), self)
self.btn_saveTab.triggered.connect(lambda : self.saveAttributes(True))
self.btn_saveAllTabs = QAction(QIcon(':/plugins/qgeric/resources/icon_saveAll.png'), self.tr('Save all results'), self)
self.btn_saveAllTabs.triggered.connect(lambda : self.saveAttributes(False))
self.btn_export = QAction(QIcon(':/plugins/qgeric/resources/icon_export.png'), self.tr('Export the selection as a memory layer'), self)
self.btn_export.triggered.connect(self.exportLayer)
self.btn_zoom = QAction(QIcon(':/plugins/qgeric/resources/icon_Zoom.png'), self.tr('Zoom to selected attributes'), self)
self.btn_zoom.triggered.connect(self.zoomToFeature)
self.btn_selectGeom = QAction(QIcon(':/plugins/qgeric/resources/icon_HlG.png'), self.tr('Highlight feature\'s geometry'), self)
self.btn_selectGeom.triggered.connect(self.selectGeomChanged)
self.btn_rename = QAction(QIcon(':/plugins/qgeric/resources/icon_Settings.png'), self.tr('Settings'), self)
self.btn_rename.triggered.connect(self.renameWindow)
self.tabWidget = QTabWidget() # Tab container
self.tabWidget.setTabsClosable(True)
self.tabWidget.currentChanged.connect(self.highlight_features)
self.tabWidget.tabCloseRequested.connect(self.closeTab)
self.loadingWindow = QProgressDialog()
self.loadingWindow.setWindowTitle(self.tr('Loading...'))
self.loadingWindow.setRange(0,100)
self.loadingWindow.setAutoClose(False)
self.loadingWindow.setCancelButton(None)
self.canvas = iface.mapCanvas()
self.canvas.extentsChanged.connect(self.highlight_features)
self.highlight = []
self.highlight_rows = []
toolbar = QToolBar()
toolbar.addAction(self.btn_saveTab)
toolbar.addAction(self.btn_saveAllTabs)
toolbar.addAction(self.btn_export)
toolbar.addSeparator()
toolbar.addAction(self.btn_zoom)
toolbar.addSeparator()
toolbar.addAction(self.btn_selectGeom)
toolbar.addAction(self.btn_rename)
vbox = QVBoxLayout()
vbox.setContentsMargins(0,0,0,0)
vbox.addWidget(toolbar)
vbox.addWidget(self.tabWidget)
self.setLayout(vbox)
self.mb = iface.messageBar()
self.selectGeom = False # False for point, True for geometry
def renameWindow(self):
title, ok = QInputDialog.getText(self, self.tr('Rename window'), self.tr('Enter a new title:'))
if ok:
self.setWindowTitle(title)
def closeTab(self, index):
self.tabWidget.widget(index).deleteLater()
self.tabWidget.removeTab(index)
def selectGeomChanged(self):
if self.selectGeom:
self.selectGeom = False
self.btn_selectGeom.setText(self.tr('Highlight feature\'s geometry'))
self.btn_selectGeom.setIcon(QIcon(':/plugins/qgeric/resources/icon_HlG.png'))
else:
self.selectGeom = True
self.btn_selectGeom.setText(self.tr('Highlight feature\'s centroid'))
self.btn_selectGeom.setIcon(QIcon(':/plugins/qgeric/resources/icon_HlC.png'))
self.highlight_features()
def exportLayer(self):
if self.tabWidget.count() != 0:
index = self.tabWidget.currentIndex()
table = self.tabWidget.widget(index).findChildren(QTableWidget)[0]
items = table.selectedItems()
if len(items) > 0:
type = ''
if items[0].feature.geometry().type() == QgsWkbTypes.PointGeometry:
type = 'Point'
elif items[0].feature.geometry().type() == QgsWkbTypes.LineGeometry:
type = 'LineString'
else:
type = 'Polygon'
features = []
for item in items:
if item.feature not in features:
features.append(item.feature)
name = ''
ok = True
while not name.strip() and ok == True:
name, ok = QInputDialog.getText(self, self.tr('Layer name'), self.tr('Give a name to the layer:'))
if ok:
layer = QgsVectorLayer(type+"?crs="+table.crs.authid(),name,"memory")
layer.startEditing()
layer.dataProvider().addAttributes(features[0].fields().toList())
layer.dataProvider().addFeatures(features)
layer.commitChanges()
QgsProject.instance().addMapLayer(layer)
else:
self.mb.pushWarning(self.tr('Warning'), self.tr('There is no selected feature !'))
def highlight_features(self):
for item in self.highlight:
self.canvas.scene().removeItem(item)
del self.highlight[:]
del self.highlight_rows[:]
index = self.tabWidget.currentIndex()
tab = self.tabWidget.widget(index)
if self.tabWidget.count() != 0:
table = self.tabWidget.widget(index).findChildren(QTableWidget)[0]
nb = 0
area = 0
length = 0
items = table.selectedItems()
for item in items:
if item.row() not in self.highlight_rows:
if self.selectGeom:
highlight = QgsHighlight(self.canvas, item.feature.geometry(), self.tabWidget.widget(index).layer)
else:
highlight = QgsHighlight(self.canvas, item.feature.geometry().centroid(), self.tabWidget.widget(index).layer)
highlight.setColor(QColor(255,0,0))
self.highlight.append(highlight)
self.highlight_rows.append(item.row())
g = QgsGeometry(item.feature.geometry())
g.transform(QgsCoordinateTransform(tab.layer.crs(), QgsCoordinateReferenceSystem(2154), QgsProject.instance())) # geometry reprojection to get meters
nb += 1
area += g.area()
length += g.length()
if tab.layer.geometryType()==QgsWkbTypes.PolygonGeometry:
tab.sb.showMessage(self.tr('Selected features')+': '+str(nb)+' '+self.tr('Area')+': '+"%.2f"%area+' m'+u'²')
elif tab.layer.geometryType()==QgsWkbTypes.LineGeometry:
tab.sb.showMessage(self.tr('Selected features')+': '+str(nb)+' '+self.tr('Length')+': '+"%.2f"%length+' m')
else:
tab.sb.showMessage(self.tr('Selected features')+': '+str(nb))
def tr(self, message):
return QCoreApplication.translate('Qgeric', message)
def zoomToFeature(self):
index = self.tabWidget.currentIndex()
table = self.tabWidget.widget(index).findChildren(QTableWidget)[0]
items = table.selectedItems()
feat_id = []
for item in items:
feat_id.append(item.feature.id())
if len(feat_id) >= 1:
if len(feat_id) == 1:
self.canvas.setExtent(items[0].feature.geometry().buffer(5, 0).boundingBox()) # in case of a single point, it will still zoom to it
else:
self.canvas.zoomToFeatureIds(self.tabWidget.widget(self.tabWidget.currentIndex()).layer, feat_id)
self.canvas.refresh()
# Add a new tab
def addLayer(self, layer, headers, types, features):
tab = QWidget()
tab.layer = layer
p1_vertical = QVBoxLayout(tab)
p1_vertical.setContentsMargins(0,0,0,0)
table = QTableWidget()
table.itemSelectionChanged.connect(self.highlight_features)
table.title = layer.name()
table.crs = layer.crs()
table.setColumnCount(len(headers))
if len(features) > 0:
table.setRowCount(len(features))
nbrow = len(features)
self.loadingWindow.show()
self.loadingWindow.setLabelText(table.title)
self.loadingWindow.activateWindow()
self.loadingWindow.showNormal()
# Table population
m = 0
for feature in features:
n = 0
for cell in feature.attributes():
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, cell)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item.feature = feature
table.setItem(m, n, item)
n += 1
m += 1
self.loadingWindow.setValue(int((float(m)/nbrow)*100))
QApplication.processEvents()
else:
table.setRowCount(0)
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setSectionsMovable(True)
table.types = types
table.filter_op = []
table.filters = []
for i in range(0, len(headers)):
table.filters.append('')
table.filter_op.append(0)
header = table.horizontalHeader()
header.setContextMenuPolicy(Qt.CustomContextMenu)
header.customContextMenuRequested.connect(partial(self.filterMenu, table))
table.setSortingEnabled(True)
p1_vertical.addWidget(table)
# Status bar to display informations (ie: area)
tab.sb = QStatusBar()
p1_vertical.addWidget(tab.sb)
title = table.title
# We reduce the title's length to 20 characters
if len(title)>20:
title = title[:20]+'...'
# We add the number of elements to the tab's title.
title += ' ('+str(len(features))+')'
self.tabWidget.addTab(tab, title) # Add the tab to the conatiner
self.tabWidget.setTabToolTip(self.tabWidget.indexOf(tab), table.title) # Display a tooltip with the layer's full name
def filterMenu(self, table, pos):
index = table.columnAt(pos.x())
menu = QMenu()
filter_operation = QComboBox()
if table.types[index] in [10]:
filter_operation.addItems([self.tr('Contains'),self.tr('Equals')])
else:
filter_operation.addItems(['=','>','<'])
filter_operation.setCurrentIndex(table.filter_op[index])
action_filter_operation = QWidgetAction(self)
action_filter_operation.setDefaultWidget(filter_operation)
if table.types[index] in [14]:
if not isinstance(table.filters[index], QDate):
filter_value = QDateEdit()
else:
filter_value = QDateEdit(table.filters[index])
elif table.types[index] in [15]:
if not isinstance(table.filters[index], QTime):
filter_value = QTimeEdit()
else:
filter_value = QTimeEdit(table.filters[index])
elif table.types[index] in [16]:
if not isinstance(table.filters[index], QDateTime):
filter_value = QDateTimeEdit()
else:
filter_value = QDateTimeEdit(table.filters[index])
else:
filter_value = QLineEdit(table.filters[index])
action_filter_value = QWidgetAction(self)
action_filter_value.setDefaultWidget(filter_value)
menu.addAction(action_filter_operation)
menu.addAction(action_filter_value)
action_filter_apply = QAction(self.tr('Apply'), self)
action_filter_apply.triggered.connect(partial(self.applyFilter, table, index, filter_value, filter_operation))
action_filter_cancel = QAction(self.tr('Cancel'), self)
action_filter_cancel.triggered.connect(partial(self.applyFilter, table, index, None, filter_operation))
menu.addAction(action_filter_apply)
menu.addAction(action_filter_cancel)
menu.exec_(QtGui.QCursor.pos())
def applyFilter(self, table, index, filter_value, filter_operation):
if filter_value == None:
table.filters[index] = None
else:
if isinstance(filter_value, QDateEdit):
table.filters[index] = filter_value.date()
elif isinstance(filter_value, QTimeEdit):
table.filters[index] = filter_value.time()
elif isinstance(filter_value, QDateTimeEdit):
table.filters[index] = filter_value.dateTime()
else:
table.filters[index] = filter_value.text()
table.filter_op[index] = filter_operation.currentIndex()
nb_elts = 0
for i in range(0, table.rowCount()):
table.setRowHidden(i, False)
nb_elts += 1
hidden_rows = []
for nb_col in range(0, table.columnCount()):
filtered = False
header = table.horizontalHeaderItem(nb_col).text()
valid = False
if table.filters[nb_col] is not None:
if type(table.filters[nb_col]) in [QDate, QTime, QDateTime]:
valid = True
else:
if table.filters[nb_col].strip():
valid = True
if valid:
filtered = True
items = None
if table.types[nb_col] in [10]:# If it's a string
filter_type = None
if table.filter_op[nb_col] == 0: # Contain
filter_type = Qt.MatchContains
if table.filter_op[nb_col] == 1: # Equal
filter_type = Qt.MatchFixedString
items = table.findItems(table.filters[nb_col], filter_type)
elif table.types[nb_col] in [14, 15, 16]: # If it's a date/time
items = []
for nb_row in range(0, table.rowCount()):
item = table.item(nb_row, nb_col)
if table.filter_op[nb_col] == 0: # =
if item.data(QTableWidgetItem.Type) == table.filters[nb_col]:
items.append(item)
if table.filter_op[nb_col] == 1: # >
if item.data(QTableWidgetItem.Type) > table.filters[nb_col]:
items.append(item)
if table.filter_op[nb_col] == 2: # <
if item.data(QTableWidgetItem.Type) < table.filters[nb_col]:
items.append(item)
else: # If it's a number
items = []
for nb_row in range(0, table.rowCount()):
item = table.item(nb_row, nb_col)
if item.text().strip():
if table.filter_op[nb_col] == 0: # =
if float(item.text()) == float(table.filters[nb_col]):
items.append(item)
if table.filter_op[nb_col] == 1: # >
if float(item.text()) > float(table.filters[nb_col]):
items.append(item)
if table.filter_op[nb_col] == 2: # <
if float(item.text()) < float(table.filters[nb_col]):
items.append(item)
rows = []
for item in items:
if item.column() == nb_col:
rows.append(item.row())
for i in range(0, table.rowCount()):
if i not in rows:
if i not in hidden_rows:
nb_elts -= 1
table.setRowHidden(i, True)
hidden_rows.append(i)
if filtered:
if header[len(header)-1] != '*':
table.setHorizontalHeaderItem(nb_col, QTableWidgetItem(header+'*'))
else:
if header[len(header)-1] == '*':
header = header[:-1]
table.setHorizontalHeaderItem(nb_col, QTableWidgetItem(header))
title = self.tabWidget.tabText(self.tabWidget.currentIndex())
for i in reversed(range(len(title))):
if title[i] == ' ':
break
title = title[:-1]
title += '('+str(nb_elts)+')'
self.tabWidget.setTabText(self.tabWidget.currentIndex(), title)
# Save tables in OpenDocument format
# Use odswriter library
def saveAttributes(self, active):
file = QFileDialog.getSaveFileName(self, self.tr('Save in...'),'', self.tr('OpenDocument Spreadsheet (*.ods)'))
if file[0]:
try:
with ods.writer(open(file[0],"wb")) as odsfile:
tabs = None
if active:
tabs = self.tabWidget.currentWidget().findChildren(QTableWidget)
else:
tabs = self.tabWidget.findChildren(QTableWidget)
for table in reversed(tabs):
sheet = odsfile.new_sheet(table.title[:20]+'...') # For each tab in the container, a new sheet is created
sheet.writerow([table.title]) # As the tab's title's lenght is limited, the full name of the layer is written in the first row
nb_row = table.rowCount()
nb_col = table.columnCount()
# Fetching and writing of the table's header
header = []
for i in range(0,nb_col):
header.append(table.horizontalHeaderItem(i).text())
sheet.writerow(header)
# Fetching and writing of the table's items
for i in range(0,nb_row):
row = []
for j in range(0,nb_col):
row.append(table.item(i,j).text())
if not table.isRowHidden(i):
sheet.writerow(row)
return True
except IOError:
QMessageBox.critical(self, self.tr('Error'), self.tr('The file can\'t be written.')+'\n'+self.tr('Maybe you don\'t have the rights or are trying to overwrite an opened file.'))
return False
def center(self):
screen = QDesktopWidget().screenGeometry()
size = self.geometry()
self.move((screen.width()-size.width())/2, (screen.height()-size.height())/2)
def clear(self):
self.tabWidget.clear()
for table in self.tabWidget.findChildren(QTableWidget):
table.setParent(None)
def closeEvent(self, e):
result = QMessageBox.question(self, self.tr("Saving ?"), self.tr("Would you like to save results before exit ?"), buttons = QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if result == QMessageBox.Yes:
if self.saveAttributes(False):
self.clear()
e.accept()
else:
e.ignore()
elif result == QMessageBox.No:
self.clear()
e.accept()
else:
e.ignore()
class ProcessingPlugin:
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(
self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
Processing.initialize()
def initGui(self):
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'),
self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(
self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(
self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin',
'Graphical &Modeler…'),
self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(
self.modelerAction,
QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QIcon(os.path.join(pluginPath, 'images', 'history.svg')),
QCoreApplication.translate('ProcessingPlugin', '&History…'),
self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(
self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(
self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(
self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
def openProcessingOptions(self):
self.iface.showOptionsDialog(self.iface.mainWindow(),
currentPage='processingOptions')
def unload(self):
self.toolbox.setVisible(False)
self.iface.removeDockWidget(self.toolbox)
self.iface.attributesToolBar().removeAction(self.toolboxAction)
self.resultsDock.setVisible(False)
self.iface.removeDockWidget(self.resultsDock)
self.toolbox.deleteLater()
self.menu.deleteLater()
# delete temporary output files
folder = QgsProcessingUtils.tempFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
# also delete temporary help files
folder = tempHelpFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.toolboxAction)
self.iface.unregisterMainWindowAction(self.modelerAction)
self.iface.unregisterMainWindowAction(self.historyAction)
self.iface.unregisterMainWindowAction(self.resultsAction)
self.iface.unregisterOptionsWidgetFactory(self.options_factory)
self.iface.deregisterLocatorFilter(self.locator_filter)
self.iface.unregisterCustomDropHandler(self.drop_handler)
QgsApplication.dataItemProviderRegistry().removeProvider(
self.item_provider)
removeMenus()
Processing.deinitialize()
def openToolbox(self, show):
self.toolbox.setUserVisible(show)
def toolboxVisibilityChanged(self, visible):
self.toolboxAction.setChecked(visible)
def openModeler(self):
dlg = ModelerDialog()
dlg.update_model.connect(self.updateModel)
dlg.show()
def updateModel(self):
model_provider = QgsApplication.processingRegistry().providerById(
'model')
model_provider.refreshAlgorithms()
def openResults(self):
if self.resultsDock.isVisible():
self.resultsDock.hide()
else:
self.resultsDock.show()
def openHistory(self):
dlg = HistoryDialog()
dlg.exec_()
def tr(self, message):
return QCoreApplication.translate('ProcessingPlugin', message)
class TrackingDisplay(QToolBar):
'''
Display the position of a mobile and add action for centering
the map on the vehicle and erasing the track
'''
def __init__(self, mobile, parent=None):
super(TrackingDisplay, self).__init__(parent)
self.setMovable(True)
self.setFloatable(True)
self.mobile = mobile
self.timedOut = True
self.lastFix = 0.0
s = QSettings()
self.defFormat = s.value('PosiView/Misc/DefaultFormat', defaultValue=0, type=int)
self.format = self.defFormat & 3
self.withSuff = QgsCoordinateFormatter.FlagDegreesUseStringSuffix if bool(self.defFormat & 4) else QgsCoordinateFormatter.FormatFlag(0)
self.createActions()
self.mobile.newPosition.connect(self.onNewPosition)
self.mobile.timeout.connect(self.onTimeout)
def createActions(self):
self.nameLabel = QLabel(self.mobile.name)
self.nameLabel.setMinimumSize(80, 23)
self.nameLabelAction = QWidgetAction(self)
self.nameLabelAction.setDefaultWidget(self.nameLabel)
self.addAction(self.nameLabelAction)
self.enableAction = QAction("Enable Display", self)
self.enableAction.setCheckable(True)
self.enableAction.setChecked(True)
icon = QIcon(':/plugins/PosiView/ledgrey.png')
icon.addFile(':/plugins/PosiView/ledgreen.png', QSize(), QIcon.Normal, QIcon.On)
self.enableAction.setIcon(icon)
self.addAction(self.enableAction)
self.enableAction.triggered.connect(self.onEnableClicked)
self.enableAction.triggered.connect(self.mobile.setEnabled)
self.addSeparator()
self.posLabel = QLabel("--:--:-- 0.000000 0.000000")
self.posLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
widths = (180, 196, 204, 180, 184, 200, 208, 184)
self.posLabel.setMinimumSize(widths[self.format], 23)
self.posLabel.setStyleSheet('background: red; font-size: 8pt; color: white;')
self.posLabelAction = QWidgetAction(self)
self.posLabelAction.setDefaultWidget(self.posLabel)
self.addAction(self.posLabelAction)
self.centerAction = QAction(QIcon(':/plugins/PosiView/center.png'), "Center &Map", self)
self.addAction(self.centerAction)
self.deleteTrackAction = QAction(QIcon(':/plugins/PosiView/deletetrack.png'), 'Delete &Track', self)
self.addAction(self.deleteTrackAction)
self.deleteTrackAction.triggered.connect(self.mobile.deleteTrack)
self.centerAction.triggered.connect(self.mobile.centerOnMap)
@pyqtSlot(float, QgsPointXY, float, float)
def onNewPosition(self, fix, pos, depth, altitude):
s = str()
if fix > 0:
s = strftime('%H:%M:%S ', gmtime(fix))
else:
s = '--:--:-- '
if self.format == 0:
s += "{:f} {:f}".format(pos.y(), pos.x())
elif self.format == 1:
s += ', '.join(QgsCoordinateFormatter.format(pos,
QgsCoordinateFormatter.FormatDegreesMinutes,
4,
self.withSuff
).rsplit(',')[::-1])
else:
s += ', '.join(QgsCoordinateFormatter.format(pos,
QgsCoordinateFormatter.FormatDegreesMinutesSeconds,
2,
self.withSuff
).rsplit(',')[::-1])
if depth > -9999:
s += "\nd = {:.1f}".format(depth)
if altitude > -9999:
if depth > -9999:
s += " alt = {:.1f}".format(altitude)
else:
s += "\nalt = {:.1f}".format(altitude)
self.posLabel.setText(s)
if self.timedOut:
if fix > self.lastFix:
self.posLabel.setStyleSheet('background: lime; font-size: 8pt; color: black;')
self.timedOut = False
self.lastFix = fix
@pyqtSlot()
def onTimeout(self):
if not self.timedOut:
self.timedOut = True
self.posLabel.setStyleSheet('background: red; font-size: 8pt; color: white;')
@pyqtSlot(bool)
def onEnableClicked(self, enable):
self.timedOut = True
if enable:
self.posLabel.setStyleSheet('background: red; font-size: 8pt; color: white;')
else:
self.posLabel.setStyleSheet('background: white; font-size: 8pt; color: black;')
def releaseMobile(self):
self.mobile = None
class Comptages(QObject):
def __init__(self, iface):
QObject.__init__(self)
self.iface = iface
self.settings = Settings()
self.settings_dialog = SettingsDialog()
self.layers = Layers()
self.chart_dock = ChartDock(self.iface, self.layers)
self.iface.addDockWidget(Qt.BottomDockWidgetArea, self.chart_dock)
self.filter_start_date = None
self.filter_end_date = None
self.filter_installation = None
self.filter_sensor = None
self.filter_tjm = None
self.filter_axe = None
self.filter_sector = None
self.tm = QgsApplication.taskManager()
def initGui(self):
self.connect_db_action = QAction(
QIcon(':/plugins/Comptages/images/power.png'), 'Connection DB',
self.iface.mainWindow())
self.create_new_action = QAction(
QIcon(':/plugins/Comptages/images/measure.png'),
'Créer un nouveau comptage', None)
self.select_edit_action = QAction(
QIcon(':/plugins/Comptages/images/select_edit.png'),
'Modifier comptage', None)
self.import_files_action = QAction(
QIcon(':/plugins/Comptages/images/import.png'), 'Importation',
None)
self.validate_imported_files = QAction(
QIcon(':/plugins/Comptages/images/validate.png'), 'Validation',
None)
self.filter_action = QAction(
QIcon(':/plugins/Comptages/images/filter.png'), 'Filtrer', None)
self.yearly_report_action = QAction(
QIcon(':/plugins/Comptages/images/filled_file.png'),
'Rapport annuel', None)
self.import_ics_action = QAction(
QIcon(':/plugins/Comptages/images/calendar.png'),
'Importer fichier ics', None)
self.settings_action = QAction(
QIcon(':/plugins/Comptages/images/settings.png'), 'Réglages', None)
self.connect_db_action.triggered.connect(self.do_connect_db_action)
self.create_new_action.triggered.connect(self.do_create_new_action)
self.select_edit_action.triggered.connect(self.do_select_edit_action)
self.import_files_action.triggered.connect(self.do_import_files_action)
self.validate_imported_files.triggered.connect(
self.do_validate_imported_files_action)
self.filter_action.triggered.connect(self.do_filter_action)
self.yearly_report_action.triggered.connect(
self.do_yearly_report_action)
self.import_ics_action.triggered.connect(self.do_import_ics_action)
self.settings_action.triggered.connect(self.do_settings_action)
self.create_new_action.setEnabled(False)
self.select_edit_action.setEnabled(False)
self.import_files_action.setEnabled(False)
self.validate_imported_files.setEnabled(False)
self.filter_action.setEnabled(False)
self.yearly_report_action.setEnabled(False)
self.import_ics_action.setEnabled(False)
self.iface.addPluginToMenu('Comptages', self.connect_db_action)
self.iface.addPluginToMenu('Comptages', self.create_new_action)
self.iface.addPluginToMenu('Comptages', self.select_edit_action)
self.iface.addPluginToMenu('Comptages', self.import_files_action)
self.iface.addPluginToMenu('Comptages', self.validate_imported_files)
self.iface.addPluginToMenu('Comptages', self.filter_action)
self.iface.addPluginToMenu('Comptages', self.yearly_report_action)
self.iface.addPluginToMenu('Comptages', self.import_ics_action)
self.iface.addPluginToMenu('Comptages', self.settings_action)
self.toolbar = self.iface.addToolBar('Comptages')
self.toolbar.setObjectName('Comptages')
self.toolbar.setToolTip('Comptages toolbar')
self.toolbar.addAction(self.connect_db_action)
self.toolbar.addSeparator()
self.toolbar.addAction(self.create_new_action)
self.toolbar.addAction(self.select_edit_action)
self.toolbar.addAction(self.import_files_action)
self.toolbar.addAction(self.validate_imported_files)
self.toolbar.addAction(self.filter_action)
self.toolbar.addAction(self.yearly_report_action)
self.toolbar.addAction(self.import_ics_action)
self.toolbar.addSeparator()
self.toolbar.addAction(self.settings_action)
def unload(self):
self.iface.removePluginMenu('Comptages', self.connect_db_action)
self.iface.removePluginMenu('Comptages', self.create_new_action)
self.iface.removePluginMenu('Comptages', self.select_edit_action)
self.iface.removePluginMenu('Comptages', self.filter_action)
self.iface.removePluginMenu('Comptages', self.yearly_report_action)
self.iface.removePluginMenu('Comptages', self.import_ics_action)
self.iface.removePluginMenu('Comptages', self.settings_action)
del self.connect_db_action
del self.create_new_action
del self.select_edit_action
del self.filter_action
del self.yearly_report_action
del self.import_ics_action
del self.settings_action
del self.toolbar
def do_connect_db_action(self):
self.layers.load_layers()
self.enable_actions_if_needed()
def do_create_new_action(self):
if self.tm.countActiveTasks() > 0:
push_info(("Veuillez patienter jusqu'à ce que l'importation "
"soit terminée."))
return
self.layers.create_count()
def do_select_edit_action(self):
if self.tm.countActiveTasks() > 0:
push_info(("Veuillez patienter jusqu'à ce que l'importation "
"soit terminée."))
return
self.layers.edit_count()
def do_import_files_action(self):
if self.tm.countActiveTasks() > 0:
push_info(("Veuillez patienter jusqu'à ce que l'importation "
"soit terminée."))
return
file_dialog = QFileDialog()
title = 'Importer'
path = self.settings.value('data_import_directory')
files = QFileDialog.getOpenFileNames(
file_dialog, title, path,
"Data file (*.A?? *.aV? *.I?? *.V?? *.txt)")[0]
self.tm.allTasksFinished.connect(
partial(self.all_tasks_finished, 'import'))
tasks = []
for file_path in files:
tasks.append(self.import_file(file_path))
for t in tasks:
self.tm.addTask(t)
def import_file(self, file_path, count_id=None):
QgsMessageLog.logMessage(
'{} - Prepare import file {} started'.format(
datetime.now(), os.path.basename(file_path)), 'Comptages',
Qgis.Info)
# Manage binary files
with open(file_path, 'rb') as fd:
file_head = fd.read(24)
if file_head == b'Golden River Traffic Ltd': # is a binary file
formatter = self.layers.get_formatter_name('GoldenRiver')
file_path_formatted = "{}_for".format(file_path)
os.system("{} {} {}".format(formatter, file_path,
file_path_formatted))
file_path = file_path_formatted
if count_id:
count = models.Count.objects.get(id=count_id)
else:
count = importer.guess_count(file_path)
if not count:
QgsMessageLog.logMessage(
"Impossible de trouver le comptage associé {}".format(
file_path, ), 'Comptages', Qgis.Critical)
return
QgsMessageLog.logMessage(
'{} - Prepare import file {}'.format(datetime.now(),
os.path.basename(file_path)),
'Comptages', Qgis.Info)
QgsMessageLog.logMessage(
'{} - Import file {} started'.format(datetime.now(),
os.path.basename(file_path)),
'Comptages', Qgis.Info)
task = importer_task.ImporterTask(file_path, count)
return task
def all_tasks_finished(self, task='import'):
# Check if actually all tasks are finished because apparently it doesn't
# work the same on all systems
if not self.tm.countActiveTasks() == 0:
QgsMessageLog.logMessage(
'{} - all_tasks_finished signal raised, but active tasks still exist, ignoring it'
.format(datetime.now()), 'Comptages', Qgis.Warning)
return
self.tm.allTasksFinished.disconnect()
push_info(('Toutes les tâches sont terminées. Consultez le journal '
'pour plus de détails.'))
QgsMessageLog.logMessage('{} - All tasks ended'.format(datetime.now()),
'Comptages', Qgis.Info)
if task == 'import':
self.chart_dock.show_next_quarantined_chart()
def do_validate_imported_files_action(self):
if self.tm.countActiveTasks() > 0:
push_info(("Veuillez patienter jusqu'à ce que l'importation "
"soit terminée."))
return
self.chart_dock.show_next_quarantined_chart()
def do_filter_action(self):
dlg = FilterDialog(self.iface)
# Set last values in the filter
if self.filter_start_date:
dlg.start_date.setDateTime(self.filter_start_date)
else:
dlg.start_date.setDateTime(QDateTime())
if self.filter_end_date:
dlg.end_date.setDateTime(self.filter_end_date)
else:
dlg.end_date.setDateTime(QDateTime())
if self.filter_installation:
dlg.installation.setCurrentIndex(self.filter_installation)
if self.filter_sensor:
dlg.sensor.setCurrentIndex(self.filter_sensor)
if self.filter_tjm:
dlg.tjm.setRange(self.filter_tjm[0], self.filter_tjm[1])
else:
dlg.tjm.setRange(0, 30000)
if self.filter_axe:
dlg.axe.setCurrentIndex(self.filter_axe)
if self.filter_sector:
dlg.sector.setCurrentIndex(self.filter_sector)
if dlg.exec_():
self.filter_start_date = dlg.start_date.dateTime()
self.filter_end_date = dlg.end_date.dateTime()
self.filter_installation = dlg.installation.currentIndex()
self.filter_sensor = dlg.sensor.currentIndex()
self.filter_tjm = [dlg.tjm.lowerValue(), dlg.tjm.upperValue()]
self.filter_axe = dlg.axe.currentIndex()
self.filter_sector = dlg.sector.currentIndex()
self.layers.apply_filter(
dlg.start_date.dateTime().toString('yyyy-MM-dd'),
dlg.end_date.dateTime().toString('yyyy-MM-dd'),
dlg.installation.currentIndex(),
dlg.sensor.currentIndex(),
[self.filter_tjm[0], self.filter_tjm[1]],
dlg.axe.currentData(),
dlg.sector.currentData(),
)
if (not dlg.start_date.dateTime()) and (not dlg.end_date.dateTime()) and (dlg.installation.currentIndex() == 0) and \
(dlg.sensor.currentIndex() == 0) and (dlg.tjm.lowerValue() == 0) and (dlg.tjm.upperValue() == 30000) and \
(dlg.axe.currentText() == 'Tous') and (dlg.sector.currentText() == 'Tous'):
self.filter_action.setIcon(
QIcon(':/plugins/Comptages/images/filter.png'))
else:
self.filter_action.setIcon(
QIcon(':/plugins/Comptages/images/filter_active.png'))
def do_yearly_report_action(self):
QgsMessageLog.logMessage(
'{} - Generate yearly report action started'.format(
datetime.now()), 'Comptages', Qgis.Info)
if self.tm.countActiveTasks() > 0:
push_info(("Veuillez patienter jusqu'à ce que l'importation "
"soit terminée."))
return
layer = self.layers.layers['section']
selected_count = layer.selectedFeatureCount()
if selected_count == 0:
push_info("Veuillez sélectionner un tronçon")
return
elif selected_count > 1:
push_info("Veuillez ne sélectionner qu'un tronçon")
return
else:
selected_feature = next(layer.getSelectedFeatures())
section_id = selected_feature.attribute('id')
classes = self.layers.get_classes_of_section(section_id)
dlg = YearlyReportDialog(self.iface)
dlg.section.insert(section_id)
dlg.classi.addItems(classes)
if dlg.exec_():
year = dlg.year.value()
clazz = dlg.classi.currentText()
file_dialog = QFileDialog()
title = 'Exporter un rapport'
path = self.settings.value('report_export_directory')
file_path = QFileDialog.getExistingDirectory(
file_dialog, title, path)
if not file_path:
QgsMessageLog.logMessage(
'{} - Generate yearly report action ended: No file_path given'
.format(datetime.now()), 'Comptages', Qgis.Info)
return
QgsMessageLog.logMessage(
'{} - Generate yearly report action can really begin now for count {} with file_path: {}'
.format(datetime.now(), selected_count,
file_path), 'Comptages', Qgis.Info)
if clazz.startswith("SPCH-MD"):
yrb = YearlyReportBike(file_path, year, section_id)
yrb.run()
else:
self.tm.allTasksFinished.connect(
partial(self.all_tasks_finished, report))
# TODO: consider the chosed class too
self.tm.addTask(
report_task.ReportTask(file_path=file_path,
template="yearly",
year=year,
section_id=section_id))
# TODO: check if there are comptages for this section and year
def do_import_ics_action(self):
IcsImporter(self.layers)
def do_settings_action(self):
self.settings_dialog.exec_()
def do_export_configuration_action(self, count_id):
config_creator = ConfigCreatorCmd(self.layers, count_id)
config_creator.set_section_commands()
installation_name = self.layers.get_installation_name_of_count(
count_id)
file_dialog = QFileDialog()
file_dialog.setDefaultSuffix('*.CMD')
title = 'Exporter la configuration'
path = os.path.join(self.settings.value('config_export_directory'),
"{}.CMD".format(installation_name))
file = QFileDialog.getSaveFileName(file_dialog, title, path,
"Config file (*.CMD)")[0]
if not file:
return
config_creator.write_file(file)
push_info('Written config file {}'.format(file))
def do_import_single_file_action(self, count_id):
file_dialog = QFileDialog()
title = 'Importation'
path = self.settings.value('data_import_directory')
file_path = QFileDialog.getOpenFileName(
file_dialog, title, path,
"Data file (*.A?? *.aV? *.I?? *.V?? *.txt)")[0]
if not file_path:
return
self.tm.allTasksFinished.connect(
partial(self.all_tasks_finished, 'import'))
self.tm.addTask(self.import_file(file_path, count_id))
def do_generate_report_action(self, count_id):
QgsMessageLog.logMessage(
'{} - Generate report action started'.format(datetime.now()),
'Comptages', Qgis.Info)
count = models.Count.objects.get(id=count_id)
if self.tm.countActiveTasks() > 0:
push_info(("Veuillez patienter jusqu'à ce que l'importation "
"soit terminée."))
return
# Show message if there are no data to process
if not models.CountDetail.objects.filter(id_count=count).exists():
push_info(
"Installation {}: Il n'y a pas de données à traiter pour "
"le comptage {}".format(count.id_installation.name, count.id))
QgsMessageLog.logMessage(
'{} - Generate report action ended: No data for count {}'.
format(datetime.now(), count.id), 'Comptages', Qgis.Info)
return
file_dialog = QFileDialog()
title = 'Exporter un rapport'
path = self.settings.value('report_export_directory')
file_path = QFileDialog.getExistingDirectory(file_dialog, title, path)
if not file_path:
QgsMessageLog.logMessage(
'{} - Generate report action ended: No file_path given'.format(
datetime.now()), 'Comptages', Qgis.Info)
return
QgsMessageLog.logMessage(
'{} - Generate report action can really begin now for count {} with file_path: {}'
.format(datetime.now(), count.id,
file_path), 'Comptages', Qgis.Info)
self.tm.allTasksFinished.connect(
partial(self.all_tasks_finished, 'report'))
self.tm.addTask(
report_task.ReportTask(
file_path=file_path,
count=count,
))
def do_export_plan_action(self, count_id):
plan_creator = PlanCreator(self.layers)
file_dialog = QFileDialog()
file_dialog.setDefaultSuffix('*.PDF')
title = 'Exporter plan de pose'
path = os.path.join(self.settings.value('config_export_directory'),
"{}.pdf".format("plan_de_pose"))
file = QFileDialog.getSaveFileName(file_dialog, title, path,
"Config file (*.PDF)")[0]
if not file:
return
# Highlight the current sections and installation in the layout
previous_highlightes_sections = self.layers.highlighted_sections
self.layers.highlighted_sections = \
self.layers.get_section_ids_of_count(count_id)
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'highlighted_installation',
self.layers.get_installation_name_of_count(count_id))
plan_creator.export_pdf(count_id, file)
self.layers.highlighted_sections = previous_highlightes_sections
QgsExpressionContextUtils.setProjectVariable(
QgsProject.instance(), 'highlighted_installation', '')
self.layers.layers['section'].triggerRepaint()
def do_generate_chart_action(self, count_id):
QgsMessageLog.logMessage(
'{} - Generate chart action started'.format(datetime.now()),
'Comptages', Qgis.Info)
if self.tm.countActiveTasks() > 0:
push_info(("Veuillez patienter jusqu'à ce que l'importation "
"soit terminée."))
return
count = models.Count.objects.get(id=count_id)
self.chart_dock.set_attributes(count)
QgsMessageLog.logMessage(
'{} - Generate chart action ended'.format(datetime.now()),
'Comptages', Qgis.Info)
def do_delete_data_action(self, count_id):
dlg = DeleteDialog(self.iface)
tz = pytz.timezone("Europe/Zurich")
if dlg.exec_():
start = tz.localize(dlg.start_date.dateTime().toPyDateTime())
end = tz.localize(dlg.end_date.dateTime().toPyDateTime())
definitive = dlg.definitive.isChecked()
quarantine = dlg.quarantine.isChecked()
count = models.Count.objects.get(id=count_id)
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setText("Effacement des données")
# msg.setInformativeText(f"Effacement des données")
msg.setDetailedText("Les données suivantes seront supprimées:\n"
f"comptage: {count_id}\n"
f"de: {start.strftime('%d.%m.%Y')}\n"
f"à: {end.strftime('%d.%m.%Y')} inclus\n"
f"provisoires: {quarantine}\n"
f"définitives: {definitive}")
msg.setWindowTitle("Effacement des données")
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
retval = msg.exec_()
if retval == QMessageBox.Ok:
qs = models.CountDetail.objects.filter(
id_count=count,
timestamp__range=(start, end + timedelta(days=1)),
)
if not definitive:
qs = qs.filter(status=definitions.IMPORT_STATUS_QUARANTINE)
if not quarantine:
qs = qs.filter(status=definitions.IMPORT_STATUS_DEFINITIVE)
qs.delete()
def enable_actions_if_needed(self):
"""Enable actions if the plugin is connected to the db
otherwise disable them"""
self.create_new_action.setEnabled(True)
self.select_edit_action.setEnabled(True)
self.import_files_action.setEnabled(True)
self.validate_imported_files.setEnabled(True)
self.import_ics_action.setEnabled(True)
self.filter_action.setEnabled(True)
self.yearly_report_action.setEnabled(True)
def is_section_highlighted(self, section_id):
return self.layers.is_section_highlighted(section_id)
@qgsfunction(args="auto", group="Comptages")
def is_highlighted(feature, parent):
"""Used by section layer to apply a style to the sections related to a
count"""
# Call the method of the current instance of the plugin
return plugins['comptages'].is_section_highlighted(
feature.attribute('id'))
@qgsfunction(args="auto", group="Comptages")
def check_dates(feature, parent):
"""Used by count layer to show if a count was during a special
period"""
return plugins['comptages'].layers.check_dates(
feature.attribute('start_process_date'),
feature.attribute('end_process_date'))
class ProfilesPlugin(object):
def __init__(self, iface):
self.iface = iface
QSettings().setValue('/UI/Customization/enabled', False)
try:
from profiles.tests import testerplugin
from qgistester.tests import addTestModule
addTestModule(testerplugin, 'Profiles plugin')
except:
pass
self.userProfileAction = None
self.profilesMenu = None
iface.initializationCompleted.connect(self.initProfile)
def unload(self):
if self.profilesMenu is not None:
self.profilesMenu.deleteLater()
self.iface.removePluginMenu(self.tr('Profiles'), self.autoloadAction)
self.iface.removePluginMenu(self.tr('Profiles'), self.saveProfileAction)
try:
from profiles.tests import testerplugin
from qgistester.tests import removeTestModule
removeTestModule(testerplugin, 'Profiles plugin')
except:
pass
saveCurrentPluginState()
def initGui(self):
self.addMenus()
def addMenus(self):
if self.profilesMenu is not None:
self.profilesMenu.clear()
self.actions = defaultdict(list)
settings = QSettings()
defaultProfile = settings.value('profilesplugin/LastProfile', 'Default', str)
autoLoad = settings.value('profilesplugin/AutoLoad', False, bool)
for k, v in profiles.items():
action = QAction(k, self.iface.mainWindow())
action.setCheckable(True)
if k == defaultProfile and autoLoad:
action.setChecked(True)
action.triggered.connect(lambda _, menuName=k: self.applyProfile(menuName))
action.setObjectName('mProfilesPlugin_' + k)
self.actions[v.group].append(action)
actions = self.iface.mainWindow().menuBar().actions()
settingsMenu = None
self.profilesGroup = QActionGroup(self.iface.mainWindow())
if self.profilesMenu is None:
for action in actions:
if action.menu().objectName() == 'mSettingsMenu':
settingsMenu = action.menu()
self.profilesMenu = QMenu(settingsMenu)
self.profilesMenu.setObjectName('mProfilesPlugin')
self.profilesMenu.setTitle(self.tr('Profiles'))
settingsMenu.addMenu(self.profilesMenu)
break
if self.profilesMenu is not None:
for k,v in self.actions.items():
submenu = QMenu(self.profilesMenu)
submenu.setObjectName('mProfilesPlugin_submenu_' + k)
submenu.setTitle(k)
for action in v:
self.profilesGroup.addAction(action)
submenu.addAction(action)
self.profilesMenu.addMenu(submenu)
self.profilesMenu.addSeparator()
settings = QSettings()
def _setAutoLoad():
settings.setValue('profilesplugin/AutoLoad', self.autoloadAction.isChecked())
self.autoloadAction = QAction(self.tr('Auto-load last profile on QGIS start'), iface.mainWindow())
self.autoloadAction.setCheckable(True)
autoLoad = settings.value('profilesplugin/AutoLoad', False, bool)
self.autoloadAction.setChecked(autoLoad)
self.autoloadAction.setObjectName('mProfilesPluginAutoLoad')
self.autoloadAction.triggered.connect(_setAutoLoad)
self.profilesMenu.addAction(self.autoloadAction)
self.saveProfileAction = QAction(self.tr('Profiles manager...'),
self.iface.mainWindow())
self.saveProfileAction.setObjectName('mProfilesPluginProfilesManager')
self.saveProfileAction.triggered.connect(self.saveProfile)
self.profilesMenu.addAction(self.saveProfileAction)
self.showHelpAction = QAction(self.tr('Help'), self.iface.mainWindow())
self.showHelpAction.setIcon(QgsApplication.getThemeIcon('/mActionHelpContents.svg'))
self.showHelpAction.setObjectName('mProfilesPluginShowHelp')
self.showHelpAction.triggered.connect(self.showHelp)
self.profilesMenu.addAction(self.showHelpAction)
def applyProfile(self, name):
profile = profiles.get(name)
applyProfile(profile)
def initProfile(self):
settings = QSettings()
autoLoad = settings.value('profilesplugin/AutoLoad', False, bool)
if autoLoad:
profileName = settings.value('profilesplugin/LastProfile', '', str)
if profileName in profiles:
profile = profiles[profileName]
if not profile.hasToInstallPlugins():
applyProfile(profile, False)
def saveProfile(self):
dlg = ProfileManager(iface.mainWindow())
dlg.exec_()
def showHelp(self):
if not QDesktopServices.openUrl(
QUrl('file://{}'.format(os.path.join(pluginPath, 'docs', 'html', 'index.html')))):
QMessageBox.warning(None,
self.tr('Error'),
self.tr('Can not open help URL in browser'))
def tr(self, text):
return QCoreApplication.translate('Profiles', text)
class VertexListWidget(QgsPanelWidget, WIDGET):
"""
A table for vertex lists
"""
label_filter_changed = pyqtSignal()
vertex_symbol_changed = pyqtSignal()
vertex_text_format_changed = pyqtSignal()
selected_vertex_changed = pyqtSignal(int, object)
def __init__(self, map_canvas: QgsMapCanvas, parent: QWidget = None):
super().__init__(parent)
self.setupUi(self)
self._block_feature_changes = False
self.map_canvas = map_canvas
self.vertex_model = VertexModel()
self.table_view.setModel(self.vertex_model)
self.table_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.feature_model = FeatureModel()
self.feature_combo.setModel(self.feature_model)
self.feature_combo.currentIndexChanged.connect(
self._active_feature_changed)
self.settings_action = QAction(self.tr('Settings'), self)
self.settings_action.setIcon(
QgsApplication.getThemeIcon('/propertyicons/settings.svg'))
self.settings_action.triggered.connect(self._show_settings)
self.toolbar.addAction(self.settings_action)
self.settings_panel = None
self.layer: Optional[QgsVectorLayer] = None
self.selection: List[int] = []
self.button_zoom.clicked.connect(self._zoom_to_feature)
self.table_view.selectionModel().selectionChanged.connect(
self._vertex_selection_changed)
self.table_view.doubleClicked.connect(self._table_double_click)
self.button_zoom.setEnabled(False)
def set_selection(self, layer: Optional[QgsVectorLayer],
selection: List[int]):
"""
Sets the selection to show in the dock
"""
if layer == self.layer:
prev_feature_id = self.feature_model.data(
self.feature_model.index(self.feature_combo.currentIndex(), 0),
FeatureModel.FEATURE_ID_ROLE)
else:
prev_feature_id = None
self.layer = layer
if self.layer is not None:
self.layer_label.setText(
self.tr('{} — {} features selected').format(
layer.name(), layer.selectedFeatureCount()))
else:
self.layer_label.clear()
self._block_feature_changes = True
self.selection = selection
self.feature_model.set_feature_ids(layer, selection)
if prev_feature_id is not None:
prev_index = self.feature_model.index_from_id(prev_feature_id)
if prev_index.isValid():
self.feature_combo.setCurrentIndex(
self.feature_model.index_from_id(prev_feature_id).row())
else:
self.feature_combo.setCurrentIndex(0)
else:
self.feature_combo.setCurrentIndex(0)
self._block_feature_changes = False
self._active_feature_changed()
def _active_feature_changed(self):
"""
Triggered when the active feature is changed
"""
if self._block_feature_changes:
return
selected_index = self.feature_model.index(
self.feature_combo.currentIndex(), 0)
if selected_index.isValid():
feature = self.feature_model.data(selected_index,
FeatureModel.FEATURE_ROLE)
changed = self.vertex_model.feature is None or feature is None or self.vertex_model.feature.id(
) != feature.id()
self.vertex_model.set_feature(feature)
if feature is not None:
self.label_part_count.setText(
str(feature.geometry().constGet().numGeometries(
) if feature.geometry().isMultipart() else 1))
self.label_vertex_count.setText(
str(feature.geometry().constGet().nCoordinates()))
self.label_geometry_type.setText(
QgsWkbTypes.translatedDisplayString(
feature.geometry().wkbType()))
self.button_zoom.setEnabled(True)
else:
self.label_geometry_type.clear()
self.label_part_count.clear()
self.label_vertex_count.clear()
self.button_zoom.setEnabled(False)
if changed and feature is not None and SettingsRegistry.flash_feature(
):
self.map_canvas.flashGeometries([feature.geometry()],
self.layer.crs())
else:
self.vertex_model.set_feature(None)
self.label_geometry_type.clear()
self.label_part_count.clear()
self.label_vertex_count.clear()
self.button_zoom.setEnabled(False)
self._vertex_selection_changed()
def _show_settings(self):
"""
Shows the settings panel
"""
self.settings_panel = SettingsWidget()
self.settings_panel.panelAccepted.connect(self._update_settings)
self.settings_panel.label_filter_changed.connect(
self.label_filter_changed)
self.settings_panel.vertex_symbol_changed.connect(
self.vertex_symbol_changed)
self.settings_panel.vertex_text_format_changed.connect(
self.vertex_text_format_changed)
self.settings_panel.number_format_changed.connect(
self.vertex_model.number_format_changed)
self.openPanel(self.settings_panel)
def _update_settings(self):
"""
Updates the stored settings
"""
self.settings_panel.deleteLater()
self.settings_panel = None
def _zoom_to_feature(self):
"""
Zooms to the extent of the selected feature
"""
selected_index = self.feature_model.index(
self.feature_combo.currentIndex(), 0)
if selected_index.isValid():
feature = self.feature_model.data(selected_index,
FeatureModel.FEATURE_ROLE)
ct = QgsCoordinateTransform(
self.layer.crs(),
self.map_canvas.mapSettings().destinationCrs(),
QgsProject.instance())
try:
bounds = ct.transformBoundingBox(
feature.geometry().boundingBox())
self.map_canvas.zoomToFeatureExtent(bounds)
if SettingsRegistry.flash_feature():
self.map_canvas.flashGeometries([feature.geometry()],
self.layer.crs())
except QgsCsException:
pass
def _vertex_selection_changed(self):
"""
Triggered when the selected vertex is changed
"""
selection = self.table_view.selectionModel().selectedIndexes()
vertex_number = None
if selection:
selected_index = self.vertex_model.index(
self.table_view.selectionModel().selectedIndexes()[0].row(), 0)
if selected_index.isValid():
vertex_number = self.vertex_model.data(
selected_index, VertexModel.VERTEX_NUMBER_ROLE)
point = self.vertex_model.data(selected_index,
VertexModel.VERTEX_POINT_ROLE)
map_point = self.map_canvas.mapSettings(
).layerToMapCoordinates(self.layer, point)
if SettingsRegistry.center_on_selected():
self.map_canvas.setCenter(QgsPointXY(map_point))
self.map_canvas.refresh()
if SettingsRegistry.flash_vertex():
geom = QgsGeometry(map_point)
self.map_canvas.flashGeometries([geom])
feature_id = None
if self.vertex_model.feature is not None:
feature_id = self.vertex_model.feature.id()
self.selected_vertex_changed.emit(feature_id, vertex_number)
def _table_double_click(self, index: QModelIndex):
"""
Triggered when the table is double-clicked
"""
if not index.isValid():
return
point = self.vertex_model.data(index, VertexModel.VERTEX_POINT_ROLE)
map_point = self.map_canvas.mapSettings().layerToMapCoordinates(
self.layer, point)
self.map_canvas.setCenter(QgsPointXY(map_point))
self.map_canvas.refresh()
class ProcessingPlugin:
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(
self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
# Invalidate the locator filter for in-place when active layer changes
iface.currentLayerChanged.connect(
lambda _: self.iface.invalidateLocatorResults())
self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter()
iface.registerLocatorFilter(self.edit_features_locator_filter)
Processing.initialize()
def initGui(self):
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'),
self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(
self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(
self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin',
'Graphical &Modeler…'),
self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(
self.modelerAction,
QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QgsApplication.getThemeIcon("/mIconHistory.svg"),
QCoreApplication.translate('ProcessingPlugin', '&History…'),
self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(
self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(
self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(
self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.toolbox.processingToolbar.addSeparator()
self.editInPlaceAction = QAction(
QgsApplication.getThemeIcon("/mActionProcessSelected.svg"),
self.tr('Edit Features In-Place'), self.iface.mainWindow())
self.editInPlaceAction.setObjectName('editInPlaceFeatures')
self.editInPlaceAction.setCheckable(True)
self.editInPlaceAction.toggled.connect(self.editSelected)
self.menu.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addSeparator()
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
# In-place editing button state sync
self.iface.currentLayerChanged.connect(self.sync_in_place_button_state)
self.iface.mapCanvas().selectionChanged.connect(
self.sync_in_place_button_state)
self.iface.actionToggleEditing().triggered.connect(
partial(self.sync_in_place_button_state, None))
self.sync_in_place_button_state()
def sync_in_place_button_state(self, layer=None):
"""Synchronise the button state with layer state"""
if layer is None:
layer = self.iface.activeLayer()
old_enabled_state = self.editInPlaceAction.isEnabled()
new_enabled_state = layer is not None and layer.type(
) == QgsMapLayer.VectorLayer
self.editInPlaceAction.setEnabled(new_enabled_state)
if new_enabled_state != old_enabled_state:
self.toolbox.set_in_place_edit_mode(
new_enabled_state and self.editInPlaceAction.isChecked())
def openProcessingOptions(self):
self.iface.showOptionsDialog(self.iface.mainWindow(),
currentPage='processingOptions')
def unload(self):
self.toolbox.setVisible(False)
self.iface.removeDockWidget(self.toolbox)
self.iface.attributesToolBar().removeAction(self.toolboxAction)
self.resultsDock.setVisible(False)
self.iface.removeDockWidget(self.resultsDock)
self.toolbox.deleteLater()
self.menu.deleteLater()
# delete temporary output files
folder = QgsProcessingUtils.tempFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
# also delete temporary help files
folder = tempHelpFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.toolboxAction)
self.iface.unregisterMainWindowAction(self.modelerAction)
self.iface.unregisterMainWindowAction(self.historyAction)
self.iface.unregisterMainWindowAction(self.resultsAction)
self.iface.unregisterOptionsWidgetFactory(self.options_factory)
self.iface.deregisterLocatorFilter(self.locator_filter)
self.iface.deregisterLocatorFilter(self.edit_features_locator_filter)
self.iface.unregisterCustomDropHandler(self.drop_handler)
QgsApplication.dataItemProviderRegistry().removeProvider(
self.item_provider)
removeMenus()
Processing.deinitialize()
def openToolbox(self, show):
self.toolbox.setUserVisible(show)
def toolboxVisibilityChanged(self, visible):
self.toolboxAction.setChecked(visible)
def openModeler(self):
dlg = ModelerDialog()
dlg.update_model.connect(self.updateModel)
dlg.show()
def updateModel(self):
model_provider = QgsApplication.processingRegistry().providerById(
'model')
model_provider.refreshAlgorithms()
def openResults(self):
if self.resultsDock.isVisible():
self.resultsDock.hide()
else:
self.resultsDock.show()
def openHistory(self):
dlg = HistoryDialog()
dlg.exec_()
def tr(self, message):
return QCoreApplication.translate('ProcessingPlugin', message)
def editSelected(self, enabled):
self.toolbox.set_in_place_edit_mode(enabled)
class Plugin(QGISPluginBase):
"""docstring for Plugin"""
def __init__(self, iface):
super(Plugin, self).__init__()
self.iface = iface
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.i18nPath,
'plugin_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
def tr(self, message):
return QApplication.translate('Plugin', message)
def initGui(self):
self.paste_geometry_action = QAction(self.tr('Paste Geometry'),
self.iface.mainWindow())
self.paste_geometry_action.setIcon(
QIcon(os.path.join(self.dir, 'icon.svg')))
self.paste_geometry_action.setShortcut(QKeySequence('Ctrl+Shift+G'))
self.paste_geometry_action.setToolTip(self.tr('Paste Geometry'))
self.paste_geometry_action.setStatusTip(self.description)
self.paste_geometry_action.setEnabled(False)
self.paste_geometry_action.triggered.connect(self.pasteGeometry)
self.iface.editMenu().insertAction(
self.iface.actionDeleteSelected(),
self.paste_geometry_action,
)
self.iface.digitizeToolBar().insertAction(
self.iface.actionDeleteSelected(),
self.paste_geometry_action,
)
self.iface.currentLayerChanged.connect(self._changeCurrentLayerHandle)
self._changeCurrentLayerHandle(self.iface.activeLayer())
def unload(self):
self.iface.editMenu().removeAction(self.paste_geometry_action)
self.iface.digitizeToolBar().removeAction(self.paste_geometry_action)
self.iface.currentLayerChanged.disconnect(
self._changeCurrentLayerHandle)
def pushMessage(self, title, message, level=QGis23MessageBarLevel.Info):
self.iface.messageBar().pushMessage(title, message, level)
def pushLog(self, msg, level=QGis23MessageLogLevel.Info):
QgsMessageLog.logMessage(msg, self.name, level)
def pasteGeometry(self):
geoms = self._tryGetFeaturesGeomsFromClipBoard()
if len(geoms) > 1:
self.pushMessage(
self.tr('Paste geometry'),
self.tr('Fail to paste. Multiple features in the clipboard.'),
QGis23MessageBarLevel.Critical)
return
if len(geoms) == 0:
self.pushMessage(
self.tr('Paste geometry'),
self.tr('Nothing to paste. No features in the clipboard.'),
QGis23MessageBarLevel.Critical)
return
geom = geoms[0]
layer = self.iface.activeLayer()
selected_features = layer.selectedFeatures()
if len(selected_features) > 1:
self.pushMessage(
self.tr('Paste geometry'),
# 'Multiple features selected. Need only one.',
self.tr(
'Multiple features are selected. There should be only one.'
),
QGis23MessageBarLevel.Critical)
return
if len(selected_features) == 0:
self.pushMessage(
self.tr('Paste geometry'),
self.tr('Nowhere to paste. No target feature selected.'),
QGis23MessageBarLevel.Critical)
return
feature = selected_features[0]
if feature.geometry().type() != geom.type():
self.pushMessage(
self.tr('Paste geometry'),
self.tr('Incompatible geometries. Trying to paste %s to %s') %
(getGeomtryName(
geom.type()), getGeomtryName(feature.geometry().type())),
QGis23MessageBarLevel.Critical)
return
result = layer.changeGeometry(feature.id(), geom)
if not result:
self.pushMessage(
self.tr('Paste geometry'),
self.tr('Something is wrong. Can\'t change geometry.'),
QGis23MessageBarLevel.Critical)
return
# This is hack. It is not mandatory instruction.
# But without new features not repaint.
# May be I made something wrong above
self.iface.mapCanvas().refresh()
def _tryGetFeaturesGeomsFromClipBoard(self):
cb = QApplication.clipboard()
clipboard_text = cb.text()
if sys.version_info[0] == 2:
clipboard_text = clipboard_text.encode('utf-8')
reader = csv.DictReader(StringIO(clipboard_text), delimiter='\t')
geoms = []
for row in reader:
wkt_geom = row.get('wkt_geom')
geom = QgsGeometry.fromWkt(wkt_geom)
if not geom:
self.pushLog('Can\'t create geometry from wkt: %s' % wkt_geom)
continue
geoms.append(geom)
return geoms
def _changeCurrentLayerHandle(self, layer):
if layer and isinstance(layer, QgsVectorLayer):
layer.selectionChanged.connect(self._checkPasteAvalability)
layer.editingStarted.connect(self._checkPasteAvalability)
layer.editingStopped.connect(self._checkPasteAvalability)
self._checkPasteAvalability()
def _checkPasteAvalability(self):
layer = self.iface.activeLayer()
is_available = False
if layer and isinstance(layer, QgsVectorLayer) and layer.isEditable():
if len(layer.selectedFeatures()) == 1:
is_available = True
else:
msg = self.tr("Select a target feature!")
is_available = False
else:
msg = self.tr("Start editing a vector layer!")
is_available = False
if is_available:
if len(self._tryGetFeaturesGeomsFromClipBoard()) == 0:
msg = self.tr(
"Copy feature with the geometry you need to paste first!")
is_available = False
self.paste_geometry_action.setEnabled(is_available)
if is_available:
self.paste_geometry_action.setToolTip(self.tr('Paste Geometry'))
else:
self.paste_geometry_action.setToolTip(
"%s. %s" % (self.tr('Paste Geometry'), msg))
class ProcessingPlugin:
def __init__(self, iface):
self.iface = iface
self.options_factory = None
self.drop_handler = None
self.item_provider = None
self.locator_filter = None
self.edit_features_locator_filter = None
self.initialized = False
self.initProcessing()
def initProcessing(self):
if not self.initialized:
self.initialized = True
Processing.initialize()
def initGui(self):
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
# Invalidate the locator filter for in-place when active layer changes
iface.currentLayerChanged.connect(lambda _: self.iface.invalidateLocatorResults())
self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter()
iface.registerLocatorFilter(self.edit_features_locator_filter)
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin', 'Graphical &Modeler…'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction,
QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QgsApplication.getThemeIcon("/mIconHistory.svg"),
QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.toolbox.processingToolbar.addSeparator()
self.editInPlaceAction = QAction(
QgsApplication.getThemeIcon("/mActionProcessSelected.svg"),
self.tr('Edit Features In-Place'), self.iface.mainWindow())
self.editInPlaceAction.setObjectName('editInPlaceFeatures')
self.editInPlaceAction.setCheckable(True)
self.editInPlaceAction.toggled.connect(self.editSelected)
self.menu.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addSeparator()
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(
self.iface.firstRightStandardMenu().menuAction(), self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
# In-place editing button state sync
self.iface.currentLayerChanged.connect(self.sync_in_place_button_state)
self.iface.mapCanvas().selectionChanged.connect(self.sync_in_place_button_state)
self.iface.actionToggleEditing().triggered.connect(partial(self.sync_in_place_button_state, None))
self.sync_in_place_button_state()
def sync_in_place_button_state(self, layer=None):
"""Synchronise the button state with layer state"""
if layer is None:
layer = self.iface.activeLayer()
old_enabled_state = self.editInPlaceAction.isEnabled()
new_enabled_state = layer is not None and layer.type() == QgsMapLayerType.VectorLayer
self.editInPlaceAction.setEnabled(new_enabled_state)
if new_enabled_state != old_enabled_state:
self.toolbox.set_in_place_edit_mode(new_enabled_state and self.editInPlaceAction.isChecked())
def openProcessingOptions(self):
self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions')
def unload(self):
self.toolbox.setVisible(False)
self.iface.removeDockWidget(self.toolbox)
self.iface.attributesToolBar().removeAction(self.toolboxAction)
self.resultsDock.setVisible(False)
self.iface.removeDockWidget(self.resultsDock)
self.toolbox.deleteLater()
self.menu.deleteLater()
# delete temporary output files
folder = QgsProcessingUtils.tempFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
# also delete temporary help files
folder = tempHelpFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.toolboxAction)
self.iface.unregisterMainWindowAction(self.modelerAction)
self.iface.unregisterMainWindowAction(self.historyAction)
self.iface.unregisterMainWindowAction(self.resultsAction)
self.iface.unregisterOptionsWidgetFactory(self.options_factory)
self.iface.deregisterLocatorFilter(self.locator_filter)
self.iface.deregisterLocatorFilter(self.edit_features_locator_filter)
self.iface.unregisterCustomDropHandler(self.drop_handler)
QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider)
removeMenus()
Processing.deinitialize()
def openToolbox(self, show):
self.toolbox.setUserVisible(show)
def toolboxVisibilityChanged(self, visible):
self.toolboxAction.setChecked(visible)
def openModeler(self):
dlg = ModelerDialog()
dlg.update_model.connect(self.updateModel)
dlg.show()
def updateModel(self):
model_provider = QgsApplication.processingRegistry().providerById('model')
model_provider.refreshAlgorithms()
def openResults(self):
if self.resultsDock.isVisible():
self.resultsDock.hide()
else:
self.resultsDock.show()
def openHistory(self):
dlg = HistoryDialog()
dlg.exec_()
def tr(self, message):
return QCoreApplication.translate('ProcessingPlugin', message)
def editSelected(self, enabled):
self.toolbox.set_in_place_edit_mode(enabled)
class GeToolsPlugin:
def __init__(self, iface):
self.iface = iface
locale = QgsApplication.locale()
qmPath = '{}/i18n/getools_{}.qm'.format(pluginPath, locale)
if os.path.exists(qmPath):
self.translator = QTranslator()
self.translator.load(qmPath)
QCoreApplication.installTranslator(self.translator)
def initGui(self):
self.actionPostionToGe = QAction(self.tr('Coords to the Google Earth'), self.iface.mainWindow())
self.actionPostionToGe.setIcon(QIcon(os.path.join(pluginPath, 'icons', 'ge-click.svg')))
self.actionPostionToGe.setObjectName('gePosition')
self.actionPostionToGe.setCheckable(True)
self.actionFeaturesToGe = QAction(self.tr('Feature(s) to the Google Earth'), self.iface.mainWindow())
self.actionFeaturesToGe.setIcon(QIcon(os.path.join(pluginPath, 'icons', 'ge-selected.svg')))
self.actionFeaturesToGe.setObjectName('geFeatures')
self.actionFeaturesToGe.setCheckable(True)
self.actionVectorToGe = QAction(self.tr('Vector layer to the Google Earth'), self.iface.mainWindow())
self.actionVectorToGe.setIcon(QIcon(os.path.join(pluginPath, 'icons', 'ge-export-vector.svg')))
self.actionVectorToGe.setObjectName('geVector')
self.actionRasterToGe = QAction(self.tr('Raster layer to the Google Earth'), self.iface.mainWindow())
self.actionRasterToGe.setIcon(QIcon(os.path.join(pluginPath, 'icons', 'ge-export-raster.svg')))
self.actionRasterToGe.setObjectName('geRaster')
self.actionSettings = QAction(self.tr('Settings…'), self.iface.mainWindow())
self.actionSettings.setIcon(QgsApplication.getThemeIcon('/mActionOptions.svg'))
self.actionSettings.setObjectName('geSettings')
self.actionAbout = QAction(self.tr('About GETools…'), self.iface.mainWindow())
self.actionAbout.setIcon(QgsApplication.getThemeIcon('/mActionHelpContents.svg'))
self.actionAbout.setObjectName('geAbout')
self.iface.addPluginToMenu(self.tr('GETools'), self.actionPostionToGe)
self.iface.addPluginToMenu(self.tr('GETools'), self.actionFeaturesToGe)
self.iface.addPluginToMenu(self.tr('GETools'), self.actionVectorToGe)
self.iface.addPluginToMenu(self.tr('GETools'), self.actionRasterToGe)
self.iface.addPluginToMenu(self.tr('GETools'), self.actionSettings)
self.iface.addPluginToMenu(self.tr('GETools'), self.actionAbout)
self.iface.addVectorToolBarIcon(self.actionPostionToGe)
self.iface.addVectorToolBarIcon(self.actionFeaturesToGe)
self.iface.addVectorToolBarIcon(self.actionVectorToGe)
self.iface.addRasterToolBarIcon(self.actionRasterToGe)
self.actionPostionToGe.triggered.connect(self.selectPosition)
self.actionFeaturesToGe.triggered.connect(self.selectFeatures)
self.actionVectorToGe.triggered.connect(self.exportLayer)
self.actionRasterToGe.triggered.connect(self.exportLayer)
self.actionSettings.triggered.connect(self.settings)
self.actionAbout.triggered.connect(self.about)
self.toolClick = MapToolClick(self.iface.mapCanvas())
self.toolClick.setAction(self.actionPostionToGe)
self.toolClick.canvasClicked.connect(self.exportPosition)
self.toolSelect = MapToolSelect(self.iface.mapCanvas())
self.toolSelect.setAction(self.actionFeaturesToGe)
self.toolSelect.featuresSelected.connect(self.exportFeatures)
self.iface.currentLayerChanged.connect(self.toggleButtons)
self.taskManager = QgsApplication.taskManager()
def unload(self):
self.iface.removeVectorToolBarIcon(self.actionPostionToGe)
self.iface.removeVectorToolBarIcon(self.actionFeaturesToGe)
self.iface.removeVectorToolBarIcon(self.actionVectorToGe)
self.iface.removeRasterToolBarIcon(self.actionRasterToGe)
self.iface.removePluginMenu(self.tr('GETools'), self.actionPostionToGe)
self.iface.removePluginMenu(self.tr('GETools'), self.actionFeaturesToGe)
self.iface.removePluginMenu(self.tr('GETools'), self.actionVectorToGe)
self.iface.removePluginMenu(self.tr('GETools'), self.actionRasterToGe)
self.iface.removePluginMenu(self.tr('GETools'), self.actionSettings)
self.iface.removePluginMenu(self.tr('GETools'), self.actionAbout)
if self.iface.mapCanvas().mapTool() == self.toolClick:
self.iface.mapCanvas().unsetMapTool(self.toolClick)
if self.iface.mapCanvas().mapTool() == self.toolSelect:
self.iface.mapCanvas().unsetMapTool(self.toolSelect)
del self.toolClick
del self.toolSelect
utils.removeTempFiles()
def settings(self):
dlg = OptionsDialog(self.iface.mainWindow())
dlg.exec_()
def about(self):
dlg = AboutDialog()
dlg.exec_()
def tr(self, text):
return QCoreApplication.translate('GeTools', text)
def selectPosition(self):
self.iface.mapCanvas().setMapTool(self.toolClick)
def selectFeatures(self):
self.iface.mapCanvas().setMapTool(self.toolSelect)
def toggleButtons(self, layer):
if layer and layer.type() == QgsMapLayer.VectorLayer:
self.actionFeaturesToGe.setEnabled(True)
self.actionVectorToGe.setEnabled(True)
self.actionRasterToGe.setEnabled(False)
elif layer and layer.type() == QgsMapLayer.RasterLayer:
self.actionFeaturesToGe.setEnabled(False)
self.actionVectorToGe.setEnabled(False)
self.actionRasterToGe.setEnabled(True)
else:
self.actionFeaturesToGe.setEnabled(False)
self.actionVectorToGe.setEnabled(False)
self.actionRasterToGe.setEnabled(False)
def exportPosition(self, point, button):
task = KmlWriterTask(point)
task.exportComplete.connect(self.completed)
task.errorOccurred.connect(self.errored)
self.taskManager.addTask(task)
def exportFeatures(self):
task = KmlWriterTask(self.iface.activeLayer(), True)
task.exportComplete.connect(self.completed)
task.errorOccurred.connect(self.errored)
self.taskManager.addTask(task)
def exportLayer(self):
task = KmlWriterTask(self.iface.activeLayer())
task.exportComplete.connect(self.completed)
task.errorOccurred.connect(self.errored)
self.taskManager.addTask(task)
def completed(self, fileName):
uri = QUrl.fromLocalFile(fileName)
self.iface.messageBar().pushSuccess(self.tr('GETools'), self.tr('Successfully exported to <a href="{}">{}</a>').format(uri.toString(), fileName))
QDesktopServices.openUrl(uri)
def errored(self, error):
self.iface.messageBar().pushWarning(self.tr('GETools'), error)
class ProcessingPlugin:
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
Processing.initialize()
def initGui(self):
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin', 'Graphical &Modeler…'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction,
QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QgsApplication.getThemeIcon("/mIconHistory.svg"),
QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(
self.iface.firstRightStandardMenu().menuAction(), self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
def openProcessingOptions(self):
self.iface.showOptionsDialog(self.iface.mainWindow(), currentPage='processingOptions')
def unload(self):
self.toolbox.setVisible(False)
self.iface.removeDockWidget(self.toolbox)
self.iface.attributesToolBar().removeAction(self.toolboxAction)
self.resultsDock.setVisible(False)
self.iface.removeDockWidget(self.resultsDock)
self.toolbox.deleteLater()
self.menu.deleteLater()
# delete temporary output files
folder = QgsProcessingUtils.tempFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
# also delete temporary help files
folder = tempHelpFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.toolboxAction)
self.iface.unregisterMainWindowAction(self.modelerAction)
self.iface.unregisterMainWindowAction(self.historyAction)
self.iface.unregisterMainWindowAction(self.resultsAction)
self.iface.unregisterOptionsWidgetFactory(self.options_factory)
self.iface.deregisterLocatorFilter(self.locator_filter)
self.iface.unregisterCustomDropHandler(self.drop_handler)
QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider)
removeMenus()
Processing.deinitialize()
def openToolbox(self, show):
self.toolbox.setUserVisible(show)
def toolboxVisibilityChanged(self, visible):
self.toolboxAction.setChecked(visible)
def openModeler(self):
dlg = ModelerDialog()
dlg.update_model.connect(self.updateModel)
dlg.show()
def updateModel(self):
model_provider = QgsApplication.processingRegistry().providerById('model')
model_provider.refreshAlgorithms()
def openResults(self):
if self.resultsDock.isVisible():
self.resultsDock.hide()
else:
self.resultsDock.show()
def openHistory(self):
dlg = HistoryDialog()
dlg.exec_()
def tr(self, message):
return QCoreApplication.translate('ProcessingPlugin', message)
class CreatePoint:
"""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',
'CreatePoint_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
# Obtaining the map canvas
self.canvas = iface.mapCanvas()
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/Create_Point/icon.png'
#create action that will be run by the plugin
self.action = QAction("Create Point", self.iface.mainWindow())
self.action.setIcon(QIcon(icon_path))
self.action.setWhatsThis("Create Point")
self.action.setStatusTip("Click On Map And Draw Point")
# add plugin menu to Vector toolbar
self.iface.addPluginToMenu("Create_Point", self.action)
# add icon to new menu item in Vector toolbar
self.iface.addToolBarIcon(self.action)
# connect action to the run method
self.action.triggered.connect(self.run)
# prepare map tool
self.mapTool = Map_Tool(self.iface)
#self.iface.mapCanvas().mapToolSet.connect(self.mapToolChanged)
def unload(self):
"""Actions to run when the plugin is unloaded"""
# remove menu and icon from the menu
self.iface.removeToolBarIcon(self.action)
self.iface.removePluginMenu("Create_Point", self.action)
if self.iface.mapCanvas().mapTool() == self.mapTool:
self.iface.mapCanvas().unsetMapTool(self.mapTool)
del self.mapTool
def run(self):
#Check Active Layer Present Or Not
self.active_point_layer = self.iface.mapCanvas().currentLayer()
if not self.active_point_layer:
self.iface.messageBar().pushMessage(
"Active Layer",
"No Active Layer Found Please Select Point Layer",
level=Qgis.Warning)
else:
self.layer_type = self.active_point_layer.geometryType()
if self.layer_type == QgsWkbTypes.PointGeometry:
self.iface.mapCanvas().setMapTool(self.mapTool)
else:
self.iface.messageBar().pushMessage(
"Active Layer",
"Active Layer Is Not Point Type Layer Please Select Point Layer",
level=Qgis.Warning)
