def initGui(self):
menuBar = self.iface.mainWindow().menuBar()
self.menu = menuBar.findChild(QMenu, 'locationLab')
if self.menu is None:
self.menu = QMenu(menuBar)
self.menu.setObjectName('locationLab')
self.menu.setTitle(u'&Location Lab')
menuBar.insertMenu(
self.iface.firstRightStandardMenu().menuAction(), self.menu)
self.add_action(':/plugins/LocationLab/catchments/catchments.png',
text=self.tr(u'Catchments'),
callback=self.catchmentsModule.show)
self.add_action(':/plugins/LocationLab/geocoder/geocoder.png',
text=self.tr(u'Geocoder'),
callback=self.geocoderModule.show)
self.menu.addSeparator()
self.add_action(':/plugins/LocationLab/catchments/info.png',
text=self.tr(u'Info'),
callback=self.infoModule.show)
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(self.tr('Use layer/canvas extent'),
self.btnSelect)
selectOnCanvasAction = QAction(self.tr('Select extent on canvas'),
self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
useMincoveringExtentAction = QAction(
self.tr('Use min covering extent from input layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(self.tr('Use layer/canvas extent'),
self.btnSelect)
selectOnCanvasAction = QAction(self.tr('Select extent on canvas'),
self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.canUseAutoExtent():
useMincoveringExtentAction = QAction(
self.tr('Use min covering extent from input layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
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 contextMenuEvent(self, ev):
index = self.indexAt(ev.pos())
if not index.isValid():
return
if index != self.currentIndex():
self.itemChanged(index)
item = self.currentItem()
menu = QMenu(self)
if isinstance(item, (Table, Schema)):
menu.addAction(QCoreApplication.translate("DBTree", "Rename…"),
self.rename)
menu.addAction(QCoreApplication.translate("DBTree", "Delete…"),
self.delete)
if isinstance(item, Table) and item.canBeAddedToCanvas():
menu.addSeparator()
menu.addAction(self.tr("Add to Canvas"), self.addLayer)
item.addExtraContextMenuEntries(menu)
elif isinstance(item, DBPlugin):
if item.database() is not None:
menu.addAction(self.tr("Re-connect"), self.reconnect)
menu.addAction(self.tr("Remove"), self.delete)
elif not index.parent().isValid() and item.typeName() in ("spatialite",
"gpkg"):
menu.addAction(
QCoreApplication.translate("DBTree", "New Connection…"),
self.newConnection)
if not menu.isEmpty():
menu.exec_(ev.globalPos())
menu.deleteLater()
def showPopupMenu(self, point):
item = self.algorithmTree.itemAt(point)
popupmenu = QMenu()
if isinstance(item, TreeAlgorithmItem):
alg = item.alg
executeAction = QAction(
QCoreApplication.translate('ProcessingToolbox', 'Execute…'),
self.algorithmTree)
executeAction.triggered.connect(self.executeAlgorithm)
popupmenu.addAction(executeAction)
if alg.flags() & QgsProcessingAlgorithm.FlagSupportsBatch:
executeBatchAction = QAction(
QCoreApplication.translate('ProcessingToolbox',
'Execute as Batch Process…'),
self.algorithmTree)
executeBatchAction.triggered.connect(
self.executeAlgorithmAsBatchProcess)
popupmenu.addAction(executeBatchAction)
popupmenu.addSeparator()
editRenderingStylesAction = QAction(
QCoreApplication.translate(
'ProcessingToolbox', 'Edit Rendering Styles for Outputs…'),
self.algorithmTree)
editRenderingStylesAction.triggered.connect(
self.editRenderingStyles)
popupmenu.addAction(editRenderingStylesAction)
actions = ProviderContextMenuActions.actions
if len(actions) > 0:
popupmenu.addSeparator()
for action in actions:
action.setData(item.alg, self)
if action.isEnabled():
contextMenuAction = QAction(action.name,
self.algorithmTree)
contextMenuAction.triggered.connect(action.execute)
popupmenu.addAction(contextMenuAction)
popupmenu.exec_(self.algorithmTree.mapToGlobal(point))
def add_user_button(self):
user_menu = QMenu()
self.acct_act = QAction(QIcon(EXT_LINK), 'Account', user_menu)
self.acct_act.triggered[bool].connect(
lambda: QDesktopServices.openUrl(QUrl(ACCOUNT_URL)))
user_menu.addAction(self.acct_act)
self.logout_act = QAction('Logout', user_menu)
self.logout_act.triggered[bool].connect(self.logout)
user_menu.addAction(self.logout_act)
self.user_button = QToolButton()
self.user_button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.user_button.setIcon(
QIcon(os.path.join(plugin_path, "resources", "account.svg"), ))
self.user_button.setMenu(user_menu)
self.user_button.setPopupMode(QToolButton.MenuButtonPopup)
# Also show menu on click, to keep disclosure triangle visible
self.user_button.clicked.connect(self.user_button.showMenu)
self.toolbar.addWidget(self.user_button)
def showPopupMenu(self):
popupmenu = QMenu()
isLayerParam = isinstance(self.param,
(QgsProcessingParameterRasterLayer,
QgsProcessingParameterVectorLayer,
QgsProcessingParameterMeshLayer,
QgsProcessingParameterFeatureSource))
if isLayerParam or (
isinstance(self.param, QgsProcessingParameterMultipleLayers)
and self.param.layerType() != QgsProcessing.TypeFile):
selectLayerAction = QAction(self.tr('Select from Open Layers…'),
self.pushButton)
selectLayerAction.triggered.connect(self.showLayerSelectionDialog)
popupmenu.addAction(selectLayerAction)
selectFileAction = QAction(self.tr('Select from File System…'),
self.pushButton)
selectFileAction.triggered.connect(self.showFileSelectionDialog)
popupmenu.addAction(selectFileAction)
popupmenu.exec_(QCursor.pos())
def createPropertyPerspectiveContextMenu(self, position):
menu = QMenu()
item = self.treeWidget.itemAt(position)
if item:
if item.text(0) != '':
menu.addAction(self.tr('Update selected setting'),
self.updateSelectedSetting)
menu.addAction(self.tr('Clone selected setting'),
self.cloneSelectedSetting)
menu.addAction(self.tr('Manage selected setting'),
self.manageSelectedSetting)
menu.addAction(
self.tr('Uninstall selected setting on all databases'),
self.uninstallSettings)
menu.addAction(self.tr('Delete selected setting'),
self.deleteSelectedSetting)
elif item.text(1) != '':
menu.addAction(self.tr('Manage Settings on database'),
self.manageDbSettings)
menu.addAction(
self.tr('Uninstall selected setting on selected database'),
self.uninstallSettings)
menu.exec_(self.treeWidget.viewport().mapToGlobal(position))
def mobileShapeContextMenu(self, pos):
menu = QMenu(self.lineEditMobileShape)
vesselAction = menu.addAction(self.tr('Vessel'))
rovAction = menu.addAction(self.tr('ROV'))
auvAction = menu.addAction(self.tr('AUV'))
arrowAction = menu.addAction(self.tr('Arrow'))
selectedAction = menu.exec_(self.lineEditMobileShape.mapToGlobal(pos))
if selectedAction == vesselAction:
self.lineEditMobileShape.setText(
u'((0, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.5), (-0.5, -0.3))'
)
elif selectedAction == rovAction:
self.lineEditMobileShape.setText(
u'((0.3, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.5), (-0.5, -0.3), (-0.3, -0.5))'
)
elif selectedAction == auvAction:
self.lineEditMobileShape.setText(
u'((0, -0.5), (0.4, -0.3), (0.5, -0.3), (0.5, -0.2), (0.4, -0.2), (0.4, 0.3), (0.5, 0.3), (0.5, 0.4), (0.4, 0.4), (0.0, 0.5), \
(-0.4, 0.4), (-0.5, 0.4), (-0.5, 0.3), (-0.4, 0.3), (-0.4, -0.2), (-0.5, -0.2), (-0.5, -0.3), (-0.4, -0.3))'
)
elif selectedAction == arrowAction:
self.lineEditMobileShape.setText(
u'((0, -0.5), (0.5, 0.5), (0, 0), (-0.5, 0.5))')
def menu(self):
menu = QMenu()
copyUrlAction = QAction(icon("copy.png"), "Copy repository URL", menu)
copyUrlAction.triggered.connect(self.copyUrl)
menu.addAction(copyUrlAction)
refreshAction = QAction(icon("refresh.svg"), "Refresh", menu)
refreshAction.triggered.connect(self.refreshContent)
menu.addAction(refreshAction)
deleteAction = QAction(
QgsApplication.getThemeIcon('/mActionDeleteSelected.svg'),
"Delete", menu)
deleteAction.triggered.connect(self.delete)
menu.addAction(deleteAction)
remotesAction = QAction("Manage remote connections", menu)
remotesAction.triggered.connect(self.manageRemotes)
menu.addAction(remotesAction)
pullAction = QAction(icon("pull.svg"), "Pull", menu)
pullAction.triggered.connect(self.pull)
menu.addAction(pullAction)
pushAction = QAction(icon("push.svg"), "Push", menu)
pushAction.triggered.connect(self.push)
menu.addAction(pushAction)
return menu
def addMenu(self, name, filename, domdoc):
# main project menu
menuBar = self.iface.editMenu().parentWidget()
projectMenu = QMenu('&' + name, menuBar)
projectMenu.setToolTipsVisible(self.optionTooltip)
projectAction = menuBar.addMenu(projectMenu)
self.menubarActions.append(projectAction)
self.absolute = self.isAbsolute(domdoc)
self.projectpath = QFileInfo(os.path.realpath(filename)).path()
mapLayersDict = getMapLayersDict(domdoc)
# build menu on legend schema
legends = domdoc.elementsByTagName("layer-tree-group")
if legends.length() > 0:
node = legends.item(0)
if node:
node = node.firstChild()
self.addMenuItem(filename, node, projectMenu, domdoc,
mapLayersDict)
def dat_PF_table_menu(self, position):
""" Add a contextual menu to the fixed points table view """
# Create the menu
menu = QMenu()
# Menu options
set_pfp = menu.addAction(u"Fixe en planimétrie")
set_pfa = menu.addAction(u"Fixe en altimétrie")
rmv_pfp = menu.addAction(u"Variable en planimétrie")
rmv_pfa = menu.addAction(u"Variable en altimétrie")
menu.addSeparator()
sel_all = menu.addAction(u"Sélectionner toutes les lignes")
action = menu.exec_(self.tblDatPF.mapToGlobal(position))
# Define the menu actions
if action == set_pfp:
self.dat_PF_set(u"pfp", 0)
if action == set_pfa:
self.dat_PF_set(u"pfa", 0)
if action == rmv_pfp:
self.dat_PF_set(u"pfp", 1)
if action == rmv_pfa:
self.dat_PF_set(u"pfa", 1)
if action == sel_all:
self.tblDatPF.selectAll()
def _setup_info_button(self):
info_menu = QMenu(self)
self._p_sec_act = add_menu_section_action('Planet', info_menu)
p_com_act = QAction(QIcon(EXT_LINK), 'planet.com', info_menu)
p_com_act.triggered[bool].connect(
lambda: self._open_link_with_browser(PLANET_COM))
info_menu.addAction(p_com_act)
p_explorer_act = QAction(QIcon(EXT_LINK), 'Planet Explorer web app',
info_menu)
p_explorer_act.triggered[bool].connect(
lambda: self._open_link_with_browser(PLANET_EXPLORER))
info_menu.addAction(p_explorer_act)
p_sat_act = QAction(QIcon(EXT_LINK), 'Satellite specs PDF', info_menu)
p_sat_act.triggered[bool].connect(
lambda: self._open_link_with_browser(SAT_SPECS_PDF))
info_menu.addAction(p_sat_act)
p_support_act = QAction(QIcon(EXT_LINK), 'Support Community',
info_menu)
p_support_act.triggered[bool].connect(
lambda: self._open_link_with_browser(PLANET_SUPPORT_COMMUNITY))
info_menu.addAction(p_support_act)
self._info_act = add_menu_section_action('Documentation', info_menu)
terms_act = QAction('Terms', info_menu)
terms_act.triggered[bool].connect(self._show_terms)
info_menu.addAction(terms_act)
self.btnInfo.setMenu(info_menu)
# Also show menu on click, to keep disclosure triangle visible
self.btnInfo.clicked.connect(self.btnInfo.showMenu)
def showPopupMenu(self, point):
item = self.algorithmTree.itemAt(point)
popupmenu = QMenu()
if isinstance(item, TreeAlgorithmItem):
alg = item.alg
executeAction = QAction(self.tr('Execute'), self.algorithmTree)
executeAction.triggered.connect(self.executeAlgorithm)
popupmenu.addAction(executeAction)
if alg.flags() & QgsProcessingAlgorithm.FlagSupportsBatch:
executeBatchAction = QAction(
self.tr('Execute as batch process'), self.algorithmTree)
executeBatchAction.triggered.connect(
self.executeAlgorithmAsBatchProcess)
popupmenu.addAction(executeBatchAction)
popupmenu.addSeparator()
editRenderingStylesAction = QAction(
self.tr('Edit rendering styles for outputs'),
self.algorithmTree)
editRenderingStylesAction.triggered.connect(
self.editRenderingStyles)
popupmenu.addAction(editRenderingStylesAction)
if isinstance(item, (TreeAlgorithmItem, TreeActionItem)):
data = item.alg if isinstance(item,
TreeAlgorithmItem) else item.action
actions = ProviderContextMenuActions.actions
if len(actions) > 0:
popupmenu.addSeparator()
for action in actions:
action.setData(data, self)
if action.isEnabled():
contextMenuAction = QAction(action.name,
self.algorithmTree)
contextMenuAction.triggered.connect(action.execute)
popupmenu.addAction(contextMenuAction)
popupmenu.exec_(self.algorithmTree.mapToGlobal(point))
def _read_ini_file(self, root, ini_file_path, category):
try:
ini_full_path = os.path.join(root, ini_file_path)
parser = configparser.ConfigParser()
with codecs.open(ini_full_path, 'r', 'utf-8') as ini_file:
if hasattr(parser, "read_file"):
parser.read_file(ini_file)
else:
parser.readfp(ini_file)
#read config
group_id = parser.get('general', 'id')
group_alias = parser.get('ui', 'alias')
icon_file = ConfigReaderHelper.try_read_config(
parser, 'ui', 'icon')
group_icon_path = os.path.join(
root, icon_file) if icon_file else None
#try read translations
posible_trans = parser.items('ui')
for key, val in posible_trans:
if type(key) is unicode and key == 'alias[%s]' % self.locale:
self.translator.append(group_alias, val)
break
#create menu
group_menu = QMenu(self.tr(group_alias))
group_menu.setIcon(QIcon(group_icon_path))
#append to all groups
# set contrib&user
self.groups[group_id] = GroupInfo(group_id, group_alias,
group_icon_path, ini_full_path,
group_menu, category)
except Exception as e:
error_message = self.tr(
'Group INI file can\'t be parsed: ') + e.message
QgsMessageLog.logMessage(error_message,
level=QgsMessageLog.CRITICAL)
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):
"""Init the user interface."""
self.initProcessing()
icon = QIcon(resources_path('icons', 'QuickOSM.svg'))
self.help_action = QAction(icon, 'QuickOSM', self.iface.mainWindow())
self.iface.pluginHelpMenu().addAction(self.help_action)
self.help_action.triggered.connect(self.show_help)
# Add the toolbar
self.toolbar = self.iface.addToolBar('QuickOSM')
self.toolbar.setObjectName('QuickOSM')
# Setup menu
self.quickosm_menu = QMenu('QuickOSM')
self.quickosm_menu.setIcon(icon)
self.vector_menu = self.iface.vectorMenu()
self.vector_menu.addMenu(self.quickosm_menu)
# Main window
self.main_window_action = QAction(icon, 'QuickOSM…', self.iface.mainWindow())
# noinspection PyUnresolvedReferences
self.main_window_action.triggered.connect(self.open_dialog)
self.toolbar.addAction(self.main_window_action)
# Action JOSM
self.josm_action = QAction(
QIcon(resources_path('icons', 'josm_icon.svg')),
tr('JOSM Remote'),
self.iface.mainWindow())
self.josm_action.triggered.connect(self.josm_remote)
self.toolbar.addAction(self.josm_action)
# Insert in the good order
self.quickosm_menu.addAction(self.main_window_action)
self.quickosm_menu.addAction(self.josm_action)
def setup_panel(self):
super().setup_panel()
self.dialog.combo_query_type_q.addItem(tr('Canvas Extent'), 'canvas')
self.dialog.combo_query_type_q.addItem(tr('Layer Extent'), 'layer')
self.dialog.combo_query_type_q.currentIndexChanged.connect(
self.query_type_updated)
highlighter = XMLHighlighter(self.dialog.text_query.document())
self.dialog.text_query.cursorPositionChanged.connect(
highlighter.rehighlight)
self.dialog.text_query.cursorPositionChanged.connect(
self.allow_nominatim_or_extent)
self.dialog.button_overpass_turbo.setIcon(
QIcon(resources_path('icons', 'turbo.png')))
self.dialog.button_overpass_turbo.clicked.connect(open_overpass_turbo)
# Setup menu for documentation
popup_menu = QMenu()
map_features_action = QAction(
'Map Features', self.dialog.button_documentation)
# noinspection PyUnresolvedReferences
map_features_action.triggered.connect(open_map_features)
popup_menu.addAction(map_features_action)
overpass_action = QAction('Overpass', self.dialog.button_documentation)
# noinspection PyUnresolvedReferences
overpass_action.triggered.connect(open_doc_overpass)
popup_menu.addAction(overpass_action)
self.dialog.button_documentation.setMenu(popup_menu)
self.dialog.run_buttons[self.panel].clicked.connect(self.run)
self.dialog.button_generate_query.clicked.connect(self.generate_query)
self.dialog.button_box_q.button(QDialogButtonBox.Reset).clicked.connect(
self.dialog.reset_form)
self.allow_nominatim_or_extent()
self.query_type_updated()
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)
def _create_run_test_action(self):
"""Create action for running tests (developer mode, non final only)."""
if self.hide_developer_buttons:
return
default_package = str(setting('testPackage', 'safe',
expected_type=str))
msg = self.tr('Run tests in %s' % default_package)
self.test_button = QToolButton()
self.test_button.setMenu(QMenu())
self.test_button.setPopupMode(QToolButton.MenuButtonPopup)
icon = resources_path('img', 'icons', 'run-tests.svg')
self.action_run_tests = QAction(QIcon(icon), msg,
self.iface.mainWindow())
self.action_run_tests.setStatusTip(msg)
self.action_run_tests.setWhatsThis(msg)
self.action_run_tests.triggered.connect(self.run_tests)
self.test_button.menu().addAction(self.action_run_tests)
self.test_button.setDefaultAction(self.action_run_tests)
self.action_select_package = QAction(QIcon(icon),
self.tr('Select package'),
self.iface.mainWindow())
self.action_select_package.setStatusTip(self.tr('Select Test Package'))
self.action_select_package.setWhatsThis(self.tr('Select Test Package'))
self.action_select_package.triggered.connect(self.select_test_package)
self.test_button.menu().addAction(self.action_select_package)
self.toolbar.addWidget(self.test_button)
self.add_action(self.action_run_tests, add_to_toolbar=False)
self.add_action(self.action_select_package, add_to_toolbar=False)
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',
'QWeather_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&QWeather')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'QWeather')
self.toolbar.setObjectName(u'QWeather')
self.key1 = '9Q2gyTzBLVGVSTWdoJnM9Y29uc'
self.toolButton = QToolButton()
self.toolButton.setMenu(QMenu())
self.toolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.toolbar.addWidget(self.toolButton)
def selectExtent(self):
popupmenu = QMenu()
useLayerExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel",
'Use Layer/Canvas Extent…'),
self.btnSelect)
selectOnCanvasAction = QAction(self.tr('Select Extent on Canvas'),
self.btnSelect)
popupmenu.addAction(useLayerExtentAction)
popupmenu.addAction(selectOnCanvasAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
if self.param.flags() & QgsProcessingParameterDefinition.FlagOptional:
useMincoveringExtentAction = QAction(
self.tr('Use Min Covering Extent from Input Layers'),
self.btnSelect)
useMincoveringExtentAction.triggered.connect(
self.useMinCoveringExtent)
popupmenu.addAction(useMincoveringExtentAction)
popupmenu.exec_(QCursor.pos())
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 contextMenuEvent(self, event):
menu = QMenu(self)
menu.addAction(self.copyLine)
menu.addAction(self.copyAll)
menu.exec_(event.globalPos())
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 initGui(self):
self.commander = None
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = self.toolbox.toggleViewAction()
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QIcon(os.path.join(cmd_folder, 'images', 'alg.png')))
self.toolboxAction.setText(self.tr('&Toolbox'))
self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T')
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'model.png')),
self.tr('Graphical &Modeler...'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M')
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'history.gif')),
self.tr('&History...'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H')
self.menu.addAction(self.historyAction)
self.configAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'config.png')),
self.tr('&Options...'), self.iface.mainWindow())
self.configAction.setObjectName('configAction')
self.configAction.triggered.connect(self.openConfig)
self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C')
self.menu.addAction(self.configAction)
self.resultsAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'results.png')),
self.tr('&Results Viewer...'), self.iface.mainWindow())
self.resultsAction.setObjectName('resultsAction')
self.resultsAction.triggered.connect(self.openResults)
self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R')
self.menu.addAction(self.resultsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.commanderAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'commander.png')),
self.tr('&Commander'), self.iface.mainWindow())
self.commanderAction.setObjectName('commanderAction')
self.commanderAction.triggered.connect(self.openCommander)
self.menu.addAction(self.commanderAction)
self.iface.registerMainWindowAction(self.commanderAction,
self.tr('Ctrl+Alt+D'))
initializeMenus()
createMenus()
def initGui(self):
# create actions
defIconPath = ":/plugins/QWater/icons/qwater.svg"
self.action = QAction(QIcon(':/plugins/QWater/icons/sizing.svg'),
'Calculate economic diameters',
self.iface.mainWindow())
self.action.setWhatsThis(
"Calculate economic pipe diameters based on flow data.")
self.settingsAction = QAction(
QIcon(':/plugins/QWater/icons/00settings.svg'), 'Settings',
self.iface.mainWindow())
self.makeModelAction = QAction(
QIcon(':/plugins/QWater/icons/makemodel.svg'), 'Make Model',
self.iface.mainWindow())
self.fillFieldsAction = QAction(
QIcon(':/plugins/QWater/icons/fields_fill.svg'), 'Fill up Fields',
self.iface.mainWindow())
self.writeInpAction = QAction(
QIcon(':/plugins/QWater/icons/epanet.svg'),
'Write EPANET INP file', self.iface.mainWindow())
self.runEpanetAction = QAction(QIcon(':/plugins/QWater/icons/run.svg'),
'Run EPANET simulation',
self.iface.mainWindow())
self.aboutAction = QAction(
QIcon(":/plugins/QWater/icons/qwater.svg"),
QCoreApplication.translate('GHydraulics', "&About"),
self.iface.mainWindow())
self.LoadStylesAction = QAction(
QIcon(":/plugins/QWater/icons/style.svg"), "Load default styles",
self.iface.mainWindow())
self.GetElevationAction = QAction(
QIcon(":/plugins/QWater/icons/getelevation.svg"),
"Get Elevation from Raster", self.iface.mainWindow())
self.vazaoAction = QAction(QIcon(':/plugins/QWater/icons/01vazao.svg'),
self.tr('Calc Flow'),
self.iface.mainWindow())
self.renameAction = QAction(
QIcon(':/plugins/QWater/icons/01rename.svg'), 'Renumber Network',
self.iface.mainWindow())
self.updateDN_Action = QAction(
QIcon(":/plugins/QWater/icons/qwater.svg"), "Update DN field",
self.iface.mainWindow())
# Connect actions to triggers
self.action.triggered.connect(self.run)
self.settingsAction.triggered.connect(self.showSettings)
self.makeModelAction.triggered.connect(self.makeModel)
self.fillFieldsAction.triggered.connect(self.fillFields)
self.writeInpAction.triggered.connect(self.writeInpFile)
self.GetElevationAction.triggered.connect(self.GetElevation)
self.updateDN_Action.triggered.connect(self.update_DN)
self.runEpanetAction.triggered.connect(self.runEpanet)
self.aboutAction.triggered.connect(self.about)
self.RenameClasse = Rename_Tools(self.iface)
self.renameAction.triggered.connect(self.RenameCall)
Qwflow = QWater_02Flow().CalcFlow
self.vazaoAction.triggered.connect(
self.VazaoClasse.CalcFlow
) #self.Vazao #ListNoDemandNodes #QWater_02Flow.CalcFlow
self.LoadStylesAction.triggered.connect(self.LoadStyles)
#Create toolbar
self.toolbar = self.iface.addToolBar('&QWater')
self.toolbar.setObjectName('&QWater')
# add toolbar buttons
self.toolbar.addAction(self.settingsAction)
self.toolbar.addAction(self.makeModelAction)
self.toolbar.addAction(self.renameAction)
self.toolbar.addAction(self.fillFieldsAction)
self.toolbar.addAction(self.vazaoAction)
self.toolbar.addAction(self.action)
self.toolbar.addAction(self.runEpanetAction)
#self.iface.addToolBarIcon(self.settingsAction)
#Add separator
self.toolbar.addSeparator()
# Add ToolButton (with Menu)
self.menuButton = QToolButton() #QPushButton()#QToolButton
self.menuButton.setMenu(QMenu())
self.menuButton.setPopupMode(QToolButton.MenuButtonPopup)
# self.menuButton.setAutoRaise(True)
m = self.menuButton.menu()
m.addAction(self.LoadStylesAction)
m.addAction(self.writeInpAction)
m.addAction(self.GetElevationAction)
m.addAction(self.updateDN_Action)
self.menuButton.setDefaultAction(self.GetElevationAction)
self.menuButtonAction = self.toolbar.addWidget(self.menuButton)
# add menu items
self.iface.addPluginToMenu("&QWater", self.settingsAction)
self.iface.addPluginToMenu('&QWater', self.makeModelAction)
self.iface.addPluginToMenu('&QWater', self.renameAction)
self.iface.addPluginToMenu('&QWater', self.fillFieldsAction)
self.iface.addPluginToMenu('&QWater', self.vazaoAction)
self.iface.addPluginToMenu("&QWater", self.action)
self.iface.addPluginToMenu('&QWater', self.runEpanetAction)
# tools submenu
self.tools_menu = QMenu('&Tools')
self.tools_menu.addAction(self.LoadStylesAction)
self.tools_menu.addAction(self.writeInpAction)
self.tools_menu.addAction(self.GetElevationAction)
self.tools_menu.addAction(self.updateDN_Action)
# Projects submenu
self.project_menu = QMenu('&Projects')
self.newProjectAction = QAction(self.iface.actionNewProject().icon(),
'New Project', self.iface.mainWindow())
self.newProjectAction.triggered.connect(self.newProject)
self.project_menu.addAction(self.newProjectAction)
self.sampleDwCmdAction = QAction(
QIcon(':/python/plugins/ghydraulic/icon.xpm'),
'Sample Darcy-Weisbach, cubic meters/day', self.iface.mainWindow())
self.sampleDwCmdAction.triggered.connect(self.openDwCmdSample)
self.project_menu.addAction(self.sampleDwCmdAction)
self.sampleDwLpsAction = QAction(
QIcon(':/python/plugins/ghydraulic/icon.xpm'),
'Sample Darcy-Weisbach, liters/second', self.iface.mainWindow())
self.sampleDwLpsAction.triggered.connect(self.openDwLpsSample)
self.project_menu.addAction(self.sampleDwLpsAction)
self.sampleHwGpmAction = QAction(
QIcon(':/python/plugins/ghydraulic/icon.xpm'),
'Sample Hazen-Williams, gallons/min', self.iface.mainWindow())
self.sampleHwGpmAction.triggered.connect(self.openHwGpmSample)
self.project_menu.addAction(self.sampleHwGpmAction)
# Back in main menu
self.iface.addPluginToMenu("&QWater", self.tools_menu.menuAction())
self.iface.addPluginToMenu("&QWater", self.project_menu.menuAction())
self.iface.addPluginToMenu("&QWater", self.aboutAction)
def __init__(self, parent=None):
super(FormWidget, self).__init__(parent)
self.setupUi(self)
self.form = None
self.iconlabel.mouseReleaseEvent = self.change_icon
self._currentwidgetid = ''
self.fieldsmodel = QgsFieldModel()
self.widgetmodel = WidgetsModel()
self.widgetmodel.rowsMoved.connect(self._widget_moved)
self.possiblewidgetsmodel = QStandardItemModel()
self.formlayersmodel = QgsLayerModel(watchregistry=True)
self.formlayers = CaptureLayerFilter()
self.formlayers.setSourceModel(self.formlayersmodel)
self.layerCombo.setModel(self.formlayers)
self.useablewidgets.setModel(self.possiblewidgetsmodel)
self.fieldList.setModel(self.fieldsmodel)
self.userwidgets.setModel(self.widgetmodel)
self.userwidgets.selectionModel().currentChanged.connect(self.load_widget)
self.widgetmodel.rowsRemoved.connect(self.set_widget_config_state)
self.widgetmodel.rowsInserted.connect(self.set_widget_config_state)
self.widgetmodel.modelReset.connect(self.set_widget_config_state)
self.addWidgetButton.pressed.connect(self.newwidget)
self.addSectionButton.pressed.connect(self.add_section)
self.removeWidgetButton.pressed.connect(self.removewidget)
self.formfolderLabel.linkActivated.connect(self.openformfolder)
self.expressionButton.clicked.connect(self.opendefaultexpression)
self.expressionButton_2.clicked.connect(self.opendefaultexpression_advanced)
self.fieldList.currentIndexChanged.connect(self.updatewidgetname)
self.fieldwarninglabel.hide()
self.formtab.currentChanged.connect(self.formtabchanged)
for item, data in readonlyvalues:
self.readonlyCombo.addItem(item, data)
for item, data in defaultevents:
self.defaultEventsCombo.addItem(item, data)
self.loadwidgettypes()
self.formLabelText.textChanged.connect(self.form_name_changed)
self.newStyleCheck.stateChanged.connect(self.form_style_changed)
self.layerCombo.currentIndexChanged.connect(self.layer_updated)
# Gross but ok for now.
self.blockWidgets = [
self.fieldList,
self.nameText,
self.sectionNameText,
self.useablewidgets,
self.hiddenCheck,
self.requiredCheck,
self.readonlyCombo,
self.defaultEventsCombo,
self.defaultvalueText,
self.defaultLayerCombo,
self.defaultFieldCombo,
self.defaultValueExpression,
self.savevalueCheck
]
for widget in self.blockWidgets:
self._connect_save_event(widget)
self.blockWidgetSignels(True)
self.useablewidgets.currentIndexChanged.connect(self.swapwidgetconfig)
menu = QMenu("Field Actions")
action = menu.addAction("Auto add all fields")
action.triggered.connect(self.auto_add_fields)
self.addWidgetButton.setMenu(menu)
self.addWidgetButton.setPopupMode(QToolButton.MenuButtonPopup)
self.defaultLayerCombo.layerChanged.connect(self.defaultFieldCombo.setLayer)
self.addEvent.pressed.connect(self.addEventItem)
self.btnDeleteForm.pressed.connect(ConfigEvents.deleteForm.emit)
def canvasReleaseEvent(self, event):
# if not self.mouse_clicked:
# return
if event.button() == Qt.LeftButton:
# Update rubber bands
self.rubber_band.addPoint(
(self.snapped_vertex
if self.snapped_vertex is not None else self.mouse_pt), True)
if self.first_click:
self.rubber_band.addPoint(
(self.snapped_vertex if self.snapped_vertex is not None
else self.mouse_pt), True)
self.first_click = not self.first_click
elif event.button() == Qt.RightButton:
# try:
pipe_band_geom = self.rubber_band.asGeometry()
# No rubber band geometry and feature snapped: pop the context menu
if self.rubber_band.size(
) == 0 and self.snapped_feat_id is not None:
menu = QMenu()
section_action = menu.addAction('Section...') # TODO: softcode
diameter_action = menu.addAction(
'Change diameter...') # TODO: softcode
action = menu.exec_(self.iface.mapCanvas().mapToGlobal(
QPoint(event.pos().x(),
event.pos().y())))
pipe_ft = vector_utils.get_feats_by_id(self.params.pipes_vlay,
self.snapped_feat_id)[0]
if action == section_action:
if self.params.dem_rlay is None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'No DEM selected. Cannot edit section.',
Qgis.Warning, 5) # TODO: softcode
else:
# Check whether the pipe is all inside the DEM
pipe_pts = pipe_ft.geometry().asPolyline()
for pt in pipe_pts:
if not self.params.dem_rlay.extent().contains(pt):
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Some pipe vertices fall outside of the DEM. Cannot edit section.',
Qgis.Warning, 5) # TODO: softcode
return
# Check whether the start/end nodes have an elevation value
(start_node_ft,
end_node_ft) = NetworkUtils.find_start_end_nodes(
self.params, pipe_ft.geometry())
start_node_elev = start_node_ft.attribute(
Junction.field_name_elev)
end_node_elev = end_node_ft.attribute(
Junction.field_name_elev)
if start_node_elev == NULL or end_node_elev == NULL:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Missing elevation value in start or end node attributes. Cannot edit section.',
Qgis.Warning, 5) # TODO: softcode
return
pipe_dialog = PipeSectionDialog(
self.iface.mainWindow(), self.iface, self.params,
pipe_ft)
pipe_dialog.exec_()
elif action == diameter_action:
old_diam = pipe_ft.attribute(Pipe.field_name_diameter)
self.diameter_dialog = DiameterDialog(
self.iface.mainWindow(), self.params, old_diam)
self.diameter_dialog.exec_() # Exec creates modal dialog
new_diameter = self.diameter_dialog.get_diameter()
if new_diameter is None:
return
# Update pipe diameter
vector_utils.update_attribute(self.params.pipes_vlay,
pipe_ft,
Pipe.field_name_diameter,
new_diameter)
# Check if a valve is present
adj_valves = NetworkUtils.find_links_adjacent_to_link(
self.params, self.params.pipes_vlay, pipe_ft, True,
True, False)
if adj_valves['valves']:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Valves detected on the pipe: need to update their diameters too.',
Qgis.Warning, 5) # TODO: softcode
return
# There's a rubber band: create new pipe
if pipe_band_geom is not None:
#XPSS ADDED - transform rubber band CRS
canvas_crs = self.canvas().mapSettings().destinationCrs()
#pipes_vlay = Parameters().pipes_vlay()
#print(pipes_vlay)
qepanet_crs = self.params.pipes_vlay.sourceCrs()
crs_transform = QgsCoordinateTransform(canvas_crs, qepanet_crs,
QgsProject.instance())
pipe_band_geom.transform(crs_transform)
# Finalize line
rubberband_pts = pipe_band_geom.asPolyline()[:-1]
if len(rubberband_pts) == 0:
self.iface.mapCanvas().refresh()
return
rubberband_pts = self.remove_duplicated_point(rubberband_pts)
if len(rubberband_pts) < 2:
self.rubber_band.reset()
return
# Check whether the pipe points are located on existing nodes
junct_nrs = [0]
for p in range(1, len(rubberband_pts) - 1):
overlapping_nodes = NetworkUtils.find_overlapping_nodes(
self.params, rubberband_pts[p])
if overlapping_nodes['junctions'] or overlapping_nodes[
'reservoirs'] or overlapping_nodes['tanks']:
junct_nrs.append(p)
junct_nrs.append(len(rubberband_pts) - 1)
new_pipes_nr = len(junct_nrs) - 1
new_pipes_fts = []
new_pipes_eids = []
for np in range(new_pipes_nr):
pipe_eid = NetworkUtils.find_next_id(
self.params.pipes_vlay, Pipe.prefix) # TODO: softcode
#demand = float(self.data_dock.txt_pipe_demand.text())
length_units = 'm' #TODO soft code
diameter = float(self.data_dock.cbo_pipe_dia.\
currentText())
diameter_units = self.data_dock.cbo_pipe_dia_units.\
currentText()
#loss = float(self.data_dock.txt_pipe_loss.text())
#status = self.data_dock.cbo_pipe_status.currentText()
material = self.data_dock.cbo_pipe_mtl.currentText()
roughness = float(self.data_dock.txt_roughness.text())
#pipe_desc = self.data_dock.txt_pipe_desc.text()
#pipe_tag = self.data_dock.cbo_pipe_tag.currentText()
num_edu = 1
zone_id = 0
velocity = 0
velocity_units = 'm/s'
frictionloss = 0
frictionloss_units = 'm'
pipe_ft = LinkHandler.create_new_pipe(
self.params, pipe_eid, length_units, diameter,
diameter_units, 0, roughness, " ", material,
rubberband_pts[junct_nrs[np]:junct_nrs[np + 1] + 1],
True, " ", " ", num_edu, zone_id, velocity,
velocity_units, frictionloss, frictionloss_units)
self.rubber_band.reset()
new_pipes_fts.append(pipe_ft)
new_pipes_eids.append(pipe_eid)
# emitter_coeff_s = self.data_dock.txt_junction_emit_coeff.text()
#
# if emitter_coeff_s is None or emitter_coeff_s == '':
# emitter_coeff = float(0)
# else:
# emitter_coeff = float(self.data_dock.txt_junction_emit_coeff.text())
# # Description
# junction_desc = self.data_dock.txt_junction_desc.text()
#
# # Tag
# junction_tag = self.data_dock.cbo_junction_tag.currentText()
zone_end = 0
pressure = 0
pressure_units = self.data_dock.cbo_rpt_units_pressure.currentText(
)
# Create start and end node, if they don't exist
(start_junction,
end_junction) = NetworkUtils.find_start_end_nodes(
self.params, new_pipes_fts[0].geometry())
new_start_junction = None
if not start_junction:
new_start_junction = rubberband_pts[0]
junction_eid = NetworkUtils.find_next_id(
self.params.junctions_vlay, Junction.prefix)
elev = raster_utils.read_layer_val_from_coord(
self.params.dem_rlay, new_start_junction, 1)
if elev is None:
elev = 0
# If elev is none, and the DEM is selected, it's better to inform the user
if self.params.dem_rlay is not None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Elevation value not available: element elevation set to 0.',
Qgis.Warning, 5) # TODO: softcode
deltaz = float(0)
#j_demand = float(self.data_dock.txt_junction_demand.text())
# pattern = self.data_dock.cbo_junction_pattern.itemData(
# self.data_dock.cbo_junction_pattern.currentIndex())
# if pattern is not None:
# pattern_id = pattern.id
# else:
# pattern_id = None
NodeHandler.create_new_junction(self.params,
new_start_junction,
junction_eid, elev, 0,
deltaz, None, 0, " ", " ",
zone_end, pressure,
pressure_units)
(start_junction,
end_junction) = NetworkUtils.find_start_end_nodes(
self.params,
new_pipes_fts[len(new_pipes_fts) - 1].geometry())
new_end_junction = None
if not end_junction:
new_end_junction = rubberband_pts[len(rubberband_pts) - 1]
junction_eid = NetworkUtils.find_next_id(
self.params.junctions_vlay, Junction.prefix)
elev = raster_utils.read_layer_val_from_coord(
self.params.dem_rlay, new_end_junction, 1)
if elev is None:
elev = 0
# If elev is none, and the DEM is selected, it's better to inform the user
if self.params.dem_rlay is not None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Elevation value not available: element elevation set to 0.',
Qgis.Warning, 5) # TODO: softcode
deltaz = float(0)
# pattern = self.data_dock.cbo_junction_pattern.itemData(
# self.data_dock.cbo_junction_pattern.currentIndex())
# if pattern is not None:
# pattern_id = pattern.id
# else:
# pattern_id = None
NodeHandler.create_new_junction(self.params,
new_end_junction,
junction_eid, elev, 0,
deltaz, None, 0, " ", " ",
zone_end, pressure,
pressure_units)
# If end or start node intersects a pipe, split it
if new_start_junction:
for pipe_ft in self.params.pipes_vlay.getFeatures():
if pipe_ft.attribute(Pipe.field_name_eid) != new_pipes_eids[0] and\
pipe_ft.geometry().distance(QgsGeometry.fromPointXY(new_start_junction)) < self.params.tolerance:
LinkHandler.split_pipe(self.params, pipe_ft,
new_start_junction)
if new_end_junction:
for pipe_ft in self.params.pipes_vlay.getFeatures():
if pipe_ft.attribute(Pipe.field_name_eid) != new_pipes_eids[-1] and\
pipe_ft.geometry().distance(QgsGeometry.fromPointXY(new_end_junction)) < self.params.tolerance:
LinkHandler.split_pipe(self.params, pipe_ft,
new_end_junction)
self.iface.mapCanvas().refresh()
