def populate_field_list(self, excluded_fields=None):
"""Helper to add field of the layer to the list.
:param excluded_fields: List of field that want to be excluded.
:type excluded_fields: list
"""
# Populate fields list
if excluded_fields is None:
excluded_fields = []
self.field_list.clear()
for field in self.layer.fields():
# Skip if it's excluded
if field.name() in excluded_fields:
continue
# Skip if it's not number (float, int, etc)
if field.type() not in qvariant_numbers:
continue
field_item = QListWidgetItem(self.field_list)
field_item.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field.name())
field_item.setText(field.name())
self.field_list.addItem(field_item)
def validate(self):
#self.layerList.setTitle('Layers')
data_source = self.gmlas_datasource()
if data_source is None:
QMessageBox.critical(self,
plugin_name(),
self.tr('Failed to open file using OGR GMLAS driver'))
return
ogrMetadataLayerPrefix = '_ogr_'
self.datasetsListWidget.clear()
for i in range(0, data_source.GetLayerCount()):
layer = data_source.GetLayer(i)
layer_name = layer.GetName()
if not layer_name.startswith(ogrMetadataLayerPrefix):
feature_count = layer.GetFeatureCount()
item = QListWidgetItem("{} ({})".format(layer_name, feature_count))
item.setData(Qt.UserRole, layer_name)
self.datasetsListWidget.addItem(item)
self.datasetsListWidget.sortItems()
self.datasetsListWidget.selectAll()
def on_load_base_layer(self):
# look for base layers in the config
layer_config = get_layer_config()
dlg = QDialog()
vbox = QVBoxLayout()
list_widget = QListWidget()
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
vbox.addWidget(list_widget)
vbox.addWidget(button_box)
dlg.setWindowTitle("Select a base layer to load")
dlg.setLayout(vbox)
# populate the list widget
for (uri, provider), cfg in layer_config.items():
layer_name = cfg.get(
"layer_name", "Unnamed layer ({}, {})".format(uri, provider))
list_item = QListWidgetItem()
list_item.setText(layer_name)
list_item.setData(Qt.UserRole, (uri, provider))
list_widget.addItem(list_item)
button_box.rejected.connect(dlg.reject)
button_box.accepted.connect(dlg.accept)
if dlg.exec_():
item = list_widget.currentItem()
if item:
uri, provider = item.data(Qt.UserRole)
self.iface.addVectorLayer(uri, item.text(), provider)
def _populate_list(self):
self.__list.clear()
for cfg in self.__config_list:
if cfg["type"] in ("continuous", "instantaneous"):
uri, provider = cfg["source"]
# check number of features for this station
data_l = QgsVectorLayer(uri, "data_layer", provider)
req = QgsFeatureRequest()
req.setFilterExpression("{}={}".format(
cfg["feature_ref_column"], self.__feature_id))
if len(list(data_l.getFeatures(req))) == 0:
continue
if cfg.get("feature_filter_type") == "unique_data_from_values":
# get unique filter values
cfg["filter_unique_values"] = sorted(
list(
set([
f[cfg["feature_filter_column"]]
for f in data_l.getFeatures(req)
])))
elif cfg["type"] == "image":
if not self.__viewer.has_imagery_data(cfg, self.__feature_id):
continue
item = QListWidgetItem(cfg["name"])
item.setData(Qt.UserRole, cfg)
self.__list.addItem(item)
def _populate_list(self):
self.__list.clear()
for cfg in self.__config_list:
if cfg["type"] in ("cumulative", "instantaneous"):
# check number of features for this station
if cfg.get("feature_filter_type") == "unique_data_from_values":
# get unique filter values
layerid = cfg["source"]
data_l = QgsProject.instance().mapLayers()[layerid]
values = set()
for feature in self.__features:
feature_id = feature[self.__config["id_column"]]
req = QgsFeatureRequest()
req.setFilterExpression("{}={}".format(
cfg["feature_ref_column"], feature_id))
values.update([
f[cfg["feature_filter_column"]]
for f in data_l.getFeatures(req)
])
cfg.set_filter_unique_values(sorted(list(values)))
item = QListWidgetItem(cfg["name"])
item.setData(Qt.UserRole, cfg)
self.__list.addItem(item)
def parse_get_capabilities(self, xml):
# this raises a IOError if the file doesn't exist
root = ElementTree.fromstring(xml)
featuretypelist = root.find('%sFeatureTypeList' % NS_NET_OPENGIS_WFS)
layers = featuretypelist.findall('%sFeatureType' % NS_NET_OPENGIS_WFS)
for layer in layers:
try:
keywords = layer.find('%sKeywords' % NS_NET_OPENGIS_WFS).text
if keywords is not None and (
'IRMT_QGIS_Plugin' in keywords or
# this is for backward compatibility
'SVIR_QGIS_Plugin' in keywords):
title = layer.find('%sTitle' % NS_NET_OPENGIS_WFS).text
layer_id = layer.find('%sName' % NS_NET_OPENGIS_WFS).text
abstract = layer.find('%sAbstract' %
NS_NET_OPENGIS_WFS).text
bbox = layer.find('%sLatLongBoundingBox' %
NS_NET_OPENGIS_WFS).attrib
self.extra_infos[layer_id] = {
'Title': title,
'Abstract': abstract,
'Keywords': keywords,
'Bounding Box': bbox
}
# update combo box
item = QListWidgetItem()
item.setData(Qt.DisplayRole, title)
item.setData(Qt.ToolTipRole, layer_id)
self.layers_lst.addItem(item)
except AttributeError:
continue
def search(self, text):
db = self.db
c = db.cursor()
self.resultsView.clear()
self.resultsView.setEnabled(False)
if not text:
return
if self.fuzzyCheck.isChecked():
search = "* ".join(text.split()) + "*"
else:
search = text
query = c.execute(
"""SELECT layer, featureid, snippet(search, '[',']') as snippet
FROM search
JOIN featureinfo on search.docid = featureinfo.id
WHERE search match '{}' LIMIT 100""".format(
search)).fetchall()
for layer, featureid, snippet in query:
item = QListWidgetItem()
text = "{}\n {}".format(layer, snippet.replace('\n', ' '))
item.setText(text)
item.setData(Qt.UserRole + 1, (layer, featureid, snippet))
self.resultsView.addItem(item)
self.resultsView.setEnabled(True)
if self.resultsView.count() == 0:
self.resultsView.addItem("No Results")
self.resultsView.setEnabled(False)
db.close()
def set_widgets(self):
"""Set widgets on the Classification tab."""
self.clear_further_steps()
purpose = self.parent.step_kw_purpose.selected_purpose()['name']
subcategory = self.parent.step_kw_subcategory.\
selected_subcategory()['name']
self.lstClassifications.clear()
self.lblDescribeClassification.setText('')
self.lblSelectClassification.setText(
classification_question % (subcategory, purpose))
classifications = self.classifications_for_layer()
for classification in classifications:
if not isinstance(classification, dict):
classification = definition(classification)
item = QListWidgetItem(
classification['name'],
self.lstClassifications)
item.setData(QtCore.Qt.UserRole, classification['key'])
self.lstClassifications.addItem(item)
# Set values based on existing keywords (if already assigned)
classification_keyword = self.parent.get_existing_keyword(
'classification')
if classification_keyword:
classifications = []
for index in range(self.lstClassifications.count()):
item = self.lstClassifications.item(index)
classifications.append(item.data(QtCore.Qt.UserRole))
if classification_keyword in classifications:
self.lstClassifications.setCurrentRow(
classifications.index(classification_keyword))
self.auto_select_one_item(self.lstClassifications)
def _populateTerrainLayers(self):
"""Populates the layers list"""
listLayers = self.listLayers
listLayers.clear()
for layerView in QgsProject.instance().layerTreeRoot().findLayers():
layer = layerView.layer()
# Must be vectory
if layer.type() != QgsMapLayer.VectorLayer:
continue
# Must be polygon
if layer.geometryType() != QgsWkbTypes.PolygonGeometry:
continue
fields = layer.fields()
elevationIndex = fields.indexOf('elevation')
if elevationIndex == -1:
continue
listItem = QListWidgetItem(listLayers)
listItem.setText(layer.name())
listItem.setData(QtCore.Qt.UserRole, layer)
def validate(self):
self.layerList.setTitle('Layers')
data_source = self.gmlas_datasource()
if data_source is None:
QMessageBox.critical(
self, plugin_name(),
self.tr('Failed to open file using OGR GMLAS driver'))
return
ogrMetadataLayerPrefix = '_ogr_'
self.datasetsListWidget.clear()
for i in range(0, data_source.GetLayerCount()):
layer = data_source.GetLayer(i)
layer_name = layer.GetName()
if not layer_name.startswith(ogrMetadataLayerPrefix):
feature_count = layer.GetFeatureCount()
item = QListWidgetItem("{} ({})".format(
layer_name, feature_count))
item.setData(Qt.UserRole, layer_name)
self.datasetsListWidget.addItem(item)
self.datasetsListWidget.sortItems()
self.datasetsListWidget.selectAll()
self.layerList.setTitle('{} layer(s) found:'.format(
self.datasetsListWidget.count()))
def feel_list(self):
self.lstServices.clear()
ds_list = DataSourcesList(USER_DS_PATHS)
for ds in ds_list.data_sources.values():
item = QListWidgetItem(ds.action.icon(), ds.action.text())
item.setData(Qt.UserRole, ds)
self.lstServices.addItem(item)
def feel_list(self):
self.lstGroups.clear()
ds_groups = GroupsList(USER_GROUP_PATHS)
for ds_group in ds_groups.groups.values():
item = QListWidgetItem(QIcon(ds_group.icon), self.tr(ds_group.alias))
item.setData(Qt.UserRole, ds_group)
self.lstGroups.addItem(item)
def set_widgets(self):
"""Set widgets on the Classification tab."""
self.clear_further_steps()
purpose = self.parent.step_kw_purpose.selected_purpose()['name']
subcategory = self.parent.step_kw_subcategory.\
selected_subcategory()['name']
self.lstClassifications.clear()
self.lblDescribeClassification.setText('')
self.lblSelectClassification.setText(
classification_question % (subcategory, purpose))
classifications = self.classifications_for_layer()
for classification in classifications:
if not isinstance(classification, dict):
classification = definition(classification)
item = QListWidgetItem(
classification['name'],
self.lstClassifications)
item.setData(QtCore.Qt.UserRole, classification['key'])
self.lstClassifications.addItem(item)
# Set values based on existing keywords (if already assigned)
classification_keyword = self.parent.get_existing_keyword(
'classification')
if classification_keyword:
classifications = []
for index in range(self.lstClassifications.count()):
item = self.lstClassifications.item(index)
classifications.append(item.data(QtCore.Qt.UserRole))
if classification_keyword in classifications:
self.lstClassifications.setCurrentRow(
classifications.index(classification_keyword))
self.auto_select_one_item(self.lstClassifications)
def set_widgets(self):
"""Set widgets on the Hazard Category tab."""
self.clear_further_steps()
# Set widgets
self.lstHazardCategories.clear()
self.lblDescribeHazardCategory.setText('')
self.lblSelectHazardCategory.setText(hazard_category_question)
hazard_categories = self.hazard_categories_for_layer()
for hazard_category in hazard_categories:
if not isinstance(hazard_category, dict):
# noinspection PyTypeChecker
hazard_category = definition(hazard_category)
# noinspection PyTypeChecker
item = QListWidgetItem(hazard_category['name'],
self.lstHazardCategories)
# noinspection PyTypeChecker
item.setData(QtCore.Qt.UserRole, hazard_category['key'])
self.lstHazardCategories.addItem(item)
# Set values based on existing keywords (if already assigned)
category_keyword = self.parent.get_existing_keyword('hazard_category')
if category_keyword:
categories = []
for index in range(self.lstHazardCategories.count()):
item = self.lstHazardCategories.item(index)
categories.append(item.data(QtCore.Qt.UserRole))
if category_keyword in categories:
self.lstHazardCategories.setCurrentRow(
categories.index(category_keyword))
self.auto_select_one_item(self.lstHazardCategories)
def __init__(self, parent=None):
"""Constructor."""
super().__init__(parent)
self.setupUi(self)
self.blocked = False
self.previous_map_tool = None
self.extent_tool = None
for name in SERVICE_MANAGER.available_predefined_bounding_boxes():
extent = SERVICE_MANAGER.predefined_bounding_box(name)
item = QListWidgetItem(extent['title'])
item.setData(Qt.UserRole, name)
item.setData(Qt.UserRole + 1, extent.get('read_only', False))
item.setData(Qt.UserRole + 2, extent.get('title', ''))
item.setData(Qt.UserRole + 3, extent.get('boundingbox', [0, 0, 0, 0])[0])
item.setData(Qt.UserRole + 4, extent.get('boundingbox', [0, 0, 0, 0])[1])
item.setData(Qt.UserRole + 5, extent.get('boundingbox', [0, 0, 0, 0])[2])
item.setData(Qt.UserRole + 6, extent.get('boundingbox', [0, 0, 0, 0])[3])
self.region_list.addItem(item)
self.region_list.currentItemChanged.connect(self._item_changed)
self.button_add.clicked.connect(self._add_item)
self.button_remove.clicked.connect(self._remove_item)
self.edit_label.textEdited.connect(self._update_item)
self.spin_min_long.valueChanged.connect(self._update_item)
self.spin_max_long.valueChanged.connect(self._update_item)
self.spin_min_lat.valueChanged.connect(self._update_item)
self.spin_max_lat.valueChanged.connect(self._update_item)
self.button_draw_on_map.clicked.connect(self.draw_rect_on_map)
def set_widgets(self):
"""Set widgets on the Hazard Category tab."""
self.clear_further_steps()
# Set widgets
self.lstHazardCategories.clear()
self.lblDescribeHazardCategory.setText('')
self.lblSelectHazardCategory.setText(
hazard_category_question)
hazard_categories = self.hazard_categories_for_layer()
for hazard_category in hazard_categories:
if not isinstance(hazard_category, dict):
# noinspection PyTypeChecker
hazard_category = definition(hazard_category)
# noinspection PyTypeChecker
item = QListWidgetItem(
hazard_category['name'],
self.lstHazardCategories)
# noinspection PyTypeChecker
item.setData(QtCore.Qt.UserRole, hazard_category['key'])
self.lstHazardCategories.addItem(item)
# Set values based on existing keywords (if already assigned)
category_keyword = self.parent.get_existing_keyword('hazard_category')
if category_keyword:
categories = []
for index in range(self.lstHazardCategories.count()):
item = self.lstHazardCategories.item(index)
categories.append(item.data(QtCore.Qt.UserRole))
if category_keyword in categories:
self.lstHazardCategories.setCurrentRow(
categories.index(category_keyword))
self.auto_select_one_item(self.lstHazardCategories)
def feel_list(self):
self.lstServices.clear()
ds_list = DataSourcesList(USER_DS_PATHS)
for ds in ds_list.data_sources.values():
item = QListWidgetItem(ds.action.icon(), ds.action.text())
item.setData(Qt.UserRole, ds)
self.lstServices.addItem(item)
def open_images(self):
self.clear_thumb_images()
data_len = len(self.DATA)
if self.NUM_DATA_BEGIN >= data_len:
# Sono già state visualizzate tutte le immagini
self.NUM_DATA_BEGIN = 0
self.NUM_DATA_END = 25
elif self.NUM_DATA_BEGIN <= data_len:
# indica che non sono state visualizzate tutte le immagini
data = self.DATA[self.NUM_DATA_BEGIN:self.NUM_DATA_END]
for i in range(len(data)):
item = QListWidgetItem(str(data[i].id_media))
# data_for_thumb = self.db_search_check(self.MAPPER_TABLE_CLASS_thumb, 'id_media', id_media) # recupera i valori della thumb in base al valore id_media del file originale
thumb_path = data[i].filepath
# QMessageBox.warning(self, "Errore",str(thumb_path), QMessageBox.Ok)
item.setData(Qt.UserRole, str(data[i].media_filename))
icon = QIcon(
thumb_path
) # os.path.join('%s/%s' % (directory.toUtf8(), image)))
item.setIcon(icon)
self.iconListWidget.addItem(item)
def feel_list(self):
self.lstGroups.clear()
ds_groups = GroupsList(USER_GROUP_PATHS)
for ds_group in ds_groups.groups.values():
item = QListWidgetItem(QIcon(ds_group.icon),
self.tr(ds_group.alias))
item.setData(Qt.UserRole, ds_group)
self.lstGroups.addItem(item)
def updateManaged(self):
self.mManagedLayers.clear()
for layer in managed_layers():
item = QListWidgetItem(layer.name())
item.setData(Qt.UserRole, layer.id())
self.mManagedLayers.addItem(item)
def addPrefixToList(self):
item = QListWidgetItem()
item.setData(
0, "PREFIX " + self.tripleStorePrefixNameEdit.text() + ":<" +
self.tripleStorePrefixEdit.text() + ">")
item.setText("PREFIX " + self.tripleStorePrefixNameEdit.text() + ":<" +
self.tripleStorePrefixEdit.text() + ">")
self.prefixList.addItem(item)
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 getClassesFromLabel(self, comboBox):
viewlist = []
resultlist = []
label = self.conceptSearchEdit.text()
if label == "":
return
language = "en"
results = {}
self.searchResult.clear()
query = ""
position = self.tripleStoreEdit.currentIndex()
if self.tripleStoreEdit.currentIndex() > len(self.triplestoreconf):
if self.findProperty.isChecked():
self.addVocab[self.addVocab.keys()[
position -
len(self.triplestoreconf)]]["source"]["properties"]
viewlist = {k: v for k, v in d.iteritems() if label in k}
else:
self.addVocab[self.addVocab.keys()[
position - len(self.triplestoreconf)]]["source"]["classes"]
viewlist = {k: v for k, v in d.iteritems() if label in k}
for res in viewlist:
item = QListWidgetItem()
item.setData(1, val)
item.setText(key)
self.searchResult.addItem(item)
else:
if self.findProperty.isChecked():
if "propertyfromlabelquery" in self.triplestoreconf[
self.tripleStoreEdit.currentIndex() + 1]:
query = self.triplestoreconf[
self.tripleStoreEdit.currentIndex() +
1]["propertyfromlabelquery"].replace(
"%%label%%", label)
else:
if "classfromlabelquery" in self.triplestoreconf[
self.tripleStoreEdit.currentIndex() + 1]:
query = self.triplestoreconf[
self.tripleStoreEdit.currentIndex() +
1]["classfromlabelquery"].replace("%%label%%", label)
if query == "":
msgBox = QMessageBox()
msgBox.setText(
"No search query specified for this triplestore")
msgBox.exec()
return
self.qtask = SearchTask(
"Searching classes/properties for " + label + " in " +
self.triplestoreconf[self.tripleStoreEdit.currentIndex() +
1]["endpoint"],
self.triplestoreconf[self.tripleStoreEdit.currentIndex() +
1]["endpoint"], query,
self.triplestoreconf, self.findProperty, self.tripleStoreEdit,
self.searchResult, self.prefixes, label, language, None)
QgsApplication.taskManager().addTask(self.qtask)
return viewlist
def addResults(self, hits):
#REFACTOR to add if link is missing
for hit in hits:
for link in hit.get("downloadLinks"):
title = self.getTitleFromHit(hit)
if title:
item = QListWidgetItem()
item.setText(title)
item.setData(1, hit)
self.dlg.searchResult.addItem(item)
def __init__(self, names, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.names = names
self.selected_layers_info = dict()
self.lst_plots.clear()
self.lst_buildings.clear()
self.plots = {
self.names.LC_BOUNDARY_POINT_T: None,
self.names.LC_BOUNDARY_T: None,
self.names.LC_PLOT_T: None
}
self.buildings = {
self.names.LC_SURVEY_POINT_T: None,
self.names.LC_BUILDING_T: None,
self.names.LC_BUILDING_UNIT_T: None
}
icons = {
self.names.LC_BOUNDARY_POINT_T:
QIcon(":/Asistente-LADM-COL/resources/images/points.png"),
self.names.LC_BOUNDARY_T:
QIcon(":/Asistente-LADM-COL/resources/images/lines.png"),
self.names.LC_PLOT_T:
QIcon(":/Asistente-LADM-COL/resources/images/polygons.png"),
self.names.LC_SURVEY_POINT_T:
QIcon(":/Asistente-LADM-COL/resources/images/points.png"),
self.names.LC_BUILDING_T:
QIcon(":/Asistente-LADM-COL/resources/images/polygons.png"),
self.names.LC_BUILDING_UNIT_T:
QIcon(":/Asistente-LADM-COL/resources/images/polygons.png")
}
for k, v in self.plots.items():
item = QListWidgetItem()
item.setData(Qt.DecorationRole, icons[k])
item.setText(k)
self.lst_plots.addItem(item)
for k, v in self.buildings.items():
item = QListWidgetItem()
item.setData(Qt.DecorationRole, icons[k])
item.setText(k)
self.lst_buildings.addItem(item)
# Set connections
self.buttonBox.accepted.connect(self.accepted)
self.rad_plots.toggled.connect(self.update_controls)
self.lst_plots.itemSelectionChanged.connect(self.update_controls)
self.lst_buildings.itemSelectionChanged.connect(self.update_controls)
self.update_controls() # Initialize GUI state
def getClassesFromLabel(self, comboBox):
viewlist = []
resultlist = []
label = self.conceptSearchEdit.text()
language = "en"
results = {}
self.searchResult.clear()
query = ""
if self.currentcol == 4:
if "propertyfromlabelquery" in self.triplestoreconf[
self.tripleStoreEdit.currentIndex() + 1]:
query = self.triplestoreconf[
self.tripleStoreEdit.currentIndex() +
1]["propertyfromlabelquery"].replace("%%label%%", label)
else:
if "classfromlabelquery" in self.triplestoreconf[
self.tripleStoreEdit.currentIndex() + 1]:
query = self.triplestoreconf[
self.tripleStoreEdit.currentIndex() +
1]["classfromlabelquery"].replace("%%label%%", label)
if "SELECT" in query:
query = query.replace("%%label%%",
label).replace("%%language%%", language)
sparql = SPARQLWrapper(
self.triplestoreconf[
self.tripleStoreEdit.currentIndex()]["endpoint"],
agent=
"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11"
)
sparql.setQuery(query)
sparql.setReturnFormat(JSON)
results = sparql.query().convert()
self.searchResultMap = {}
for res in results["results"]["bindings"]:
item = QListWidgetItem()
item.setData(0, str(res["class"]["value"]))
item.setText(str(res["label"]["value"]))
self.searchResultMap[res["label"]
["value"]] = res["class"]["value"]
self.searchResult.addItem(item)
else:
myResponse = json.loads(requests.get(query).text)
for ent in myResponse["search"]:
qid = ent["url"]
label = ent["label"] + " (" + ent["id"] + ") "
if "description" in ent:
label += "[" + ent["description"] + "]"
results[qid] = label
self.searchResultMap[label] = ent["url"]
for result in results:
item = QListWidgetItem()
item.setData(0, result)
item.setText(str(results[result]))
self.searchResult.addItem(item)
return viewlist
def __addPolygonsToGui(self):
self.ui.IDC_listPolygons.clear()
self.ui.cmbCadastreLayer.clear()
check = Qt.Unchecked
for poly_lyr in self.settings.mapData.polygons.polygons():
item = QListWidgetItem(poly_lyr.name)
item.setData(Qt.UserRole, poly_lyr)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(check)
self.ui.IDC_listPolygons.addItem(item)
self.ui.cmbCadastreLayer.addItem(poly_lyr.name, poly_lyr.id)
def filterPublicLayers(self):
self.publicWebMapsList.clear()
filter = self.filterText.text()
for idx, public_layers in enumerate(self.public_db_keys):
if "layer_name" in public_layers:
if len(filter) < 3 or public_layers["layer_name"].find(
filter) != -1 or public_layers["id"].find(
filter) != -1:
listItem = QListWidgetItem(public_layers["layer_name"])
listItem.setData(Qt.UserRole, idx)
self.publicWebMapsList.addItem(listItem)
def _add_item(self):
item = QListWidgetItem('New Area')
item.setData(Qt.UserRole, None)
item.setData(Qt.UserRole + 1, False)
item.setData(Qt.UserRole + 2, 'New Area')
item.setData(Qt.UserRole + 3, 0)
item.setData(Qt.UserRole + 4, 0)
item.setData(Qt.UserRole + 5, 0)
item.setData(Qt.UserRole + 6, 0)
self.region_list.addItem(item)
self.region_list.setCurrentItem(item)
def __addPolygonsToGui(self):
self.ui.IDC_listPolygons.clear()
self.ui.cmbCadastreLayer.clear()
check = Qt.Unchecked
for poly_lyr in self.settings.mapData.polygons.polygons():
item = QListWidgetItem(poly_lyr.name)
item.setData(Qt.UserRole, poly_lyr)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(check)
self.ui.IDC_listPolygons.addItem(item)
self.ui.cmbCadastreLayer.addItem(poly_lyr.name, poly_lyr.id)
def _create_topics_list(self, topics):
"""Builds qt list with topics items from given data.
Args:
topics (Dict[str, Any]): topics data (title, abstract, visible_overlays)
"""
for topic_data in topics:
item = QListWidgetItem(topic_data.pop('title'))
item.setFlags(item.flags() | Qt.ItemIsEditable)
item.setData(Qt.UserRole, topic_data)
self.dialog.topicsList.addItem(item)
def update_lists(self, only_update_all_list=False):
"""
Update left list widget and optionally the right one.
:param only_update_all_list: Only update left list widget.
:type only_update_all_list: bool
"""
# All parties
self.lst_all_parties.clear()
if self.txt_search_party.text():
tmp_parties = {
i: d
for i, d in self.data.items()
if self.txt_search_party.text().lower() in d[0].lower()
}
else:
tmp_parties = copy.deepcopy(self.data) # Copy all!
for party_id in self.current_selected_parties:
if party_id in tmp_parties:
del tmp_parties[party_id]
for i, d in tmp_parties.items():
item = QListWidgetItem(d[0])
item.setData(Qt.UserRole, i)
self.lst_all_parties.addItem(item)
if not only_update_all_list:
# Selected parties
self.tbl_selected_parties.clearContents()
self.tbl_selected_parties.setRowCount(
len(self.current_selected_parties))
self.tbl_selected_parties.setColumnCount(3)
self.tbl_selected_parties.setSortingEnabled(False)
for row, party_id in enumerate(self.current_selected_parties):
item = QTableWidgetItem(self.data[party_id][0])
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
item.setData(Qt.UserRole, party_id)
self.tbl_selected_parties.setItem(row, 0, item)
value_denominator = self.parties_to_group[party_id][
0] if party_id in self.parties_to_group else self.data[
party_id][1]
self.tbl_selected_parties.setItem(
row, 1, QTableWidgetItem(str(value_denominator)))
value_numerator = self.parties_to_group[party_id][
1] if party_id in self.parties_to_group else self.data[
party_id][2]
self.tbl_selected_parties.setItem(
row, 2, QTableWidgetItem(str(value_numerator)))
self.tbl_selected_parties.setSortingEnabled(True)
def __addRastersToGui(self):
self.ui.IDC_listRasters.clear()
check = Qt.Unchecked
if self.settings.mapData.rasters.count() == 1:
check = Qt.Checked
self.settings.mapData.rasters.rasters()[0].selected = True
for raster_lyr in self.settings.mapData.rasters.rasters():
item = QListWidgetItem(raster_lyr.name)
item.setData(Qt.UserRole, raster_lyr)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(check)
self.ui.IDC_listRasters.addItem(item)
def __addRastersToGui(self):
self.ui.IDC_listRasters.clear()
check = Qt.Unchecked
if self.settings.mapData.rasters.count() == 1:
check = Qt.Checked
self.settings.mapData.rasters.rasters()[0].selected = True
for raster_lyr in self.settings.mapData.rasters.rasters():
item = QListWidgetItem(raster_lyr.name)
item.setData(Qt.UserRole, raster_lyr)
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(check)
self.ui.IDC_listRasters.addItem(item)
def __createWidget(field, layer, settings_layer):
settings_field = settings_layer["filters_fields"][field]
widget_type = settings_field["widget_type"]
filter_widget = getattr(QtWidgets, widget_type)()
filter_widget.setObjectName(field)
widget_options = settings_field["widget_options"]
for wo in widget_options:
value = widget_options[wo]
try:
value = int(value)
except:
try:
value = float(value)
except:
pass
getattr(filter_widget, wo)(value)
if settings_field["source_type"] == "own":
idx_field = layer.fields().indexFromName(field)
if not idx_field > 0:
print(f"Field {field} does not found in layer")
field_type = layer.editorWidgetSetup(idx_field).type()
if field_type == 'ValueMap':
valuemap = layer.editorWidgetSetup(idx_field).config()['map']
# по какой-то неведомой причине какие-то
# карты значений в виде списка,
# какие-то в виде словарей
if isinstance(valuemap, list):
newvaluemap = {}
for d in valuemap:
newvaluemap[list(d.keys())[0]] = d[list(d.keys())[0]]
valuemap = newvaluemap
for key, value in valuemap.items():
if widget_type == "QListWidget":
item = QListWidgetItem(key)
item.setData(Qt.UserRole, QVariant(value))
filter_widget.addItem(item)
elif widget_type == "QComboBox":
filter_widget.addItem(key, QVariant(value))
filter_widget.setCurrentIndex(-1)
elif settings_field["source_type"] == "custom":
if widget_type == "QComboBox":
filter_widget.setCurrentIndex(-1)
filter_widget.addItem(None, QVariant(None))
return filter_widget
def populateListWithDatabasesFromServer(self):
'''
Populates databases list from server
'''
dbList = []
try:
dbList = self.serverWidget.abstractDb.getEDGVDbsFromServer()
except Exception as e:
QMessageBox.critical(self, self.tr('Critical!'), ':'.join(e.args))
dbList.sort()
for (dbname, dbversion) in dbList:
item = QListWidgetItem(self.dbListWidget)
item.setText(dbname + ' (EDGV v. ' + dbversion + ')')
item.setData(Qt.UserRole, dbname)
def show_result(self, geoservice, image_ba):
if geoservice:
custom_widget = QmsSearchResultItemWidget(
geoservice, image_ba, extent_renderer=self.extent_renderer)
new_item = QListWidgetItem(self.lstSearchResult)
new_item.setSizeHint(custom_widget.sizeHint())
self.lstSearchResult.addItem(new_item)
self.lstSearchResult.setItemWidget(new_item, custom_widget)
else:
new_item = QListWidgetItem()
new_item.setText(self.tr('No results!'))
new_item.setData(Qt.UserRole, None)
self.lstSearchResult.addItem(new_item)
self.lstSearchResult.update()
def __init__(self,
electorate_registry: LinzElectoralDistrictRegistry,
parent=None):
super().__init__(parent)
self.electorate_registry = electorate_registry
self.setWindowTitle(self.tr('Deprecate Electorate'))
layout = QVBoxLayout()
self.search = QgsFilterLineEdit()
self.search.setShowSearchIcon(True)
self.search.setPlaceholderText(
self.tr('Search for {}').format(
electorate_registry.type_string_sentence()))
self.search.textChanged.connect(self.filter_changed)
layout.addWidget(self.search)
request = QgsFeatureRequest()
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes([
electorate_registry.source_field_index,
electorate_registry.title_field_index,
electorate_registry.deprecated_field_index
])
self.list = QListWidget()
for f in electorate_registry.source_layer.getFeatures(request):
title = f[electorate_registry.title_field_index]
code = f[electorate_registry.source_field_index]
deprecated = f[electorate_registry.deprecated_field_index]
if deprecated:
title = '*' + title
item = QListWidgetItem(title)
item.setData(Qt.UserRole, code)
self.list.addItem(item)
layout.addWidget(self.list, 10)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
layout.addWidget(button_box)
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self.accept)
self.setLayout(layout)
self.list.itemDoubleClicked.connect(self.accept)
def set_widgets(self):
"""Set widgets on the LayerMode tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
layer_mode_question = (
layer_mode_raster_question
if is_raster_layer(self.parent.layer)
else layer_mode_vector_question)
self.lblDescribeLayerMode.setText('')
self.lstLayerModes.clear()
layer_modes = get_layer_modes(subcategory['key'])
if is_raster_layer(self.parent.layer):
layer_mode_question = layer_mode_raster_question
else:
if len(layer_modes) == 2:
layer_mode_question = layer_mode_vector_question
elif len(layer_modes) == 1:
if layer_modes[0]['key'] == 'classified':
layer_mode_question = layer_mode_vector_classified_confirm
elif layer_modes[0]['key'] == 'continuous':
layer_mode_question = layer_mode_vector_continuous_confirm
else:
layer_mode_question = layer_mode_vector_question
self.lblSelectLayerMode.setText(
layer_mode_question % (subcategory['name'], purpose['name']))
for layer_mode in layer_modes:
item = QListWidgetItem(layer_mode['name'], self.lstLayerModes)
item.setData(QtCore.Qt.UserRole, layer_mode['key'])
self.lstLayerModes.addItem(item)
# Set value to existing keyword or default value
layer_mode_keys = [m['key'] for m in layer_modes]
layer_mode_keyword = self.parent.get_existing_keyword('layer_mode')
if layer_mode_keyword in layer_mode_keys:
index = layer_mode_keys.index(layer_mode_keyword)
elif layer_mode_continuous['key'] in layer_mode_keys:
# Set default value
index = layer_mode_keys.index(layer_mode_continuous['key'])
else:
index = -1
self.lstLayerModes.setCurrentRow(index)
self.auto_select_one_item(self.lstLayerModes)
def setList(self, options):
self.options = options
self.listWidget.clear()
entries = QgsRasterCalculatorEntry.rasterEntries()
def _find_source(name):
for entry in entries:
if entry.ref == name:
return entry.raster.source()
return ''
for name in options.keys():
item = QListWidgetItem(name, self.listWidget)
tooltip = _find_source(name)
if tooltip:
item.setData(Qt.ToolTipRole, tooltip)
self.listWidget.addItem(item)
def show_result(self, geoservice, image_ba):
if geoservice:
custom_widget = QmsSearchResultItemWidget(geoservice, image_ba, extent_renderer=self.extent_renderer)
new_item = QListWidgetItem(self.lstSearchResult)
new_item.setSizeHint(custom_widget.sizeHint())
self.lstSearchResult.addItem(new_item)
self.lstSearchResult.setItemWidget(
new_item,
custom_widget
)
else:
new_item = QListWidgetItem()
new_item.setText(self.tr('No results!'))
new_item.setData(Qt.UserRole, None)
self.lstSearchResult.addItem(new_item)
self.lstSearchResult.update()
def list_compatible_canvas_layers(self):
"""Fill the list widget with compatible layers.
:returns: Metadata of found layers.
:rtype: list of dicts
"""
italic_font = QFont()
italic_font.setItalic(True)
list_widget = self.lstCanvasExpLayers
# Add compatible layers
list_widget.clear()
for layer in self.parent.get_compatible_canvas_layers('exposure'):
item = QListWidgetItem(layer['name'], list_widget)
item.setData(Qt.UserRole, layer['id'])
if not layer['keywords']:
item.setFont(italic_font)
list_widget.addItem(item)
def refresh_maps(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
if self.clouddb:
map_list = self.api.read_maps()
if self.show_api_error(map_list):
QApplication.restoreOverrideCursor()
return
self.ui.tabMaps.clear()
self.ui.btnMapDelete.setEnabled(False)
self.ui.btnMapLoad.setEnabled(False)
for map in map_list:
it = QListWidgetItem(map['map']['name'])
self.ui.tabMaps.addItem(it)
it.setData(Qt.UserRole, map['map']['id'])
QApplication.restoreOverrideCursor()
def update_list_widget(self):
"""Update list widget when radio button is clicked."""
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
# No radio button checked, then default value = None
if radio_button_checked_id > -1:
selected_dict = list(self._parameter.options.values())[
radio_button_checked_id]
if selected_dict.get('type') == MULTIPLE_DYNAMIC:
for field in selected_dict.get('value'):
# Update list widget
field_item = QListWidgetItem(self.list_widget)
field_item.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field)
field_item.setText(field)
self.list_widget.addItem(field_item)
def set_widgets(self):
"""Set widgets on the LayerMode tab."""
self.clear_further_steps()
# Set widgets
self.lblBandSelector.setText(tr(
'Please select which band that contains the data that you want to '
'use for this layer.'))
self.lstBands.clear()
band_num = self.parent.layer.bandCount()
for i in range(band_num):
item = QListWidgetItem(
self.parent.layer.bandName(i + 1),
self.lstBands)
item.setData(QtCore.Qt.UserRole, i + 1)
self.lstBands.addItem(item)
existing_band = self.parent.get_existing_keyword('active_band')
if existing_band:
self.lstBands.setCurrentRow(existing_band - 1)
else:
# Set to Band 1 / index 0
self.lstBands.setCurrentRow(0)
def set_widgets(self):
"""Set widgets on the Subcategory tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
self.lstSubcategories.clear()
self.lblDescribeSubcategory.setText('')
self.lblIconSubcategory.setPixmap(QPixmap())
self.lblSelectSubcategory.setText(
get_question_text('%s_question' % purpose['key']))
for i in self.subcategories_for_layer():
# noinspection PyTypeChecker
item = QListWidgetItem(i['name'], self.lstSubcategories)
# noinspection PyTypeChecker
item.setData(QtCore.Qt.UserRole, i['key'])
self.lstSubcategories.addItem(item)
# Check if layer keywords are already assigned
key = self.parent.step_kw_purpose.selected_purpose()['key']
keyword = self.parent.get_existing_keyword(key)
# Overwrite the keyword if it's KW mode embedded in IFCW mode
if self.parent.parent_step:
keyword = self.parent.get_parent_mode_constraints()[1]['key']
# Set values based on existing keywords or parent mode
if keyword:
subcategories = []
for index in range(self.lstSubcategories.count()):
item = self.lstSubcategories.item(index)
subcategories.append(item.data(QtCore.Qt.UserRole))
if keyword in subcategories:
self.lstSubcategories.setCurrentRow(
subcategories.index(keyword))
self.auto_select_one_item(self.lstSubcategories)
def set_widgets(self):
"""Set widgets on the Unit tab."""
self.clear_further_steps()
# Set widgets
purpose = self.parent.step_kw_purpose.selected_purpose()
subcategory = self.parent.step_kw_subcategory.selected_subcategory()
self.lblSelectUnit.setText(
unit_question % (subcategory['name'], purpose['name']))
self.lblDescribeUnit.setText('')
self.lstUnits.clear()
subcat = self.parent.step_kw_subcategory.selected_subcategory()['key']
if purpose == layer_purpose_hazard:
units_for_layer = hazard_units(subcat)
else:
units_for_layer = exposure_units(subcat)
for unit_for_layer in units_for_layer:
item = QListWidgetItem(unit_for_layer['name'], self.lstUnits)
item.setData(QtCore.Qt.UserRole, unit_for_layer['key'])
self.lstUnits.addItem(item)
# Set values based on existing keywords (if already assigned)
if self.parent.step_kw_purpose.\
selected_purpose() == layer_purpose_hazard:
key = continuous_hazard_unit['key']
else:
key = exposure_unit['key']
unit_id = self.parent.get_existing_keyword(key)
if unit_id:
units = []
for index in range(self.lstUnits.count()):
item = self.lstUnits.item(index)
units.append(item.data(QtCore.Qt.UserRole))
if unit_id in units:
self.lstUnits.setCurrentRow(units.index(unit_id))
self.auto_select_one_item(self.lstUnits)
def set_widgets(self):
"""Set widgets on the layer purpose tab."""
self.clear_further_steps()
# Set widgets
self.lstCategories.clear()
self.lblDescribeCategory.setText('')
self.lblIconCategory.setPixmap(QPixmap())
self.lblSelectCategory.setText(
category_question % self.parent.layer.name())
purposes = self.purposes_for_layer()
for purpose in purposes:
if not isinstance(purpose, dict):
purpose = definition(purpose)
item = QListWidgetItem(purpose['name'], self.lstCategories)
item.setData(QtCore.Qt.UserRole, purpose['key'])
self.lstCategories.addItem(item)
# Check if layer keywords are already assigned
purpose_keyword = self.parent.get_existing_keyword('layer_purpose')
# Overwrite the purpose_keyword if it's KW mode embedded in IFCW mode
if self.parent.parent_step:
purpose_keyword = self.parent.\
get_parent_mode_constraints()[0]['key']
# Set values based on existing keywords or parent mode
if purpose_keyword:
purposes = []
for index in range(self.lstCategories.count()):
item = self.lstCategories.item(index)
purposes.append(item.data(QtCore.Qt.UserRole))
if purpose_keyword in purposes:
self.lstCategories.setCurrentRow(
purposes.index(purpose_keyword))
self.auto_select_one_item(self.lstCategories)
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)