def selectExtent(self):
popupmenu = QMenu()
useCanvasExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel", 'Use Canvas Extent'),
self.btnSelect)
useLayerExtentAction = QAction(
QCoreApplication.translate("ExtentSelectionPanel", 'Use Layer Extent…'),
self.btnSelect)
selectOnCanvasAction = QAction(
self.tr('Select Extent on Canvas'), self.btnSelect)
popupmenu.addAction(useCanvasExtentAction)
popupmenu.addAction(selectOnCanvasAction)
popupmenu.addSeparator()
popupmenu.addAction(useLayerExtentAction)
selectOnCanvasAction.triggered.connect(self.selectOnCanvas)
useLayerExtentAction.triggered.connect(self.useLayerExtent)
useCanvasExtentAction.triggered.connect(self.useCanvasExtent)
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 showSnippets(self, evt):
popupmenu = QMenu()
for name, snippet in list(self.snippets.items()):
action = QAction(self.tr(name), self.btnSnippets)
action.triggered[()].connect(lambda snippet=snippet: self.editor.insert(snippet))
popupmenu.addAction(action)
popupmenu.exec_(QCursor.pos())
def showPopupMenu(self):
popup_menu = QMenu()
select_all_action = QAction(self.tr('Select All'), popup_menu)
select_all_action.triggered.connect(self.selectAll)
clear_all_action = QAction(self.tr('Clear Selection'), popup_menu)
clear_all_action.triggered.connect(self.deselectAll)
popup_menu.addAction(select_all_action)
popup_menu.addAction(clear_all_action)
popup_menu.exec_(QCursor.pos())
def context_menu(self):
"""Add context menu fonctions."""
menu = QMenu(self.dlg.layoutList)
menu.addAction(self.tr(u'Check...'), self.actionCheckLayout)
menu.addAction(self.tr(u'Uncheck...'), self.actionUncheckLayout)
menu.addSeparator()
menu.addAction(self.tr(u'Show...'), self.actionShowLayout)
menu.addAction(self.tr(u'Close...'), self.actionHideLayout)
menu.exec_(QCursor.pos())
def showPopupMenu(self):
popupmenu = QMenu()
if not (isinstance(self.param, ParameterMultipleInput) and self.param.datatype == dataobjects.TYPE_FILE):
selectLayerAction = QAction(self.tr("Select from open layers"), self.pushButton)
selectLayerAction.triggered.connect(self.showLayerSelectionDialog)
popupmenu.addAction(selectLayerAction)
selectFileAction = QAction(self.tr("Select from filesystem"), self.pushButton)
selectFileAction.triggered.connect(self.showFileSelectionDialog)
popupmenu.addAction(selectFileAction)
popupmenu.exec_(QCursor.pos())
def selectOutput(self):
if isinstance(self.parameter, QgsProcessingParameterFolderDestination):
self.selectDirectory()
else:
popupMenu = QMenu()
if not self.default_selection:
if self.parameter.flags() & QgsProcessingParameterDefinition.FlagOptional:
actionSkipOutput = QAction(
self.tr('Skip Output'), self.btnSelect)
actionSkipOutput.triggered.connect(self.skipOutput)
popupMenu.addAction(actionSkipOutput)
if isinstance(self.parameter, QgsProcessingParameterFeatureSink) \
and self.parameter.supportsNonFileBasedOutput():
# use memory layers for temporary layers if supported
actionSaveToTemp = QAction(
self.tr('Create Temporary Layer'), self.btnSelect)
else:
actionSaveToTemp = QAction(
self.tr('Save to a Temporary File'), self.btnSelect)
actionSaveToTemp.triggered.connect(self.saveToTemporary)
popupMenu.addAction(actionSaveToTemp)
actionSaveToFile = QAction(
QCoreApplication.translate('DestinationSelectionPanel', 'Save to File…'), self.btnSelect)
actionSaveToFile.triggered.connect(self.selectFile)
popupMenu.addAction(actionSaveToFile)
if isinstance(self.parameter, QgsProcessingParameterFeatureSink) \
and self.parameter.supportsNonFileBasedOutput():
actionSaveToGpkg = QAction(
QCoreApplication.translate('DestinationSelectionPanel', 'Save to GeoPackage…'), self.btnSelect)
actionSaveToGpkg.triggered.connect(self.saveToGeopackage)
popupMenu.addAction(actionSaveToGpkg)
actionSaveToPostGIS = QAction(
QCoreApplication.translate('DestinationSelectionPanel', 'Save to PostGIS Table…'), self.btnSelect)
actionSaveToPostGIS.triggered.connect(self.saveToPostGIS)
settings = QgsSettings()
settings.beginGroup('/PostgreSQL/connections/')
names = settings.childGroups()
settings.endGroup()
actionSaveToPostGIS.setEnabled(bool(names))
popupMenu.addAction(actionSaveToPostGIS)
actionSetEncoding = QAction(
QCoreApplication.translate('DestinationSelectionPanel', 'Change File Encoding ({})…').format(self.encoding), self.btnSelect)
actionSetEncoding.triggered.connect(self.selectEncoding)
popupMenu.addAction(actionSetEncoding)
popupMenu.exec_(QCursor.pos())
def selectOutput(self):
if isinstance(self.parameter, QgsProcessingParameterFolderDestination):
self.selectDirectory()
else:
popupMenu = QMenu()
if self.parameter.flags() & QgsProcessingParameterDefinition.FlagOptional:
actionSkipOutput = QAction(
self.tr('Skip output'), self.btnSelect)
actionSkipOutput.triggered.connect(self.skipOutput)
popupMenu.addAction(actionSkipOutput)
if isinstance(self.parameter, QgsProcessingParameterFeatureSink) \
and self.alg.provider().supportsNonFileBasedOutput():
# use memory layers for temporary layers if supported
actionSaveToTemp = QAction(
self.tr('Create temporary layer'), self.btnSelect)
else:
actionSaveToTemp = QAction(
self.tr('Save to a temporary file'), self.btnSelect)
actionSaveToTemp.triggered.connect(self.saveToTemporary)
popupMenu.addAction(actionSaveToTemp)
actionSaveToFile = QAction(
self.tr('Save to file...'), self.btnSelect)
actionSaveToFile.triggered.connect(self.selectFile)
popupMenu.addAction(actionSaveToFile)
actionShowExpressionsBuilder = QAction(
self.tr('Use expression...'), self.btnSelect)
actionShowExpressionsBuilder.triggered.connect(self.showExpressionsBuilder)
popupMenu.addAction(actionShowExpressionsBuilder)
if isinstance(self.parameter, QgsProcessingParameterFeatureSink) \
and self.alg.provider().supportsNonFileBasedOutput():
actionSaveToSpatialite = QAction(
self.tr('Save to SpatiaLite table...'), self.btnSelect)
actionSaveToSpatialite.triggered.connect(self.saveToSpatialite)
popupMenu.addAction(actionSaveToSpatialite)
actionSaveToPostGIS = QAction(
self.tr('Save to PostGIS table...'), self.btnSelect)
actionSaveToPostGIS.triggered.connect(self.saveToPostGIS)
settings = QgsSettings()
settings.beginGroup('/PostgreSQL/connections/')
names = settings.childGroups()
settings.endGroup()
actionSaveToPostGIS.setEnabled(bool(names))
popupMenu.addAction(actionSaveToPostGIS)
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)
popupmenu.exec_(QCursor.pos())
def showPopupMenu(self):
popupmenu = QMenu()
if (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 showPopupMenu(self):
popupmenu = QMenu()
if not (isinstance(self.param, QgsProcessingParameterMultipleLayers) and
self.param.layerType == dataobjects.TYPE_FILE):
selectLayerAction = QAction(
QCoreApplication.translate('BatchInputSelectionPanel', 'Select from Open Layers…'), self.pushButton)
selectLayerAction.triggered.connect(self.showLayerSelectionDialog)
popupmenu.addAction(selectLayerAction)
selectFileAction = QAction(
QCoreApplication.translate('BatchInputSelectionPanel', 'Select from File System…'), self.pushButton)
selectFileAction.triggered.connect(self.showFileSelectionDialog)
popupmenu.addAction(selectFileAction)
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 selectOutput(self):
if isinstance(self.output, OutputDirectory):
self.selectDirectory()
else:
popupMenu = QMenu()
if isinstance(self.output, OutputVector) \
and self.alg.provider.supportsNonFileBasedOutput():
# use memory layers for temporary layers if supported
actionSaveToTemp = QAction(
self.tr('Create temporary layer'), self.btnSelect)
else:
actionSaveToTemp = QAction(
self.tr('Save to a temporary file'), self.btnSelect)
actionSaveToTemp.triggered.connect(self.saveToTemporary)
popupMenu.addAction(actionSaveToTemp)
actionSaveToFile = QAction(
self.tr('Save to file...'), self.btnSelect)
actionSaveToFile.triggered.connect(self.selectFile)
popupMenu.addAction(actionSaveToFile)
actionShowExpressionsBuilder = QAction(
self.tr('Use expression...'), self.btnSelect)
actionShowExpressionsBuilder.triggered.connect(self.showExpressionsBuilder)
popupMenu.addAction(actionShowExpressionsBuilder)
if isinstance(self.output, OutputVector) \
and self.alg.provider.supportsNonFileBasedOutput():
actionSaveToSpatialite = QAction(
self.tr('Save to Spatialite table...'), self.btnSelect)
actionSaveToSpatialite.triggered.connect(self.saveToSpatialite)
popupMenu.addAction(actionSaveToSpatialite)
actionSaveToPostGIS = QAction(
self.tr('Save to PostGIS table...'), self.btnSelect)
actionSaveToPostGIS.triggered.connect(self.saveToPostGIS)
settings = QSettings()
settings.beginGroup('/PostgreSQL/connections/')
names = settings.childGroups()
settings.endGroup()
actionSaveToPostGIS.setEnabled(bool(names))
popupMenu.addAction(actionSaveToPostGIS)
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.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 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.optional:
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 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 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 printHelp(self):
QToolTip.showText(QCursor.pos(), tla.formatTooltip(
self.superParent.helps['contactListManagerWindow'][self.sender().objectName()]),
None)
def get_layers_from_coordinates(self, point, rb_list, tab_type=None):
cursor = QCursor()
x = cursor.pos().x()
y = cursor.pos().y()
click_point = QPoint(x + 5, y + 5)
visible_layers = get_visible_layers(as_list=True)
scale_zoom = self.iface.mapCanvas().scale()
# Get layers under mouse clicked
extras = f'"pointClickCoords":{{"xcoord":{point.x()}, "ycoord":{point.y()}}}, '
extras += f'"visibleLayers":{visible_layers}, '
extras += f'"zoomScale":{scale_zoom} '
body = create_body(extras=extras)
json_result = self.controller.get_json(
'gw_fct_getlayersfromcoordinates',
body,
rubber_band=self.rubber_band)
if not json_result:
return False
# hide QMenu identify if no feature under mouse
len_layers = len(json_result['body']['data']['layersNames'])
if len_layers == 0:
return False
self.icon_folder = self.plugin_dir + '/icons/'
# Right click main QMenu
main_menu = QMenu()
# Create one menu for each layer
for layer in json_result['body']['data']['layersNames']:
layer_name = self.controller.get_layer_by_tablename(
layer['layerName'])
icon_path = self.icon_folder + layer['icon'] + '.png'
if os.path.exists(str(icon_path)):
icon = QIcon(icon_path)
sub_menu = main_menu.addMenu(icon, layer_name.name())
else:
sub_menu = main_menu.addMenu(layer_name.name())
# Create one QAction for each id
for feature in layer['ids']:
action = QAction(str(feature['id']), None)
sub_menu.addAction(action)
action.triggered.connect(
partial(self.get_info_from_selected_id, action, tab_type))
action.hovered.connect(
partial(self.draw_by_action, feature, rb_list))
main_menu.addSeparator()
# Identify all
cont = 0
for layer in json_result['body']['data']['layersNames']:
cont += len(layer['ids'])
action = QAction(f'Identify all ({cont})', None)
action.hovered.connect(partial(self.identify_all, json_result,
rb_list))
main_menu.addAction(action)
main_menu.addSeparator()
main_menu.exec_(click_point)
def selectOutput(self):
popupMenu = QMenu()
if not self.default_selection:
if self.parameter.flags(
) & QgsProcessingParameterDefinition.FlagOptional:
actionSkipOutput = QAction(self.tr('Skip Output'),
self.btnSelect)
actionSkipOutput.triggered.connect(self.skipOutput)
popupMenu.addAction(actionSkipOutput)
if isinstance(self.parameter, QgsProcessingParameterFeatureSink) \
and self.parameter.supportsNonFileBasedOutput():
# use memory layers for temporary layers if supported
actionSaveToTemp = QAction(self.tr('Create Temporary Layer'),
self.btnSelect)
elif isinstance(self.parameter,
QgsProcessingParameterFolderDestination):
actionSaveToTemp = QAction(
self.tr('Save to a Temporary Directory'), self.btnSelect)
else:
actionSaveToTemp = QAction(self.tr('Save to a Temporary File'),
self.btnSelect)
actionSaveToTemp.triggered.connect(self.saveToTemporary)
popupMenu.addAction(actionSaveToTemp)
if isinstance(self.parameter, QgsProcessingParameterFolderDestination):
actionSaveToFile = QAction(
QCoreApplication.translate('DestinationSelectionPanel',
'Save to Directory…'),
self.btnSelect)
actionSaveToFile.triggered.connect(self.selectDirectory)
else:
actionSaveToFile = QAction(
QCoreApplication.translate('DestinationSelectionPanel',
'Save to File…'), self.btnSelect)
actionSaveToFile.triggered.connect(self.selectFile)
popupMenu.addAction(actionSaveToFile)
if isinstance(self.parameter, QgsProcessingParameterFeatureSink) \
and self.parameter.supportsNonFileBasedOutput():
actionSaveToGpkg = QAction(
QCoreApplication.translate('DestinationSelectionPanel',
'Save to GeoPackage…'),
self.btnSelect)
actionSaveToGpkg.triggered.connect(self.saveToGeopackage)
popupMenu.addAction(actionSaveToGpkg)
actionSaveToPostGIS = QAction(
QCoreApplication.translate('DestinationSelectionPanel',
'Save to PostGIS Table…'),
self.btnSelect)
actionSaveToPostGIS.triggered.connect(self.saveToPostGIS)
settings = QgsSettings()
settings.beginGroup('/PostgreSQL/connections/')
names = settings.childGroups()
settings.endGroup()
actionSaveToPostGIS.setEnabled(bool(names))
popupMenu.addAction(actionSaveToPostGIS)
actionSetEncoding = QAction(
QCoreApplication.translate('DestinationSelectionPanel',
'Change File Encoding ({})…').format(
self.encoding), self.btnSelect)
actionSetEncoding.triggered.connect(self.selectEncoding)
popupMenu.addAction(actionSetEncoding)
popupMenu.exec_(QCursor.pos())
def printHelp(self):
QToolTip.showText(
QCursor.pos(),
tla.formatTooltip(self.superParent.superParent.
helps['chooseGeographicExtentOnMapDialog'][
self.sender().objectName()]), None)
def printHelp(self):
QToolTip.showText(
QCursor.pos(),
tla.formatTooltip(
self.superParent.superParent.helps['chooseFreeKeywordDialog'][
self.sender().objectName()]), None)
def _add_child_layer(self):
# Create main menu and get cursor click position
main_menu = QMenu()
cursor = QCursor()
x = cursor.pos().x()
y = cursor.pos().y()
click_point = QPoint(x + 5, y + 5)
# Get load layers
layer_list = []
for layer in QgsProject.instance().mapLayers().values():
layer_list.append(tools_qgis.get_layer_source_table_name(layer))
body = tools_gw.create_body()
json_result = tools_gw.execute_procedure('gw_fct_getaddlayervalues',
body)
if not json_result or json_result['status'] == 'Failed':
return False
dict_menu = {}
for field in json_result['body']['data']['fields']:
if field['context'] is not None:
context = json.loads(field['context'])
if 'level_1' in context and context['level_1'] not in dict_menu:
menu_level_1 = main_menu.addMenu(f"{context['level_1']}")
dict_menu[context['level_1']] = menu_level_1
if 'level_2' in context and f"{context['level_1']}_{context['level_2']}" not in dict_menu:
menu_level_2 = dict_menu[context['level_1']].addMenu(
f"{context['level_2']}")
dict_menu[
f"{context['level_1']}_{context['level_2']}"] = menu_level_2
if 'level_3' in context and f"{context['level_1']}_{context['level_2']}_{context['level_3']}" not in dict_menu:
menu_level_3 = dict_menu[
f"{context['level_1']}_{context['level_2']}"].addMenu(
f"{context['level_3']}")
dict_menu[
f"{context['level_1']}_{context['level_2']}_{context['level_3']}"] = menu_level_3
if 'level_3' in context:
if f"{context['level_1']}_{context['level_2']}_{context['level_3']}_load_all" not in dict_menu:
action = QAction(
"Load all",
dict_menu[
f"{context['level_1']}_{context['level_2']}_{context['level_3']}"],
checkable=True)
action.triggered.connect(
partial(
self._manage_load_all,
fields=json_result['body']['data']['fields'],
group=context['level_1'],
sub_group=context['level_2'],
sub_sub_group=context['level_3']))
dict_menu[
f"{context['level_1']}_{context['level_2']}_{context['level_3']}"].addAction(
action)
dict_menu[
f"{context['level_1']}_{context['level_2']}_{context['level_3']}_load_all"] = True
action = QAction(
field['layerName'],
dict_menu[
f"{context['level_1']}_{context['level_2']}_{context['level_3']}"],
checkable=True)
dict_menu[
f"{context['level_1']}_{context['level_2']}_{context['level_3']}"].addAction(
action)
else:
if f"{context['level_1']}_{context['level_2']}_load_all" not in dict_menu:
action = QAction(
"Load all",
dict_menu[
f"{context['level_1']}_{context['level_2']}"],
checkable=True)
action.triggered.connect(
partial(
self._manage_load_all,
fields=json_result['body']['data']['fields'],
group=context['level_1'],
sub_group=context['level_2']))
dict_menu[
f"{context['level_1']}_{context['level_2']}"].addAction(
action)
dict_menu[
f"{context['level_1']}_{context['level_2']}_load_all"] = True
action = QAction(
field['layerName'],
dict_menu[
f"{context['level_1']}_{context['level_2']}"],
checkable=True)
dict_menu[
f"{context['level_1']}_{context['level_2']}"].addAction(
action)
if f"{field['tableName']}" in layer_list:
action.setChecked(True)
layer_name = field['tableName']
if field['geomField'] == "None":
the_geom = None
else:
the_geom = field['geomField']
geom_field = field['tableId']
style_id = field['style_id']
group = context['level_1']
sub_group = context['level_2']
action.triggered.connect(
partial(self._check_action_ischecked, layer_name, the_geom,
geom_field, group, sub_group, style_id))
main_menu.exec_(click_point)
def clicked_event(self):
# Create main menu and get cursor click position
main_menu = QMenu()
cursor = QCursor()
x = cursor.pos().x()
y = cursor.pos().y()
click_point = QPoint(x + 5, y + 5)
schema_name = self.schema_name.replace('"', '')
# Get parent layers
sql = (
"SELECT distinct ( CASE parent_layer WHEN 'v_edit_node' THEN 'Node' "
"WHEN 'v_edit_arc' THEN 'Arc' WHEN 'v_edit_connec' THEN 'Connec' "
"WHEN 'v_edit_gully' THEN 'Gully' END ), parent_layer FROM cat_feature "
"ORDER BY parent_layer")
parent_layers = self.controller.get_rows(sql)
for parent_layer in parent_layers:
# Get child layers
sql = (
f"SELECT DISTINCT(child_layer), lower(feature_type), cat_feature.id as alias, style as style_id, "
f" group_layer "
f" FROM cat_feature "
f" LEFT JOIN config_table ON config_table.id = child_layer "
f"WHERE parent_layer = '{parent_layer[1]}' "
f"AND child_layer IN ("
f" SELECT table_name FROM information_schema.tables"
f" WHERE table_schema = '{schema_name}')"
f" ORDER BY child_layer")
child_layers = self.controller.get_rows(sql)
if not child_layers: continue
# Create sub menu
sub_menu = main_menu.addMenu(str(parent_layer[0]))
child_layers.insert(
0,
['Load all', 'Load all', 'Load all', 'Load all', 'Load all'])
for child_layer in child_layers:
# Create actions
action = QAction(str(child_layer[2]), sub_menu, checkable=True)
# Get load layers and create child layers menu (actions)
layers_list = []
layers = self.iface.mapCanvas().layers()
for layer in layers:
layers_list.append(str(layer.name()))
if str(child_layer[0]) in layers_list:
action.setChecked(True)
sub_menu.addAction(action)
if child_layer[0] == 'Load all':
action.triggered.connect(
partial(from_postgres_to_toc,
child_layers=child_layers))
else:
layer_name = child_layer[0]
the_geom = "the_geom"
geom_field = child_layer[1] + "_id"
style_id = child_layer[3]
group = child_layer[4] if child_layer[
4] is not None else 'GW Layers'
action.triggered.connect(
partial(from_postgres_to_toc, layer_name, the_geom,
geom_field, None, group, style_id))
main_menu.exec_(click_point)
def printHelp(self):
QToolTip.showText(
QCursor.pos(),
tla.formatTooltip(self.superParent.helps['distributionPanel'][
self.sender().objectName()]), None)
