def show_task_steps(self):
self.trw_task_steps.clear()
steps = self._task.get_steps()
self.logger.debug(
__name__,
"Showing task steps in Task Panel. {} task steps found: {}.".
format(len(steps), ", ".join([s.get_name() for s in steps])))
for i, step in enumerate(steps):
children = []
step_item = QTreeWidgetItem([
QCoreApplication.translate("TaskPanelWidget",
"Step {}").format(i + 1)
])
step_item.setData(0, Qt.BackgroundRole, QBrush(GRAY_COLOR))
step_item.setToolTip(0, step.get_name())
step_item.setCheckState(
0, Qt.Checked if step.get_status() else Qt.Unchecked)
action_item = QTreeWidgetItem([step.get_name()])
action_item.setData(0, Qt.UserRole, step.get_id())
action_item.setIcon(
0, QIcon(":/Asistente-LADM-COL/resources/images/process.svg"))
action_item.setToolTip(0, step.get_description())
step_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
children.append(action_item)
step_item.addChildren(children)
self.trw_task_steps.addTopLevelItem(step_item)
for i in range(self.trw_task_steps.topLevelItemCount()):
self.trw_task_steps.topLevelItem(
i).setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable
| Qt.ItemIsSelectable)
self.trw_task_steps.topLevelItem(i).setExpanded(True)
def showCompletion(self, rows):
# Rows is an iterable of tuples like [("text",object1),("text2", object2),...]
pal = self.editor.palette()
color = pal.color(QPalette.Disabled, QPalette.WindowText)
self.popup.setUpdatesEnabled(False)
self.popup.clear()
if rows is None or len(rows) < 1:
return
for row in rows:
item = QTreeWidgetItem(self.popup)
item.setText(0, row[0])
#item.setText(1, hit['type'])
item.setTextAlignment(1, Qt.AlignRight)
item.setForeground(1, color)
item.setData(
2, Qt.UserRole, (row[1], )
) # Try immutable py obj #http://stackoverflow.com/questions/9257422/how-to-get-the-original-python-data-from-qvariant
self.popup.setCurrentItem(self.popup.topLevelItem(0))
self.popup.resizeColumnToContents(0)
#self.popup.resizeColumnToContents(1)
self.popup.adjustSize()
self.popup.setUpdatesEnabled(True)
h = self.popup.sizeHintForRow(0) * min(15, len(rows)) + 3
w = max(self.popup.width(), self.editor.width())
self.popup.resize(w, h)
self.popup.move(
self.editor.mapToGlobal(QPoint(0, self.editor.height())))
self.popup.setFocus()
self.popup.show()
def showCompletion(self, rows):
# Rows is an iterable of tuples like [("text",object1),("text2", object2),...]
pal = self.editor.palette()
color = pal.color(QPalette.Disabled, QPalette.WindowText)
self.popup.setUpdatesEnabled(False)
self.popup.clear()
if rows is None or len( rows ) < 1:
return
for row in rows:
item = QTreeWidgetItem(self.popup)
item.setText(0, row[0])
#item.setText(1, hit['type'])
item.setTextAlignment(1, Qt.AlignRight)
item.setForeground(1, color)
item.setData(2, Qt.UserRole, (row[1],)) # Try immutable py obj #http://stackoverflow.com/questions/9257422/how-to-get-the-original-python-data-from-qvariant
self.popup.setCurrentItem(self.popup.topLevelItem(0))
self.popup.resizeColumnToContents(0)
#self.popup.resizeColumnToContents(1)
self.popup.adjustSize()
self.popup.setUpdatesEnabled(True)
h = self.popup.sizeHintForRow(0) * min(15, len(rows)) + 3
w = max(self.popup.width(), self.editor.width())
self.popup.resize(w, h)
self.popup.move(self.editor.mapToGlobal(QPoint(0, self.editor.height())))
self.popup.setFocus()
self.popup.show()
def updateUiManyToOnePolymorphic(self):
layerFeature = dict()
for relation in self._polymorphicRelation.generateRelations():
layer = relation.referencingLayer()
request = relation.getRelatedFeaturesRequest(self.feature())
finalLayer = relation.referencedLayer()
for feature in layer.getFeatures(request):
if finalLayer in layerFeature:
layerFeature[finalLayer].append(feature)
else:
layerFeature[finalLayer] = [feature]
for layer in layerFeature:
treeWidgetItemLayer = QTreeWidgetItem(self.mFeaturesTreeWidget,
[layer.name()])
treeWidgetItemLayer.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Layer)
treeWidgetItemLayer.setData(0, TreeWidgetItemRole.Layer, layer)
treeWidgetItemLayer.setIcon(0, QgsIconUtils.iconForLayer(layer))
for feature in layerFeature[layer]:
treeWidgetItem = QTreeWidgetItem(treeWidgetItemLayer, [
QgsVectorLayerUtils.getFeatureDisplayString(
layerFeature, feature)
])
treeWidgetItem.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Feature)
treeWidgetItem.setData(0, TreeWidgetItemRole.Layer, layer)
treeWidgetItem.setData(0, TreeWidgetItemRole.Feature, feature)
treeWidgetItemLayer.setExpanded(True)
def fillMembers(self, subTree):
dim = subTree.data(0, 0)
for m in self.activeWfsConn.getDimensionMembers(dim).members:
item = QTreeWidgetItem(subTree)
item.setText(1, m.value)
item.setText(2, m.code)
item.setData(0, 0, m)
subTree.addChild(item)
def _populate_reporting_tab(self):
"""Populate trees about layers."""
self.tree.clear()
self.add_layer.setEnabled(False)
self.remove_layer.setEnabled(False)
self.move_up.setEnabled(False)
self.move_down.setEnabled(False)
self.tree.setColumnCount(1)
self.tree.setRootIsDecorated(False)
self.tree.setHeaderHidden(True)
analysis_branch = QTreeWidgetItem(self.tree.invisibleRootItem(),
[FROM_ANALYSIS['name']])
analysis_branch.setFont(0, bold_font)
analysis_branch.setExpanded(True)
analysis_branch.setFlags(Qt.ItemIsEnabled)
if self._multi_exposure_if:
expected = self._multi_exposure_if.output_layers_expected()
for group, layers in list(expected.items()):
group_branch = QTreeWidgetItem(analysis_branch, [group])
group_branch.setFont(0, bold_font)
group_branch.setExpanded(True)
group_branch.setFlags(Qt.ItemIsEnabled)
for layer in layers:
layer = definition(layer)
if layer.get('allowed_geometries', None):
item = QTreeWidgetItem(group_branch,
[layer.get('name')])
item.setData(0, LAYER_ORIGIN_ROLE,
FROM_ANALYSIS['key'])
item.setData(0, LAYER_PARENT_ANALYSIS_ROLE, group)
item.setData(0, LAYER_PURPOSE_KEY_OR_ID_ROLE,
layer['key'])
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
canvas_branch = QTreeWidgetItem(self.tree.invisibleRootItem(),
[FROM_CANVAS['name']])
canvas_branch.setFont(0, bold_font)
canvas_branch.setExpanded(True)
canvas_branch.setFlags(Qt.ItemIsEnabled)
# List layers from the canvas
loaded_layers = list(QgsProject.instance().mapLayers().values())
canvas_layers = self.iface.mapCanvas().layers()
flag = setting('visibleLayersOnlyFlag', expected_type=bool)
for loaded_layer in loaded_layers:
if flag and loaded_layer not in canvas_layers:
continue
title = loaded_layer.name()
item = QTreeWidgetItem(canvas_branch, [title])
item.setData(0, LAYER_ORIGIN_ROLE, FROM_CANVAS['key'])
item.setData(0, LAYER_PURPOSE_KEY_OR_ID_ROLE, loaded_layer.id())
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.tree.resizeColumnToContents(0)
def populate_classified_values(
self, unassigned_values, assigned_values, default_classes):
"""Populate lstUniqueValues and treeClasses.from the parameters.
:param unassigned_values: List of values that haven't been assigned
to a class. It will be put in self.lstUniqueValues.
:type unassigned_values: list
:param assigned_values: Dictionary with class as the key and list of
value as the value of the dictionary. It will be put in
self.treeClasses.
:type assigned_values: dict
:param default_classes: Default classes from unit.
:type default_classes: list
"""
# Populate the unique values list
self.lstUniqueValues.clear()
self.lstUniqueValues.setSelectionMode(
QAbstractItemView.ExtendedSelection)
for value in unassigned_values:
value_as_string = value is not None and str(value) or 'NULL'
list_item = QListWidgetItem(self.lstUniqueValues)
list_item.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
list_item.setData(Qt.UserRole, value)
list_item.setText(value_as_string)
self.lstUniqueValues.addItem(list_item)
# Populate assigned values tree
self.treeClasses.clear()
self.treeClasses.invisibleRootItem().setFlags(Qt.ItemIsEnabled)
for default_class in default_classes:
# Create branch for class
tree_branch = QTreeWidgetItem(self.treeClasses)
tree_branch.setFlags(Qt.ItemIsDropEnabled | Qt.ItemIsEnabled)
tree_branch.setExpanded(True)
tree_branch.setFont(0, bold_font)
if 'name' in default_class:
default_class_name = default_class['name']
else:
default_class_name = default_class['key']
tree_branch.setText(0, default_class_name)
tree_branch.setData(0, Qt.UserRole, default_class['key'])
if 'description' in default_class:
tree_branch.setToolTip(0, default_class['description'])
# Assign known values
for value in assigned_values[default_class['key']]:
string_value = value is not None and str(value) or 'NULL'
tree_leaf = QTreeWidgetItem(tree_branch)
tree_leaf.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
tree_leaf.setData(0, Qt.UserRole, value)
tree_leaf.setText(0, string_value)
def searchResultClicked(self, item):
self.dlg.layerTree.clear()
self.layersList = []
self.selected = None
data = item.data(1)
if not data:
return
for text in data.get("text"):
#TODO: Do something better with language
lang = text.get("lang")
if lang == "FI":
self.dlg.abstractBox.setText(text.get("abstractText"))
links = data.get("downloadLinks")
if links:
for link in links:
LOG("Download links")
LOG(link)
protocol = link.get("protocol")
url = link.get("url")
layers = getLayersForDownloadLink(protocol, url)
if layers.get("type") == "NA":
if link.get("url"):
layers["link"] = link.get("url")
else:
layers["link"] = data.get("catalog").get("url")
self.layersList.append(layers)
#Add handling for wms and wmts. Try to make code more reusable
treeItems = []
for index, layers in enumerate(self.layersList):
nodeTitle = links[index].get("title")
if not nodeTitle:
nodeTitle = layers.get("url")
if not nodeTitle:
nodeTitle = layers.get("link")
if not nodeTitle:
continue
treeItem = QTreeWidgetItem()
type = layers.get("type")
if type == "NA":
if not nodeTitle:
nodeTitle = layers.get("link")
treeItem.setText(0, "LINK: " + nodeTitle)
treeItem.setData(0, 1, {
"layerName": nodeTitle,
"index": index
})
elif type != "ERROR":
treeItem.setText(0, type + ": " + nodeTitle)
treeItem.addChildren(listChildNodes(layers, index))
treeItems.append(treeItem)
self.dlg.layerTree.addTopLevelItems(treeItems)
def createItem(itemRoot, name, class_id, flags, icon):
# WidgetItem
item = QTreeWidgetItem( itemRoot )
item.setText(0, name )
item.setData(0, Qt.UserRole, class_id )
checkState = Qt.Checked if class_id in self.l_class_id else Qt.Unchecked
item.setCheckState(0, checkState )
item.setFlags( flags )
item.setIcon(0, icon )
return item
def fillDimensions(self, cubeItem):
cube = cubeItem.data(0, 0)
self.treeDimensions.clear()
for dim in self.activeWfsConn.getCubeDimensions(cube):
item = QTreeWidgetItem(self.treeDimensions)
item.setIcon(0, self.style().standardIcon(QStyle.SP_ArrowDown))
item.setText(1, dim.description)
item.setText(2, dim.name)
item.setData(0, 0, dim)
self.treeDimensions.insertTopLevelItem(0, item)
def listChildNodes(layers, index):
items = []
layerList = layers.get("contents")
for layer in layerList:
item = QTreeWidgetItem()
item.setText(0, layers.get("service")[layer].title)
item.setData(0, 1, {"layerName": layer, "index": index})
items.append(item)
return items
def connect(self):
self.treeCubes.clear()
self.activeWfsConn = WFSConnection(self.wfsUrlInput.text(),
self.usernameInput.text(),
self.passwordInput.text(),
PLUGIN_NAME)
self.activeWfsConn.connect()
for cube in self.activeWfsConn.getCubes():
item = QTreeWidgetItem(self.treeCubes)
item.setText(1, cube.name)
item.setData(0, 0, cube)
self.treeCubes.insertTopLevelItem(0, item)
def load_items(self):
self.trw_quality_rules.setUpdatesEnabled(
False) # Don't render until we're ready
self.trw_quality_rules.clear()
font = QFont()
font.setBold(True)
for group, items in self.items_dict.items():
children = []
group_item = QTreeWidgetItem([group])
group_item.setData(0, Qt.BackgroundRole,
QBrush(QColor(219, 219, 219, 255)))
group_item.setData(0, Qt.FontRole, font)
icon = QIcon(":/Asistente-LADM_COL/resources/images/{}.png".format(
items['icon']))
group_item.setData(0, Qt.DecorationRole, icon)
for rule in items['rules']:
rule_item = QTreeWidgetItem([rule['text']])
rule_item.setData(0, Qt.UserRole, rule['id'])
children.append(rule_item)
group_item.addChildren(children)
self.trw_quality_rules.addTopLevelItem(group_item)
# Make group items non selectable and expanded
for i in range(self.trw_quality_rules.topLevelItemCount()):
self.trw_quality_rules.topLevelItem(i).setFlags(
Qt.ItemIsEnabled) # Not selectable
self.trw_quality_rules.topLevelItem(i).setExpanded(True)
self.trw_quality_rules.setUpdatesEnabled(True) # Now render!
def __update_available_rules(self):
self.trw_qrs.setUpdatesEnabled(False) # Don't render until we're ready
# Grab some context data
top_level_items_expanded_info = dict()
for i in range(self.trw_qrs.topLevelItemCount()):
top_level_items_expanded_info[self.trw_qrs.topLevelItem(i).text(0)] = self.trw_qrs.topLevelItem(i).isExpanded()
# Save selection
self.__update_selected_items()
# Iterate qr types adding children
self.trw_qrs.blockSignals(True) # We don't want to get itemSelectionChanged here
self.trw_qrs.clear()
self.trw_qrs.blockSignals(False)
bold_font = QFont()
bold_font.setBold(True)
sorted_types = sorted(self.__controller.get_qrs_tree_data().keys())
for type_enum in sorted_types:
children = []
type_item = QTreeWidgetItem([self.__controller.get_tr_string(type_enum)])
# Filter by search text
list_qrs = self.__filter_by_search_text(type_enum, self.txt_search.text())
for qr in list_qrs:
qr_item = QTreeWidgetItem([qr.name()])
qr_item.setData(0, Qt.UserRole, qr.id())
qr_item.setData(0, Qt.ToolTipRole, "{}\n{}".format(qr.name(), qr.id()))
children.append(qr_item)
if children:
icon_name = self.__icon_names[type_enum.value]
icon = QIcon(":/Asistente-LADM-COL/resources/images/{}".format(icon_name))
type_item.setData(0, Qt.DecorationRole, icon)
type_item.setData(0, Qt.FontRole, bold_font)
type_item.addChildren(children)
self.trw_qrs.addTopLevelItem(type_item)
# Set selection
iterator = QTreeWidgetItemIterator(self.trw_qrs, QTreeWidgetItemIterator.Selectable)
self.trw_qrs.blockSignals(True) # We don't want to get itemSelectionChanged here
while iterator.value():
item = iterator.value()
if item.data(0, Qt.UserRole) in self.__selected_items_list:
item.setSelected(True)
iterator += 1
self.trw_qrs.blockSignals(False)
# Make type items non selectable
# Set expand taking previous states into account
for i in range(self.trw_qrs.topLevelItemCount()):
self.trw_qrs.topLevelItem(i).setFlags(Qt.ItemIsEnabled) # Not selectable
self.trw_qrs.topLevelItem(i).setExpanded(top_level_items_expanded_info.get(self.trw_qrs.topLevelItem(i).text(0), True))
self.trw_qrs.setUpdatesEnabled(True) # Now render!
def fillInputsTree(self):
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(QgsApplication.instance().processingRegistry().parameterTypes(), key=lambda pt: pt.name())
for param in sortedParams:
if param.flags() & QgsProcessingParameterType.ExposeToModeler:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param.name())
paramItem.setData(0, Qt.UserRole, param.id())
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param.description())
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def fillInputsTree(self):
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(QgsApplication.instance().processingRegistry().parameterTypes(), key=lambda pt: pt.name())
for param in sortedParams:
if param.flags() & QgsProcessingParameterType.ExposeToModeler:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param.name())
paramItem.setData(0, Qt.UserRole, param.id())
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param.description())
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def create_layers_tree(layer_node):
"""Builds layers tree widget"""
widget = QTreeWidgetItem()
widget.setText(0, layer_node.get('title', layer_node['name']))
if 'layers' in layer_node:
for child_node in layer_node['layers']:
widget.addChild(create_layers_tree(child_node))
else:
widget.setData(0, Qt.UserRole, layer_node)
widget.setFlags(Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable
| Qt.ItemIsTristate)
widget.setCheckState(0, Qt.Checked)
widget.setDisabled(layer_node.get('hidden', False))
return widget
def fillInputsTree(self):
from processing.core.Processing import Processing
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(Processing.registeredParameters().items())
for param in sortedParams:
if param[1]['exposeToModeller']:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param[1]['name'])
paramItem.setData(0, Qt.UserRole, param[0])
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param[1]['description'])
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def fillInputsTree(self):
from processing.core.Processing import Processing
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(Processing.registeredParameters().items())
for param in sortedParams:
if param[1]['exposeToModeller']:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param[1]['name'])
paramItem.setData(0, Qt.UserRole, param[0])
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param[1]['description'])
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def updateUiManyToOne(self):
layer = self.relation().referencingLayer()
request = self.relation().getRelatedFeaturesRequest(self.feature())
for feature in layer.getFeatures(request):
treeWidgetItem = QTreeWidgetItem(
self.mFeaturesTreeWidget,
[QgsVectorLayerUtils.getFeatureDisplayString(layer, feature)])
treeWidgetItem.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Feature)
treeWidgetItem.setData(0, TreeWidgetItemRole.Layer, layer)
treeWidgetItem.setData(0, TreeWidgetItemRole.Feature, feature)
def _remove_layer_clicked(self):
"""Remove layer clicked."""
layer = self.list_layers_in_map_report.selectedItems()[0]
origin = layer.data(LAYER_ORIGIN_ROLE)
if origin == FROM_ANALYSIS['key']:
key = layer.data(LAYER_PURPOSE_KEY_OR_ID_ROLE)
parent = layer.data(LAYER_PARENT_ANALYSIS_ROLE)
parent_item = self.tree.findItems(
parent, Qt.MatchContains | Qt.MatchRecursive, 0)[0]
item = QTreeWidgetItem(parent_item, [definition(key)['name']])
item.setData(0, LAYER_PARENT_ANALYSIS_ROLE, parent)
else:
parent_item = self.tree.findItems(
FROM_CANVAS['name'], Qt.MatchContains | Qt.MatchRecursive,
0)[0]
item = QTreeWidgetItem(parent_item, [layer.text()])
layer_id = layer.data(LAYER_PURPOSE_KEY_OR_ID_ROLE)
item.setData(0, LAYER_PURPOSE_KEY_OR_ID_ROLE, layer_id)
item.setData(0, LAYER_ORIGIN_ROLE, origin)
index = self.list_layers_in_map_report.indexFromItem(layer)
self.list_layers_in_map_report.takeItem(index.row())
self.list_layers_in_map_report.clearSelection()
def updateUiManyToMany(self):
layer = self.relation().referencingLayer()
request = self.relation().getRelatedFeaturesRequest(self.feature())
filters = []
for feature in layer.getFeatures(request):
referencedFeatureRequest = self.nmRelation(
).getReferencedFeatureRequest(feature)
filterExpression = referencedFeatureRequest.filterExpression()
filters.append("(" + filterExpression.expression() + ")")
nmRequest = QgsFeatureRequest()
nmRequest.setFilterExpression(" OR ".join(filters))
finalLayer = self.nmRelation().referencedLayer()
for finalFeature in finalLayer.getFeatures(nmRequest):
treeWidgetItem = QTreeWidgetItem(self.mFeaturesTreeWidget, [
QgsVectorLayerUtils.getFeatureDisplayString(
finalLayer, finalFeature)
])
treeWidgetItem.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Feature)
treeWidgetItem.setData(0, TreeWidgetItemRole.Layer, finalLayer)
treeWidgetItem.setData(0, TreeWidgetItemRole.Feature, feature)
def updateUiManyToManyPolymorphic(self):
layer = self.relation().referencingLayer()
request = self.relation().getRelatedFeaturesRequest(self.feature())
layerFeature = dict()
for linkFeature in layer.getFeatures(request):
for relation in self._polymorphicRelation.generateRelations():
referencedFeatureRequest = relation.getReferencedFeatureRequest(
linkFeature)
filterExpression = referencedFeatureRequest.filterExpression()
nmRequest = QgsFeatureRequest()
nmRequest.setFilterExpression(filterExpression.expression())
finalLayer = relation.referencedLayer()
for finalFeature in finalLayer.getFeatures(nmRequest):
features = finalFeature, linkFeature
if finalLayer in layerFeature:
layerFeature[finalLayer].append(features)
else:
layerFeature[finalLayer] = [features]
for layer in layerFeature:
treeWidgetItemLayer = QTreeWidgetItem(self.mFeaturesTreeWidget,
[layer.name()])
treeWidgetItemLayer.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Layer)
treeWidgetItemLayer.setData(0, TreeWidgetItemRole.Layer, layer)
treeWidgetItemLayer.setIcon(0, QgsIconUtils.iconForLayer(layer))
for feature, linkFeature in layerFeature[layer]:
treeWidgetItem = QTreeWidgetItem(treeWidgetItemLayer, [
QgsVectorLayerUtils.getFeatureDisplayString(
layer, feature)
])
treeWidgetItem.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Feature)
treeWidgetItem.setData(0, TreeWidgetItemRole.Layer, layer)
treeWidgetItem.setData(0, TreeWidgetItemRole.Feature, feature)
treeWidgetItem.setData(0, TreeWidgetItemRole.LinkFeature,
linkFeature)
treeWidgetItemLayer.setExpanded(True)
def __update_available_rules(self):
self.trw_qrs.setUpdatesEnabled(False) # Don't render until we're ready
# Grab some context data
top_level_items_expanded_info = dict()
for i in range(self.trw_qrs.topLevelItemCount()):
top_level_items_expanded_info[self.trw_qrs.topLevelItem(i).text(
QR_COLUMN)] = self.trw_qrs.topLevelItem(i).isExpanded()
# Save selection before clearing tree to restate it later (if needed)
self.__update_selected_item()
# Iterate qr types adding children
self.trw_qrs.blockSignals(
True) # We don't want to get itemSelectionChanged here
self.trw_qrs.clear()
self.trw_qrs.blockSignals(False)
bold_font = QFont()
bold_font.setBold(True)
sorted_types = sorted(
self.__controller.get_general_results_tree_data().keys())
for type_enum in sorted_types:
children = []
type_item = QTreeWidgetItem(
[self.__controller.get_tr_string(type_enum)])
# Filter by search text
list_qrs = self.__filter_by_search_text(type_enum,
self.txt_search.text())
for qr in list_qrs:
qr_item = QTreeWidgetItem([qr.name(), ''])
qr_item.setData(QR_COLUMN, Qt.UserRole, qr.id())
qr_item.setData(QR_COLUMN, Qt.ToolTipRole,
"{}\n{}".format(qr.name(), qr.id()))
# Let's listen some QR's relevant signals to update our view when needed
self.__partial_connections.append([
qr,
qr.progress_changed.connect(
partial(self.__set_qr_progress, qr.id()))
])
self.__partial_connections.append([
qr,
qr.validation_finished.connect(
partial(self.__set_qr_validation_result, qr))
])
children.append(qr_item)
if children:
icon_name = self.__icon_names[type_enum.value]
icon = QIcon(":/Asistente-LADM-COL/resources/images/{}".format(
icon_name))
type_item.setData(0, Qt.DecorationRole, icon)
type_item.setData(0, Qt.FontRole, bold_font)
type_item.addChildren(children)
self.trw_qrs.addTopLevelItem(type_item)
# After we've set the children, we can set custom item widgets
self.__set_children_custom_widget(type_enum, type_item,
list_qrs)
else:
type_item = None
# Set selection
self.trw_qrs.blockSignals(
True) # We don't want to get itemSelectionChanged here
item = self.__get_item_by_qr_key(self.__selected_item)
if item:
item.setSelected(True)
self.trw_qrs.blockSignals(False)
# Make type items non selectable
# Set expand taking previous states into account
for i in range(self.trw_qrs.topLevelItemCount()):
self.trw_qrs.topLevelItem(i).setFlags(
Qt.ItemIsEnabled) # Not selectable
self.trw_qrs.topLevelItem(i).setExpanded(
top_level_items_expanded_info.get(
self.trw_qrs.topLevelItem(i).text(QR_COLUMN), True))
self.trw_qrs.setUpdatesEnabled(True) # Now render!
def fill_tree_with_element(widget,
treeItem,
elt,
ns_imap={},
custom_viewers={},
ns_map={}):
"""
:param widget: the QTreeWidget
:param treeItem: a QTreeWidgetItem to fill
:param elt: the XML node
:param ns_imap: an "inverse" namespace map { uri : prefix }
:param custom_viewers: a dict giving a custom viewer plugin (QWidget) for some elements {tag : constructor}
:param ns_map: a namespace map { prefix : uri }
"""
is_root = treeItem == widget.invisibleRootItem()
# tag
ns, tag = split_tag(elt.tag)
if ns and ns_imap.get(ns):
treeItem.setText(0, ns_imap[ns] + ":" + tag)
else:
treeItem.setText(0, tag)
f = treeItem.font(0)
f.setBold(True)
treeItem.setFont(0, f)
# custom viewer
if elt.tag in custom_viewers:
custom_viewer_widget, filter = custom_viewers[elt.tag]
if filter is None or elt.find(filter, ns_map) is not None:
btn = QToolButton(widget)
btn.setIcon(custom_viewer_widget.icon())
btn.setIconSize(QSize(32, 32))
def show_viewer(btn):
widget.w = custom_viewer_widget.init_from_xml(elt)
widget.w.setWindowModality(Qt.WindowModal)
widget.w.show()
btn.clicked.connect(show_viewer)
w = QWidget(widget)
l = QHBoxLayout()
l.addWidget(btn)
l.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding))
w.setLayout(l)
if is_root:
# insert an item
child = QTreeWidgetItem()
treeItem.addChild(child)
widget.setItemWidget(child, 0, w)
else:
widget.setItemWidget(treeItem, 1, w)
# attributes
for k, v in elt.attrib.items():
child = QTreeWidgetItem()
treeItem.addChild(child)
if "}" in k:
i = k.index("}")
ns = k[1:i]
# get ns prefix from ns uri
p = ns_imap.get(ns)
if p is not None:
n = p + ":" + k[i + 1:]
else:
n = k[i + 1:]
else:
n = no_prefix(k)
child.setText(0, "@" + n)
if n == "xlink:href" and v.startswith("http"):
html = QLabel(widget)
html.setOpenExternalLinks(True)
html.setTextFormat(Qt.RichText)
html.setText('<a href="{}">{}</a>'.format(v, v))
child.setData(1, Qt.UserRole, v)
widget.setItemWidget(child, 1, html)
else:
child.setText(1, v)
# text
if elt.text:
treeItem.setText(1, elt.text)
# children
for xmlChild in elt:
child = QTreeWidgetItem()
treeItem.addChild(child)
fill_tree_with_element(widget, child, xmlChild, ns_imap,
custom_viewers, ns_map)
def populate_classified_values(
unassigned_values, assigned_values, default_classes,
list_unique_values, tree_mapping_widget):
"""Populate lstUniqueValues and treeClasses.from the parameters.
:param unassigned_values: List of values that haven't been assigned
to a class. It will be put in list_unique_values.
:type unassigned_values: list
:param assigned_values: Dictionary with class as the key and list of
value as the value of the dictionary. It will be put in
tree_mapping_widget.
:type assigned_values: dict
:param default_classes: Default classes from unit.
:type default_classes: list
:param list_unique_values: List Widget for unique values
:type list_unique_values: QListWidget
:param tree_mapping_widget: Tree Widget for classifying.
:type tree_mapping_widget: QTreeWidget
"""
# Populate the unique values list
list_unique_values.clear()
list_unique_values.setSelectionMode(
QAbstractItemView.ExtendedSelection)
for value in unassigned_values:
value_as_string = value is not None and str(value) or 'NULL'
list_item = QListWidgetItem(list_unique_values)
list_item.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
list_item.setData(Qt.UserRole, value)
list_item.setText(value_as_string)
list_unique_values.addItem(list_item)
# Populate assigned values tree
tree_mapping_widget.clear()
bold_font = QFont()
bold_font.setItalic(True)
bold_font.setBold(True)
bold_font.setWeight(75)
tree_mapping_widget.invisibleRootItem().setFlags(
Qt.ItemIsEnabled)
for default_class in default_classes:
# Create branch for class
tree_branch = QTreeWidgetItem(tree_mapping_widget)
tree_branch.setFlags(
Qt.ItemIsDropEnabled | Qt.ItemIsEnabled)
tree_branch.setExpanded(True)
tree_branch.setFont(0, bold_font)
if 'name' in default_class:
default_class_name = default_class['name']
else:
default_class_name = default_class['key']
tree_branch.setText(0, default_class_name)
tree_branch.setData(0, Qt.UserRole, default_class['key'])
if 'description' in default_class:
tree_branch.setToolTip(0, default_class['description'])
# Assign known values
for value in assigned_values[default_class['key']]:
string_value = value is not None and str(value) or 'NULL'
tree_leaf = QTreeWidgetItem(tree_branch)
tree_leaf.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
tree_leaf.setData(0, Qt.UserRole, value)
tree_leaf.setText(0, string_value)
def data(self, profile_data):
"""Set data for the widget.
:param profile_data: profile data.
:type profile_data: dict
It will replace the previous data.
"""
default_profile = generate_default_profile()
self.clear()
for hazard in sorted(default_profile.keys()):
classifications = default_profile[hazard]
hazard_widget_item = QTreeWidgetItem()
hazard_widget_item.setData(0, Qt.UserRole, hazard)
hazard_widget_item.setText(0, get_name(hazard))
for classification in sorted(classifications.keys()):
# Filter out classification that doesn't support population.
# TODO(IS): This is not the best place to put the filtering.
# It's more suitable in the generate_default_profile method
# in safe/definitions/utilities.
classification_definition = definition(classification)
supported_exposures = classification_definition.get(
'exposures', [])
# Empty list means support all exposure
if supported_exposures != []:
if exposure_population not in supported_exposures:
continue
classes = classifications[classification]
classification_widget_item = QTreeWidgetItem()
classification_widget_item.setData(
0, Qt.UserRole, classification)
classification_widget_item.setText(0, get_name(classification))
hazard_widget_item.addChild(classification_widget_item)
for the_class, the_value in list(classes.items()):
the_class_widget_item = QTreeWidgetItem()
the_class_widget_item.setData(0, Qt.UserRole, the_class)
the_class_widget_item.setText(
0, get_class_name(the_class, classification))
classification_widget_item.addChild(the_class_widget_item)
# Adding widget must be happened after addChild
affected_check_box = QCheckBox(self)
# Set from profile_data if exist, else get default
profile_value = profile_data.get(
hazard, {}).get(classification, {}).get(
the_class, the_value)
affected_check_box.setChecked(profile_value['affected'])
self.setItemWidget(
the_class_widget_item, 1, affected_check_box)
displacement_rate_spinbox = PercentageSpinBox(self)
displacement_rate_spinbox.setValue(
profile_value['displacement_rate'])
displacement_rate_spinbox.setEnabled(
profile_value['affected'])
self.setItemWidget(
the_class_widget_item, 2, displacement_rate_spinbox)
# Behaviour when the check box is checked
# noinspection PyUnresolvedReferences
affected_check_box.stateChanged.connect(
displacement_rate_spinbox.setEnabled)
if hazard_widget_item.childCount() > 0:
self.widget_items.append(hazard_widget_item)
self.addTopLevelItems(self.widget_items)
self.expandAll()
def data(self, profile_data):
"""Set data for the widget.
:param profile_data: profile data.
:type profile_data: dict
It will replace the previous data.
"""
default_profile = generate_default_profile()
self.clear()
for hazard in sorted(default_profile.keys()):
classifications = default_profile[hazard]
hazard_widget_item = QTreeWidgetItem()
hazard_widget_item.setData(0, Qt.UserRole, hazard)
hazard_widget_item.setText(0, get_name(hazard))
for classification in sorted(classifications.keys()):
# Filter out classification that doesn't support population.
# TODO(IS): This is not the best place to put the filtering.
# It's more suitable in the generate_default_profile method
# in safe/definitions/utilities.
classification_definition = definition(classification)
supported_exposures = classification_definition.get(
'exposures', [])
# Empty list means support all exposure
if supported_exposures != []:
if exposure_population not in supported_exposures:
continue
classes = classifications[classification]
classification_widget_item = QTreeWidgetItem()
classification_widget_item.setData(0, Qt.UserRole,
classification)
classification_widget_item.setText(0, get_name(classification))
hazard_widget_item.addChild(classification_widget_item)
for the_class, the_value in list(classes.items()):
the_class_widget_item = QTreeWidgetItem()
the_class_widget_item.setData(0, Qt.UserRole, the_class)
the_class_widget_item.setText(
0, get_class_name(the_class, classification))
classification_widget_item.addChild(the_class_widget_item)
# Adding widget must be happened after addChild
affected_check_box = QCheckBox(self)
# Set from profile_data if exist, else get default
profile_value = profile_data.get(hazard, {}).get(
classification, {}).get(the_class, the_value)
affected_check_box.setChecked(profile_value['affected'])
self.setItemWidget(the_class_widget_item, 1,
affected_check_box)
displacement_rate_spinbox = PercentageSpinBox(self)
displacement_rate_spinbox.setValue(
profile_value['displacement_rate'])
displacement_rate_spinbox.setEnabled(
profile_value['affected'])
self.setItemWidget(the_class_widget_item, 2,
displacement_rate_spinbox)
# Behaviour when the check box is checked
# noinspection PyUnresolvedReferences
affected_check_box.stateChanged.connect(
displacement_rate_spinbox.setEnabled)
if hazard_widget_item.childCount() > 0:
self.widget_items.append(hazard_widget_item)
self.addTopLevelItems(self.widget_items)
self.expandAll()
def update_available_layers(self):
self.trw_layers.setUpdatesEnabled(
False) # Don't render until we're ready
# Grab some context data
show_domains = self.chk_show_domains.isChecked()
show_structures = self.chk_show_structures.isChecked()
show_associations = self.chk_show_associations.isChecked()
top_level_items_expanded_info = []
for i in range(self.trw_layers.topLevelItemCount()):
top_level_items_expanded_info.append(
self.trw_layers.topLevelItem(i).isExpanded())
# Save selection
self.update_selected_items()
# Iterate models adding children
self.trw_layers.blockSignals(
True) # We don't want to get itemSelectionChanged here
self.trw_layers.clear()
self.trw_layers.blockSignals(False)
sorted_models = sorted(self.models_tree.keys())
for model in sorted_models:
children = []
model_item = QTreeWidgetItem([model])
# Filter by search text
list_tables = self.filter_tables_by_search_text(
self.models_tree[model].keys(), self.txt_search_text.text())
sorted_tables = sorted(list_tables)
for table in sorted_tables:
current_table_info = self.models_tree[model][table]
if current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_DOMAIN and not show_domains \
or current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_STRUCTURE and not show_structures \
or current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_ASSOCIATION and not show_associations:
continue
table_item = QTreeWidgetItem([table])
table_item.setData(0, Qt.UserRole,
self.models_tree[model][table])
geometry_type = QgsWkbTypes().geometryType(
QgsWkbTypes().parseType(current_table_info[
QueryNames.GEOMETRY_TYPE_MODEL_BAKER])
) if current_table_info[
QueryNames.GEOMETRY_TYPE_MODEL_BAKER] else None
icon_name = self.icon_names[
3 if geometry_type is None else geometry_type]
# Is the layer already loaded in canvas?
if self.app.core.get_ladm_layer_from_qgis(
self._db,
current_table_info[QueryNames.TABLE_NAME_MODEL_BAKER],
EnumLayerRegistryType.IN_LAYER_TREE) is not None:
table_item.setText(
0, table + QCoreApplication.translate(
"LoadLayersDialog", " [already loaded]"))
table_item.setData(0, Qt.ForegroundRole,
QBrush(Qt.lightGray))
table_item.setFlags(Qt.ItemIsEnabled) # Not selectable
else: # Laye not in QGIS Layer Tree
if not current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER]: # This is a class
font = QFont()
font.setBold(True)
table_item.setData(0, Qt.FontRole, font)
if current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_DOMAIN:
icon_name = self.icon_names[4]
elif current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_STRUCTURE:
if geometry_type is None:
icon_name = self.icon_names[5]
elif current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_ASSOCIATION:
icon_name = self.icon_names[6]
icon = QIcon(":/Asistente-LADM-COL/resources/images/{}".format(
icon_name))
table_item.setData(0, Qt.DecorationRole, icon)
children.append(table_item)
model_item.addChildren(children)
self.trw_layers.addTopLevelItem(model_item)
# Set selection
iterator = QTreeWidgetItemIterator(self.trw_layers,
QTreeWidgetItemIterator.Selectable)
self.trw_layers.blockSignals(
True) # We don't want to get itemSelectionChanged here
while iterator.value():
item = iterator.value()
if item.text(0) in self.selected_items_dict:
item.setSelected(True)
iterator += 1
self.trw_layers.blockSignals(False)
# Make model items non selectable
# Set expand taking previous states into account
for i in range(self.trw_layers.topLevelItemCount()):
self.trw_layers.topLevelItem(i).setFlags(
Qt.ItemIsEnabled) # Not selectable
self.trw_layers.topLevelItem(i).setExpanded(
top_level_items_expanded_info[i]
if top_level_items_expanded_info else True)
self.trw_layers.setUpdatesEnabled(True) # Now render!
def tree_widget_item(self):
item = QTreeWidgetItem([self.name])
item.addChildren([child.tree_widget_item() for child in self.children])
item.setData(0, Qt.UserRole, deepcopy(self))
return item
def tree_widget_item(self):
item = QTreeWidgetItem([self.name])
item.setData(0, Qt.UserRole, deepcopy(self))
return item
def __setupModelData(self):
dsList = DataSourcesList().data_sources.values()
groupInfoList = GroupsList().groups
groupsItems = []
groups = []
for ds in dsList:
if ds.group in groups:
group_item = groupsItems[groups.index(ds.group)]
else:
group_item = QTreeWidgetItem()
group_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.group)
group_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
group_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole, ds.category)
group_item.setCheckState(self.COLUMN_VISIBILITY, Qt.Unchecked)
groupInfo = groupInfoList.get(ds.group)
if groupInfo is not None:
group_item.setIcon(self.COLUMN_GROUP_DS, QIcon(groupInfo.icon))
else:
group_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.group + " (%s!)" % self.tr("group not found"))
group_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole, groupInfo)
groups.append(ds.group)
groupsItems.append(group_item)
self.rootItem.addChild(group_item)
ds_item = QTreeWidgetItem()
ds_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.alias)
ds_item.setIcon(self.COLUMN_GROUP_DS, QIcon(ds.icon_path))
ds_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole, ds)
ds_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
ds_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole, ds.category)
ds_check_state = Qt.Checked
if ds.id in PluginSettings.get_hide_ds_id_list():
ds_check_state = Qt.Unchecked
ds_item.setCheckState(self.COLUMN_VISIBILITY, ds_check_state)
if group_item.childCount() != 0 and group_item.checkState(1) != ds_check_state:
group_item.setCheckState(self.COLUMN_VISIBILITY, Qt.PartiallyChecked)
else:
group_item.setCheckState(self.COLUMN_VISIBILITY, ds_check_state)
group_item.addChild(
ds_item
)
def __setupModelData(self):
dsList = DataSourcesList().data_sources.values()
groupInfoList = GroupsList().groups
groupsItems = []
groups = []
for ds in dsList:
if ds.group in groups:
group_item = groupsItems[groups.index(ds.group)]
else:
group_item = QTreeWidgetItem()
group_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole,
ds.group)
group_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
group_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole,
ds.category)
group_item.setCheckState(self.COLUMN_VISIBILITY, Qt.Unchecked)
groupInfo = groupInfoList.get(ds.group)
if groupInfo is not None:
group_item.setIcon(self.COLUMN_GROUP_DS,
QIcon(groupInfo.icon))
else:
group_item.setData(
self.COLUMN_GROUP_DS, Qt.DisplayRole,
ds.group + " (%s!)" % self.tr("group not found"))
group_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole,
groupInfo)
groups.append(ds.group)
groupsItems.append(group_item)
self.rootItem.addChild(group_item)
ds_item = QTreeWidgetItem()
ds_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.alias)
ds_item.setIcon(self.COLUMN_GROUP_DS, QIcon(ds.icon_path))
ds_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole, ds)
ds_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
ds_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole, ds.category)
ds_check_state = Qt.Checked
if ds.id in PluginSettings.get_hide_ds_id_list():
ds_check_state = Qt.Unchecked
ds_item.setCheckState(self.COLUMN_VISIBILITY, ds_check_state)
if group_item.childCount() != 0 and group_item.checkState(
1) != ds_check_state:
group_item.setCheckState(self.COLUMN_VISIBILITY,
Qt.PartiallyChecked)
else:
group_item.setCheckState(self.COLUMN_VISIBILITY,
ds_check_state)
group_item.addChild(ds_item)
