def __init__(self,
parent=None,
selectMode=True,
filter_data_source='',
access_templates=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.notifBar = NotificationBar(self.vlNotification)
self._mode = selectMode
# Filter templates by the specified table name
self._filter_data_source = filter_data_source
# Document templates in current profile
self._profile_templates = []
self._current_profile = current_profile()
# Load current profile templates
self._load_current_profile_templates()
self.access_templates = access_templates or []
if selectMode:
self.buttonBox.setVisible(True)
self.manageButtonBox.setVisible(False)
currHeight = self.size().height()
self.resize(200, currHeight)
else:
self.buttonBox.setVisible(False)
self.manageButtonBox.setVisible(True)
self.setWindowTitle(
QApplication.translate("TemplateDocumentSelector",
"Template Manager"))
# Configure manage buttons
btnEdit = self.manageButtonBox.button(QDialogButtonBox.Ok)
btnEdit.setText(
QApplication.translate("TemplateDocumentSelector", "Edit..."))
btnEdit.setIcon(GuiUtils.get_icon("edit.png"))
btnDelete = self.manageButtonBox.button(QDialogButtonBox.Save)
btnDelete.setText(
QApplication.translate("TemplateDocumentSelector", "Delete"))
btnDelete.setIcon(GuiUtils.get_icon("delete.png"))
# Connect signals
self.buttonBox.accepted.connect(self.onAccept)
btnEdit.clicked.connect(self.onEditTemplate)
btnDelete.clicked.connect(self.onDeleteTemplate)
# Get saved document templates then add to the model
templates = documentTemplates()
self._docItemModel = QStandardItemModel(parent)
self._docItemModel.setColumnCount(2)
# Append current profile templates to the model.
for dt in self._profile_templates:
if self._template_contains_filter_table(
dt): # and dt.name in self.access_templates:
doc_name_item = self._createDocNameItem(dt.name)
file_path_item = QStandardItem(dt.path)
self._docItemModel.appendRow([doc_name_item, file_path_item])
self.lstDocs.setModel(self._docItemModel)
def _buildfromlayer(self, widget, layerconfig):
layername = layerconfig['layer']
keyfield = layerconfig['key']
valuefield = layerconfig['value']
filterexp = layerconfig.get('filter', None)
try:
layer = utils.layer_by_name(layername)
except IndexError:
roam.utils.warning(
"Can't find layer {} in project".format(layername))
return
keyfieldindex = layer.fields().lookupField(keyfield)
valuefieldindex = layer.fields().lookupField(valuefield)
if keyfieldindex == -1 or valuefieldindex == -1:
roam.utils.warning(f"Can't find key or value column for widget "
f"Id: {self.id} "
f"Layer: {layername} "
f"Key: {keyfield} - {keyfieldindex} "
f"Value: {valuefield} - {valuefieldindex} ")
return
if self.allownulls:
item = QStandardItem('(no selection)')
item.setData(None, Qt.UserRole)
self.listmodel.appendRow(item)
fields = [keyfieldindex, valuefieldindex]
iconfieldindex = layer.fields().lookupField('icon')
if iconfieldindex > -1:
fields.append("icon")
if not filterexp and valuefieldindex == keyfieldindex and iconfieldindex == -1:
values = layer.uniqueValues(keyfieldindex)
values = sorted(values)
for value in values:
value = nullconvert(value)
item = QStandardItem(value)
item.setData(value, Qt.UserRole)
self.listmodel.appendRow(item)
return
features = roam.api.utils.search_layer(layer,
filterexp,
fields,
with_geometry=False)
# Sort the fields based on value field
features = sorted(features, key=lambda f: f[valuefield])
for feature in features:
keyvalue = nullconvert(feature[keyfieldindex])
valuvalue = nullconvert(feature[valuefield])
try:
path = feature["icon"]
icon = QIcon(path)
except KeyError:
icon = QIcon()
item = QStandardItem(keyvalue)
item.setData(str(valuvalue), Qt.UserRole)
item.setIcon(icon)
self.listmodel.appendRow(item)
def addRow(self):
items = [QStandardItem('0') for i in range(self.tblView.model().columnCount())]
self.tblView.model().appendRow(items)
def _edit_token(self, token_info: dict):
row = self.tableView.currentIndex().row()
self.token_model.insertRow(
row + 1, [QStandardItem(token_info[k]) for k in ["name", "token"]])
it = self.token_model.takeRow(row)
self.check_used_token_changed(row)
def setColumnCombos(self, cols, quotedCols):
# get sensible default columns. do this before sorting in case there's hints in the column order (e.g., id is more likely to be first)
try:
defaultGeomCol = next(
col for col in cols
if col in ['geom', 'geometry', 'the_geom', 'way'])
except:
defaultGeomCol = None
try:
defaultUniqueCol = [col for col in cols if 'id' in col][0]
except:
defaultUniqueCol = None
colNames = sorted(zip(cols, quotedCols))
newItems = []
uniqueIsFilled = False
for (col, quotedCol) in colNames:
item = QStandardItem(col)
item.setData(quotedCol)
item.setEnabled(True)
item.setCheckable(self.allowMultiColumnPk)
item.setSelectable(not self.allowMultiColumnPk)
if self.allowMultiColumnPk:
matchingItems = self.uniqueModel.findItems(col)
if matchingItems:
item.setCheckState(matchingItems[0].checkState())
uniqueIsFilled = uniqueIsFilled or matchingItems[
0].checkState() == Qt.Checked
else:
item.setCheckState(Qt.Unchecked)
newItems.append(item)
if self.allowMultiColumnPk:
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
self.uniqueChanged()
else:
previousUniqueColumn = self.uniqueCombo.currentText()
self.uniqueModel.clear()
self.uniqueModel.appendColumn(newItems)
if self.uniqueModel.findItems(previousUniqueColumn):
self.uniqueCombo.setEditText(previousUniqueColumn)
uniqueIsFilled = True
oldGeometryColumn = self.geomCombo.currentText()
self.geomCombo.clear()
self.geomCombo.addItems(cols)
self.geomCombo.setCurrentIndex(
self.geomCombo.findText(oldGeometryColumn, Qt.MatchExactly))
# set sensible default columns if the columns are not already set
try:
if self.geomCombo.currentIndex() == -1:
self.geomCombo.setCurrentIndex(cols.index(defaultGeomCol))
except:
pass
items = self.uniqueModel.findItems(defaultUniqueCol)
if items and not uniqueIsFilled:
if self.allowMultiColumnPk:
items[0].setCheckState(Qt.Checked)
else:
self.uniqueCombo.setEditText(defaultUniqueCol)
try:
pass
except:
pass
def addColumn(self):
model = self.tblView.model()
items = [QStandardItem('0') for i in range(model.rowCount())]
model.appendColumn(items)
def _populate_trv(self, trv_widget, result, expand=False):
model = QStandardItemModel()
trv_widget.setModel(model)
trv_widget.setUniformRowHeights(False)
icon_folder = self.plugin_dir + os.sep + 'icons' + os.sep + 'dialogs' + os.sep + '20x20' + os.sep
path_icon_blue = icon_folder + os.sep + '36.png'
path_icon_red = icon_folder + os.sep + '100.png'
# Section Processes
section_processes = QStandardItem('{}'.format('Processes'))
for group, functions in result['processes']['fields'].items():
parent1 = QStandardItem(f'{group} [{len(functions)} Giswater algorithm]')
self.no_clickable_items.append(f'{group} [{len(functions)} Giswater algorithm]')
functions.sort(key=self._sort_list, reverse=False)
for function in functions:
func_name = QStandardItem(str(function['functionname']))
label = QStandardItem(str(function['alias']))
font = label.font()
font.setPointSize(8)
label.setFont(font)
row = tools_db.check_function(function['functionname'])
if not row:
if os.path.exists(path_icon_red):
icon = QIcon(path_icon_red)
label.setIcon(icon)
label.setForeground(QColor(255, 0, 0))
msg = f"Function {function['functionname']}" \
f" configured on the table config_toolbox, but not found in the database"
label.setToolTip(msg)
self.no_clickable_items.append(str(function['alias']))
else:
if os.path.exists(path_icon_blue):
icon = QIcon(path_icon_blue)
label.setIcon(icon)
label.setToolTip(function['functionname'])
parent1.appendRow([label, func_name])
section_processes.appendRow(parent1)
# Section Reports
reports_processes = QStandardItem('{}'.format('Reports'))
for group, functions in result['reports']['fields'].items():
parent1 = QStandardItem(f'{group} [{len(functions)} Reports functions]')
self.no_clickable_items.append(f'{group} [{len(functions)} Reports functions]')
functions.sort(key=self._sort_list, reverse=False)
for function in functions:
func_name = QStandardItem(str(function['listname']))
label = QStandardItem(str(function['alias']))
font = label.font()
font.setPointSize(8)
label.setFont(font)
parent1.appendRow([label, func_name])
if os.path.exists(path_icon_blue):
icon = QIcon(path_icon_blue)
label.setIcon(icon)
reports_processes.appendRow(parent1)
if os.path.exists(path_icon_blue):
icon = QIcon(path_icon_blue)
section_processes.setIcon(icon)
reports_processes.setIcon(icon)
model.appendRow(section_processes)
model.appendRow(reports_processes)
section_index = model.indexFromItem(section_processes)
reports_index = model.indexFromItem(reports_processes)
trv_widget.expand(section_index)
trv_widget.expand(reports_index)
if expand:
trv_widget.expandAll()
def fillTreeUsingProviders(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels(
[self.tr('Setting'), self.tr('Value')])
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
"""
Filter 'General', 'Models' and 'Scripts' items
"""
priorityKeys = [
self.tr('General'),
self.tr('Models'),
self.tr('Scripts')
]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
# add menu item only if it has any search matches
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
"""
Filter 'Providers' items
"""
providersItem = QStandardItem(self.tr('Providers'))
icon = QIcon(os.path.join(pluginPath, 'images', 'alg.png'))
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in settings.keys():
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
"""
Filter 'Menus' items
"""
menusItem = QStandardItem(self.tr('Menus (requires restart)'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
menusItem.setIcon(icon)
menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [menusItem, emptyItem])
providers = Processing.providers
for provider in providers:
providerDescription = provider.getDescription()
groupItem = QStandardItem(providerDescription)
icon = provider.getIcon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algs:
algItem = QStandardItem(alg.i18n_name or alg.name)
algItem.setIcon(icon)
algItem.setEditable(False)
try:
settingMenu = ProcessingConfig.settings[
"MENU_" + alg.commandLineName()]
settingButton = ProcessingConfig.settings[
"BUTTON_" + alg.commandLineName()]
settingIcon = ProcessingConfig.settings[
"ICON_" + alg.commandLineName()]
except:
continue
self.items[settingMenu] = SettingItem(settingMenu)
self.items[settingButton] = SettingItem(settingButton)
self.items[settingIcon] = SettingItem(settingIcon)
menuLabelItem = QStandardItem("Menu path")
menuLabelItem.setEditable(False)
buttonLabelItem = QStandardItem("Add button in toolbar")
buttonLabelItem.setEditable(False)
iconLabelItem = QStandardItem("Icon")
iconLabelItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
algItem.insertRow(0, [menuLabelItem, self.items[settingMenu]])
algItem.insertRow(0,
[buttonLabelItem, self.items[settingButton]])
algItem.insertRow(0, [iconLabelItem, self.items[settingIcon]])
groupItem.insertRow(0, [algItem, emptyItem])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def initDropdowns(self):
# ou = Organisational Units
self.ou_model = QStandardItemModel()
self.pe_model = QStandardItemModel()
self.dx_model = QStandardItemModel()
# easy way to add ALL organisationUnits
jsono = self.get_json('{}organisationUnits.json?paging=false&level={}'.format(self.api_url, self.level))
if jsono:
self.ou_model.appendRow([QStandardItem("ALL"), QStandardItem("ALL")])
for item in jsono['organisationUnits']:
display_name = item['displayName']
ou_id = item['id']
#self.info('{} - {}'.format(ou_id, display_name))
self.ou_model.appendRow([QStandardItem(display_name), QStandardItem(ou_id)])
self.dlg.cb_ou.setModel(self.ou_model)
else:
self.gui_inited = False
return False
# dx = indicators and data elements
# indicators
jsono = self.get_json('{}indicators.json?paging=false&level={}'.format(self.api_url, self.level))
if jsono:
for item in jsono['indicators']:
display_name = item['displayName']
ou_id = item['id']
#self.info('{} - {}'.format(ou_id, display_name))
self.dx_model.appendRow([QStandardItem(display_name), QStandardItem(ou_id)])
else:
self.gui_inited = False
return False
# dataElements
jsono = self.get_json('{}dataElements.json?paging=false&level={}'.format(self.api_url, self.level))
if jsono:
for item in jsono['dataElements']:
display_name = item['displayName']
ou_id = item['id']
#self.info('{} - {}'.format(ou_id, display_name))
self.dx_model.appendRow([QStandardItem(display_name), QStandardItem(ou_id)])
self.dlg.cb_dx.setModel(self.dx_model)
else:
self.gui_inited = False
return False
for pe in ['2018', '2017', '2016', '2015', 'LAST_YEAR', 'LAST_5_YEARS',
'THIS_MONTH', 'LAST_MONTH', 'LAST_3_MONTHS', 'MONTHS_THIS_YEAR', 'LAST_12_MONTHS']:
self.pe_model.appendRow([QStandardItem(pe), QStandardItem(pe)])
self.dlg.cb_pe.setModel(self.pe_model)
self.ou_items = []
self.pe_items = []
self.dx_items = []
self.dlg.cb_ou.setCurrentIndex(-1)
self.dlg.cb_dx.setCurrentIndex(-1)
self.dlg.cb_pe.setCurrentIndex(-1)
self.gui_inited = True
self.create_url()
self.info('Finish INIT dropdowns')
return True
def build_tree_view(self, qris_project, new_item=None):
"""Builds items in the tree view based on dictionary values that are part of the project"""
self.qris_project = qris_project
self.model.clear()
self.tree_state = {}
rootNode = self.model.invisibleRootItem()
# set the project root
project_node = QStandardItem(self.qris_project.project_name)
project_node.setIcon(QIcon(':/plugins/qris_toolbar/icon.png'))
project_node.setData('project_root', item_code['item_type'])
rootNode.appendRow(project_node)
self.treeView.setExpanded(project_node.index(), True)
# Add project extent layers to tree
extent_folder = QStandardItem("Project Extents")
extent_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png'))
extent_folder.setData('extent_folder', item_code['item_type'])
project_node.appendRow(extent_folder)
for extent in self.qris_project.project_extents.values():
extent_node = QStandardItem(extent.display_name)
extent_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_project_extent.png'))
extent_node.setData('extent_node', item_code['item_type'])
extent_node.setData(extent, item_code['INSTANCE'])
extent_folder.appendRow(extent_node)
# Add project layers node
layers_folder = QStandardItem("Project Layers")
layers_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png'))
layers_folder.setData('layers_folder', item_code['item_type'])
project_node.appendRow(layers_folder)
# TODO extend this for geometry types and raster layers
for layer in self.qris_project.project_vector_layers.values():
layer_node = QStandardItem(layer.display_name)
# TODO change icon by type
layer_node.setIcon(QIcon(':/plugins/qris_toolbar/test_layers.png'))
layer_node.setData('layer_node', item_code['item_type'])
layer_node.setData(layer, item_code['INSTANCE'])
layers_folder.appendRow(layer_node)
# # Add riverscape surfaces node
# # TODO go through and add layers to the tree
# riverscape_surfaces_node = QStandardItem("Riverscape Surfaces")
# riverscape_surfaces_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# riverscape_surfaces_node.setData('riverscape_surfaces_folder', item_code['item_type'])
# riverscape_surfaces_node.setData('group', item_code['item_layer'])
# project_node.appendRow(riverscape_surfaces_node)
# # Add riverscape segments node
# # TODO go through and add layers to the tree
# riverscape_segments_node = QStandardItem("Riverscape Segments")
# riverscape_segments_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# riverscape_segments_node.setData('riverscape_segments_folder', item_code['item_type'])
# riverscape_segments_node.setData('group', item_code['item_layer'])
# project_node.appendRow(riverscape_segments_node)
# # Add detrended rasters to tree
# detrended_rasters = QStandardItem("Detrended Rasters")
# detrended_rasters.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# detrended_rasters.setData("DetrendedRastersFolder", item_code['item_type'])
# detrended_rasters.setData('group', item_code['item_layer'])
# project_node.appendRow(detrended_rasters)
# for raster in self.qris_project.detrended_rasters.values():
# detrended_raster = QStandardItem(raster.name)
# detrended_raster.setIcon(QIcon(':/plugins/qris_toolbar/qris_raster.png'))
# detrended_raster.setData('DetrendedRaster', item_code['item_type'])
# detrended_raster.setData(raster, item_code['INSTANCE'])
# detrended_raster.setData('raster_layer', item_code['item_layer'])
# detrended_rasters.appendRow(detrended_raster)
# if len(raster.surfaces.values()) > 0:
# item_surfaces = QStandardItem("Surfaces")
# item_surfaces.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# item_surfaces.setData('group', item_code['item_layer'])
# detrended_raster.appendRow(item_surfaces)
# for surface in raster.surfaces.values():
# item_surface = QStandardItem(surface.name)
# item_surface.setIcon(QIcon(':/plugins/qris_toolbar/layers/Polygon.png'))
# item_surface.setData('DetrendedRasterSurface', item_code['item_type'])
# item_surface.setData('surface_layer', item_code['item_layer'])
# item_surface.setData(surface, item_code['INSTANCE'])
# item_surfaces.appendRow(item_surface)
# # Add assessments to tree
# assessments_parent_node = QStandardItem("Riverscape Assessments")
# assessments_parent_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# assessments_parent_node.setData('assessments_folder', item_code['item_type'])
# assessments_parent_node.setData('group', item_code['item_layer'])
# project_node.appendRow(assessments_parent_node)
# if self.qris_project.project_assessments:
# self.qris_project.assessments_path = os.path.join(self.qris_project.project_path, "Assessments.gpkg")
# assessments_layer = QgsVectorLayer(self.qris_project.assessments_path + "|layername=assessments", "assessments", "ogr")
# for assessment_feature in assessments_layer.getFeatures():
# assessment_node = QStandardItem(assessment_feature.attribute('assessment_date').toString('yyyy-MM-dd'))
# assessment_node.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# assessment_node.setData('dam_assessment', item_code['item_type'])
# assessment_node.setData('group', item_code['item_layer'])
# assessment_node.setData(assessment_feature.attribute('fid'), item_code['feature_id'])
# assessments_parent_node.appendRow(assessment_node)
# assessments_parent_node.sortChildren(Qt.AscendingOrder)
# Add designs to tree
design_folder = QStandardItem("Low-Tech Designs")
design_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_folder.png'))
design_folder.setData('design_folder', item_code['item_type'])
project_node.appendRow(design_folder)
self.treeView.setExpanded(design_folder.index(), True)
design_geopackage_path = self.qris_project.project_designs.geopackage_path(
self.qris_project.project_path)
designs_path = design_geopackage_path + '|layername=designs'
if os.path.exists(design_geopackage_path):
designs_layer = QgsVectorLayer(designs_path, "designs", "ogr")
for design_feature in designs_layer.getFeatures():
# If these data types stick this should be refactored into a create node function
design_node = QStandardItem(design_feature.attribute('name'))
design_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_design.png'))
design_node.setData('design', item_code['item_type'])
design_node.setData(design_feature.attribute('fid'),
item_code['feature_id'])
design_folder.appendRow(design_node)
# TODO add the structure, footprint, and zoi to the tree under each design
# TODO This just doesn't work very well
design_folder.sortChildren(Qt.AscendingOrder)
# populate structure types
structure_type_folder = QStandardItem("Structure Types")
structure_type_folder.setIcon(
QIcon(':/plugins/qris_toolbar/test_settings.png'))
structure_type_folder.setData('structure_type_folder',
item_code['item_type'])
design_folder.appendRow(structure_type_folder)
structure_type_path = design_geopackage_path + '|layername=structure_types'
structure_type_layer = QgsVectorLayer(structure_type_path,
"structure_types", "ogr")
for structure_type in structure_type_layer.getFeatures():
structure_type_node = QStandardItem(
structure_type.attribute('name'))
# TODO change the icon
structure_type_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_structure.png'))
structure_type_node.setData('structure_type',
item_code['item_type'])
structure_type_node.setData(structure_type.attribute('fid'),
item_code['feature_id'])
structure_type_folder.appendRow(structure_type_node)
# populate design phases types
phase_folder = QStandardItem("Implementation Phases")
# TODO change icon
phase_folder.setIcon(QIcon(':/plugins/qris_toolbar/test_settings.png'))
phase_folder.setData('phase_folder', item_code['item_type'])
design_folder.appendRow(phase_folder)
phase_path = design_geopackage_path + '|layername=phases'
phase_layer = QgsVectorLayer(phase_path, "phases", "ogr")
for phase in phase_layer.getFeatures():
phase_node = QStandardItem(phase.attribute('name'))
# TODO change the icon
phase_node.setIcon(QIcon(':/plugins/qris_toolbar/test_phase.png'))
phase_node.setData('phase', item_code['item_type'])
phase_node.setData(phase.attribute('fid'), item_code['feature_id'])
phase_folder.appendRow(phase_node)
# populate zoi types
zoi_type_folder = QStandardItem("ZOI Types")
zoi_type_folder.setIcon(
QIcon(':/plugins/qris_toolbar/test_settings.png'))
zoi_type_folder.setData('zoi_type_folder', item_code['item_type'])
design_folder.appendRow(zoi_type_folder)
zoi_type_path = design_geopackage_path + '|layername=zoi_types'
zoi_type_layer = QgsVectorLayer(zoi_type_path, "zoi_types", "ogr")
for zoi_type in zoi_type_layer.getFeatures():
zoi_type_node = QStandardItem(zoi_type.attribute('name'))
# TODO change the icon
zoi_type_node.setIcon(
QIcon(':/plugins/qris_toolbar/test_influence.png'))
zoi_type_node.setData('zoi_type', item_code['item_type'])
zoi_type_node.setData(zoi_type.attribute('fid'),
item_code['feature_id'])
zoi_type_folder.appendRow(zoi_type_node)
# Add a placed for photos
# photos_folder = QStandardItem("Project Photos")
# photos_folder.setIcon(QIcon(':/plugins/qris_toolbar/BrowseFolder.png'))
# photos_folder.setData('photos_folder', item_code['item_type'])
# project_node.appendRow(photos_folder)
# TODO for now we are expanding the map however need to remember expanded state or add new nodes as we add data
# self.treeView.expandAll()
# Check if new item is in the tree, if it is pass it to the add_to_map function
# Adds a test comment
if new_item is not None and new_item != '':
selected_item = self._find_item_in_model(new_item)
if selected_item is not None:
add_to_map(self.qris_project, self.model, selected_item)
def fillStartEndPointsCombos(self):
""" Change start and end point combo when an other traversing type selected.
"""
# get selected stations
oldStartPoint = self.ui.StartPointComboBox.itemData(
self.ui.StartPointComboBox.currentIndex())
oldEndPoint = self.ui.EndPointComboBox.itemData(
self.ui.EndPointComboBox.currentIndex())
# clear combos
self.ui.StartPointComboBox.clear()
self.ui.EndPointComboBox.clear()
self.ui.StartPointComboBox.setEnabled(False)
self.ui.EndPointComboBox.setEnabled(False)
# get combobox models
combomodel1 = self.ui.StartPointComboBox.model()
combomodel2 = self.ui.EndPointComboBox.model()
# get stations
known_stations = get_stations(True, False)
oriented_stations = get_stations(True, True)
# fill StartPointComboBox and EndPointComboBox
start_points = []
end_points = []
if oriented_stations is not None and self.ui.ClosedRadio.isChecked():
for stn in oriented_stations:
start_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
end_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.StartPointComboBox.setEnabled(True)
elif known_stations is not None and self.ui.LinkRadio.isChecked():
for stn in known_stations:
start_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
end_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.StartPointComboBox.setEnabled(True)
self.ui.EndPointComboBox.setEnabled(True)
elif oriented_stations is not None and self.ui.OpenRadio.isChecked():
for stn in oriented_stations:
start_points.append(
[u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.StartPointComboBox.setEnabled(True)
self.ui.EndPointComboBox.setEnabled(True)
known_points = get_known()
if start_points is not None:
for startpoint in start_points:
item = QStandardItem(startpoint[0])
item.setData(startpoint[1], Qt.UserRole)
if known_points is not None and startpoint[1][
0] in known_points:
itemfont = item.font()
itemfont.setWeight(QFont.Bold)
item.setFont(itemfont)
combomodel1.appendRow(item)
if end_points is not None:
for endpoint in end_points:
item = QStandardItem(endpoint[0])
item.setData(endpoint[1], Qt.UserRole)
if known_points is not None and endpoint[1][0] in known_points:
itemfont = item.font()
itemfont.setWeight(QFont.Bold)
item.setFont(itemfont)
combomodel2.appendRow(item)
# select previously selected start/end point if present in the list
self.ui.StartPointComboBox.setCurrentIndex(
self.ui.StartPointComboBox.findData(oldStartPoint))
self.ui.EndPointComboBox.setCurrentIndex(
self.ui.EndPointComboBox.findData(oldEndPoint))
# in case of closed traverse ens point must be the same as start point
if self.ui.ClosedRadio.isChecked():
self.ui.EndPointComboBox.setCurrentIndex(
self.ui.StartPointComboBox.currentIndex())
def _create_item(self, text):
item = QStandardItem(text)
return item
def fillStationCombos(self):
""" Change dialog controls when an other calculation type selected.
"""
# get selected stations
oldStation1 = self.ui.Station1Combo.itemData(self.ui.Station1Combo.currentIndex())
oldStation2 = self.ui.Station2Combo.itemData(self.ui.Station2Combo.currentIndex())
# clear station combos
self.ui.Station1Combo.clear()
self.ui.Station2Combo.clear()
self.ui.Station1Combo.setEnabled(False)
self.ui.Station2Combo.setEnabled(False)
# get combobox models
combomodel1 = self.ui.Station1Combo.model()
combomodel2 = self.ui.Station2Combo.model()
# get stations
known_stations = get_stations(True, False)
all_stations = get_stations(False, False)
oriented_stations = get_stations(True, True)
# fill Station1Combo and Station2Combo
stations1 = []
stations2 = []
if known_stations is not None and self.ui.OrientRadio.isChecked():
for stn in known_stations:
stations1.append([u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.Station1Combo.setEnabled(True)
elif oriented_stations is not None and (self.ui.RadialRadio.isChecked() or
self.ui.IntersectRadio.isChecked()):
for stn in oriented_stations:
stations1.append([u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
if self.ui.IntersectRadio.isChecked():
stations2.append([u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
self.ui.Station1Combo.setEnabled(True)
if self.ui.IntersectRadio.isChecked():
self.ui.Station2Combo.setEnabled(True)
elif all_stations is not None and (self.ui.ResectionRadio.isChecked() or
self.ui.FreeRadio.isChecked()):
self.ui.Station1Combo.setEnabled(True)
for stn in all_stations:
stations1.append([u"%s (%s:%s)" % (stn[0], stn[1], stn[2]), stn])
known_points = get_known()
if stations1 is not None:
for station in stations1:
item = QStandardItem(station[0])
item.setData(station[1], Qt.UserRole)
if known_points is not None and station[1][0] in known_points:
itemfont = item.font()
itemfont.setWeight(QFont.Bold)
item.setFont(itemfont)
combomodel1.appendRow(item)
if self.ui.IntersectRadio.isChecked() and stations2 is not None:
for station in stations2:
item = QStandardItem(station[0])
item.setData(station[1], Qt.UserRole)
if known_points is not None and station[1][0] in known_points:
itemfont = item.font()
itemfont.setWeight(QFont.Bold)
item.setFont(itemfont)
combomodel2.appendRow(item)
# select previously selected stations if present in the list
self.ui.Station1Combo.setCurrentIndex(self.ui.Station1Combo.findData(oldStation1))
self.ui.Station2Combo.setCurrentIndex(self.ui.Station2Combo.findData(oldStation2))
def llegirZonesGPKG(self):
try:
QvFuncions.setReadOnlyFile(self.__zones)
pathDistrictes = self.__zones + '|layername=districtes'
layerDistrictes = QgsVectorLayer(pathDistrictes, 'ogr')
pathBarris = self.__zones + '|layername=barris'
layerBarris = QgsVectorLayer(pathBarris, 'ogr')
rowsDistrictes = layerDistrictes.getFeatures()
llistaDistrictes = []
for rowD in rowsDistrictes:
#print(rowD.attributes())
#zona = ""
num_districte = rowD.attributes()[1]
nom_districte = rowD.attributes()[2]
num_barri = ""
nom_barri = ""
geometria = rowD.geometry().boundingBox()
x_min = str(geometria.xMinimum())
y_min = str(geometria.yMinimum())
x_max = str(geometria.xMaximum())
y_max = str(geometria.yMaximum())
item = [
num_districte, nom_districte, num_barri, nom_barri, x_min,
y_min, x_max, y_max
]
llistaDistrictes.append(item)
def ordenaPerNumDistricte(elem):
return elem[0]
llistaDistrictes.sort(key=ordenaPerNumDistricte)
#print(llistaDistrictes)
rowsBarris = layerBarris.getFeatures()
llistaBarris = []
for rowB in rowsBarris:
#print(rowB.attributes())
#zona = ""
num_districte = rowB.attributes()[3]
nom_districte = llistaDistrictes[int(num_districte) - 1][1]
num_barri = rowB.attributes()[1]
nom_barri = rowB.attributes()[2]
geometria = rowB.geometry().boundingBox()
x_min = str(geometria.xMinimum())
y_min = str(geometria.yMinimum())
x_max = str(geometria.xMaximum())
y_max = str(geometria.yMaximum())
item = [
num_districte, nom_districte, num_barri, nom_barri, x_min,
y_min, x_max, y_max
]
llistaBarris.append(item)
def ordenaPerNumBarri(elem):
return elem[2]
llistaBarris.sort(key=ordenaPerNumBarri)
#print(llistaBarris)
self.labels = [
"ZONA", "DISTRICTE", "NOM_DISTRICTE", "BARRI", "NOM_BARRI",
"X_MIN", "Y_MIN", "X_MAX", "Y_MAX"
]
root = self.model.invisibleRootItem()
self.model.setColumnCount(len(self.labels))
self.model.setHorizontalHeaderLabels(self.labels)
#Afegir Barcelona com a arrel de l'arbre
bcn_dades = [
"00", "Barcelona", "00", "Barcelona", "419710.0553820258",
"4573818.80776309", "436533.35", "4591775.02"
]
bcn = [QStandardItem("Barcelona")]
for item in bcn_dades:
bcn.append(QStandardItem(item))
root.appendRow(bcn)
ultimaDistr = -1
itDist = 0
for b in llistaBarris:
if ultimaDistr != int(b[0]): #Afegir següent districte
dist = [QStandardItem(llistaDistrictes[itDist][1])]
for i in range(0, len(llistaDistrictes[itDist])):
dist.append(QStandardItem(llistaDistrictes[itDist][i]))
bcn[0].appendRow(dist)
itDist = itDist + 1
#Afegir següent Barri
barri = [QStandardItem(b[3])]
for item in b:
barri.append(QStandardItem(item))
dist[0].appendRow(barri)
ultimaDistr = int(b[0])
return True
except:
print("Error en construcció de l'arbre de zones")
return False
def endpointselectaction(self):
endpointIndex = self.dlg.comboBox.currentIndex()
self.dlg.queryTemplates.clear()
print("changing endpoint")
conceptlist = []
self.dlg.geoClassListModel.clear()
if "endpoint" in self.triplestoreconf[
endpointIndex] and self.triplestoreconf[endpointIndex][
"endpoint"] != "" and (
not "staticconcepts"
in self.triplestoreconf[endpointIndex] or
"staticconcepts" in self.triplestoreconf[endpointIndex]
and
self.triplestoreconf[endpointIndex]["staticconcepts"]
== []) and "geoconceptquery" in self.triplestoreconf[
endpointIndex] and self.triplestoreconf[
endpointIndex]["geoconceptquery"] != "":
item = QStandardItem()
item.setText("Loading...")
self.dlg.geoClassListModel.appendRow(item)
if "examplequery" in self.triplestoreconf[endpointIndex]:
conceptlist = self.getGeoConcepts(
self.triplestoreconf[endpointIndex]["endpoint"],
self.triplestoreconf[endpointIndex]["geoconceptquery"],
"class", None, True,
self.triplestoreconf[endpointIndex]["examplequery"])
else:
conceptlist = self.getGeoConcepts(
self.triplestoreconf[endpointIndex]["endpoint"],
self.triplestoreconf[endpointIndex]["geoconceptquery"],
"class", None, True, None)
elif "staticconcepts" in self.triplestoreconf[
endpointIndex] and self.triplestoreconf[endpointIndex][
"staticconcepts"] != []:
conceptlist = self.triplestoreconf[endpointIndex]["staticconcepts"]
self.dlg.autocomplete["completerClassList"] = {}
for concept in conceptlist:
item = QStandardItem()
item.setData(concept, 1)
item.setText(concept[concept.rfind('/') + 1:])
self.dlg.autocomplete["completerClassList"][
concept[concept.rfind('/') + 1:]] = "<" + concept + ">"
self.dlg.geoClassListModel.appendRow(item)
self.dlg.inp_sparql2.updateNewClassList()
if len(conceptlist) > 0:
self.dlg.geoClassList.selectionModel().setCurrentIndex(
self.dlg.geoClassList.model().index(0, 0),
QItemSelectionModel.SelectCurrent)
if "examplequery" in self.triplestoreconf[endpointIndex]:
self.dlg.inp_sparql2.setPlainText(
self.triplestoreconf[endpointIndex]["examplequery"])
self.dlg.inp_sparql2.columnvars = {}
if "areaconcepts" in self.triplestoreconf[
endpointIndex] and self.triplestoreconf[endpointIndex][
"areaconcepts"]:
conceptlist2 = self.triplestoreconf[endpointIndex]["areaconcepts"]
for concept in conceptlist2:
self.dlg.areaconcepts.addItem(concept["concept"])
if "querytemplate" in self.triplestoreconf[endpointIndex]:
for concept in self.triplestoreconf[endpointIndex][
"querytemplate"]:
self.dlg.queryTemplates.addItem(concept["label"])
def on_tab_data_change(self, itm):
if itm.column() < 4:
model = itm.model()
# model = self.ui.tab_laws.model()
if itm.data(0) or itm.data(0) == .0:
if itm.column() == 0:
model.blockSignals(True)
if not model.item(itm.row(), 1):
model.setItem(itm.row(), 1, QStandardItem())
model.item(itm.row(), 1).setData(itm.data(0) / 60., 0)
if not model.item(itm.row(), 2):
model.setItem(itm.row(), 2, QStandardItem())
model.item(itm.row(), 2).setData(itm.data(0) / 3600., 0)
if not model.item(itm.row(), 3):
model.setItem(itm.row(), 3, QStandardItem())
model.item(itm.row(), 3).setData(itm.data(0) / 86400., 0)
model.blockSignals(False)
elif itm.column() == 1:
model.blockSignals(True)
if not model.item(itm.row(), 0):
model.setItem(itm.row(), 0, QStandardItem())
model.item(itm.row(), 0).setData(itm.data(0) * 60., 0)
if not model.item(itm.row(), 2):
model.setItem(itm.row(), 2, QStandardItem())
model.item(itm.row(), 2).setData(itm.data(0) / 60., 0)
if not model.item(itm.row(), 3):
model.setItem(itm.row(), 3, QStandardItem())
model.item(itm.row(), 3).setData(itm.data(0) / 1440., 0)
model.blockSignals(False)
elif itm.column() == 2:
model.blockSignals(True)
if not model.item(itm.row(), 0):
model.setItem(itm.row(), 0, QStandardItem())
model.item(itm.row(), 0).setData(itm.data(0) * 3600., 0)
if not model.item(itm.row(), 1):
model.setItem(itm.row(), 1, QStandardItem())
model.item(itm.row(), 1).setData(itm.data(0) * 60., 0)
if not model.item(itm.row(), 3):
model.setItem(itm.row(), 3, QStandardItem())
model.item(itm.row(), 3).setData(itm.data(0) / 24., 0)
model.blockSignals(False)
elif itm.column() == 3:
model.blockSignals(True)
if not model.item(itm.row(), 0):
model.setItem(itm.row(), 0, QStandardItem())
model.item(itm.row(), 0).setData(itm.data(0) * 86400., 0)
if not model.item(itm.row(), 1):
model.setItem(itm.row(), 1, QStandardItem())
model.item(itm.row(), 1).setData(itm.data(0) * 1440., 0)
if not model.item(itm.row(), 2):
model.setItem(itm.row(), 2, QStandardItem())
model.item(itm.row(), 2).setData(itm.data(0) * 24., 0)
model.blockSignals(False)
if not self.filling_tab:
model.sort(0)
idx = itm.index()
self.ui.tab_laws.scrollTo(idx, 0)
self.update_courbe("all")
else:
if not self.filling_tab:
idx = itm.index()
self.update_courbe([idx.column() - 4])
def _add_token(self, token_info: dict):
self.token_model.appendRow(
[QStandardItem(token_info[k]) for k in self.token_info_keys])
def _refresh_token(self):
tokens = self.token_groups.options(self.server)
self.clear()
it = self.invisibleRootItem()
# it.appendRow(QStandardItem())
it.appendRows([QStandardItem(t) for t in tokens if len(t) > 0])
def import_csv(self):
""" Import csv file"""
nb_col = 7
typ_time = ''
first_ligne = True
if int(qVersion()[0]) < 5: # qt4
listf = QFileDialog.getOpenFileNames(None, 'File Selection',
self.mgis.repProject,
"File (*.txt *.csv *.met)")
else: # qt5
listf, _ = QFileDialog.getOpenFileNames(
None, 'File Selection', self.mgis.repProject,
"File (*.txt *.csv *.met)")
if listf:
error = False
self.filling_tab = True
model = self.create_tab_model()
r = 0
filein = open(listf[0], "r")
for num_ligne, ligne in enumerate(filein):
if ligne[0] != '#':
liste = ligne.replace('\n', '').replace('\t',
' ').split(";")
if len(liste) == nb_col:
if first_ligne:
val = data_to_float(liste[0])
if val is not None:
typ_time = 'num'
else:
val = data_to_date(liste[0])
if val is not None:
typ_time = 'date'
date_ref = val
self.ui.cb_date.setCheckState(2)
date_ref_str = datetime.strftime(
date_ref, '%Y-%m-%d %H:%M:%S')
self.ui.de_date.setDateTime(
QDateTime().fromString(
date_ref_str,
'yyyy-MM-dd HH:mm:ss'))
else:
# print('e1')
error = True
break
first_ligne = False
model.insertRow(r)
for c, val in enumerate(liste):
if c == 0 and typ_time == 'date':
date_tmp = data_to_date(val)
delta = date_tmp - date_ref
val = delta.total_seconds()
itm = QStandardItem()
itm.setData(data_to_float(val), 0)
if c == 0:
model.setItem(r, c, itm)
else:
model.setItem(r, c + 4, itm)
r += 1
else:
# print('e2')
error = True
break
filein.close()
self.filling_tab = False
if not error:
self.ui.tab_sets.setModel(model)
self.update_courbe("all")
else:
if self.mgis.DEBUG:
self.mgis.add_info("Import failed ({})".format(listf[0]))
def _recurse_tree(self,
bl_el=None,
proj_el=None,
parent: QStandardItem = None):
if self.business_logic is None:
return
if bl_el is None:
bl_el = self.business_logic.find('Node')
is_root = proj_el is None
bl_attr = bl_el.attrib
if proj_el is None:
proj_el = self.project
new_proj_el = proj_el
if 'xpath' in bl_el.attrib:
new_proj_el = xpathone_withref(self.project, proj_el,
bl_el.attrib['xpath'])
if new_proj_el is None:
# We just ignore layers we can't find. Log them though
return
# The label is either explicit or it's an xpath lookup
curr_label = '<unknown>'
if 'label' in bl_el.attrib:
curr_label = bl_el.attrib['label']
elif 'xpathlabel' in bl_el.attrib:
found = new_proj_el.xpath(bl_el.attrib['xpathlabel'])
curr_label = found[0].text if found is not None and len(
found) > 0 else '<unknown>'
curr_item = QStandardItem()
curr_item.setText(curr_label)
children_container = bl_el.find('Children')
# If there are children then this is a branch
if children_container:
curr_item.setIcon(
QIcon(':/plugins/qrave_toolbar/BrowseFolder.png'))
if is_root is True:
curr_item.setData(
ProjectTreeData(QRaveTreeTypes.PROJECT_ROOT,
project=self,
data=dict(children_container.attrib)),
Qt.UserRole),
else:
curr_item.setData(
ProjectTreeData(QRaveTreeTypes.PROJECT_FOLDER,
project=self,
data=dict(children_container.attrib)),
Qt.UserRole),
for child_node in children_container.xpath('*'):
# Handle any explicit <Node> children
if child_node.tag == 'Node':
self._recurse_tree(child_node, new_proj_el, curr_item)
# Repeaters are a separate case
elif child_node.tag == 'Repeater':
qrepeater = QStandardItem(
QIcon(':/plugins/qrave_toolbar/BrowseFolder.png'),
child_node.attrib['label'])
qrepeater.setData(
ProjectTreeData(QRaveTreeTypes.PROJECT_REPEATER_FOLDER,
project=self,
data=dict(children_container.attrib)),
Qt.UserRole),
curr_item.appendRow(qrepeater)
repeat_xpath = child_node.attrib['xpath']
repeat_node = child_node.find('Node')
if repeat_node is not None:
for repeater_el in new_proj_el.xpath(repeat_xpath):
self._recurse_tree(repeat_node, repeater_el,
qrepeater)
# Otherwise this is a leaf
else:
bl_type = bl_el.attrib['type']
if bl_type == 'polygon':
curr_item.setIcon(
QIcon(':/plugins/qrave_toolbar/layers/Polygon.png'))
elif bl_type == 'line':
curr_item.setIcon(
QIcon(':/plugins/qrave_toolbar/layers/Polyline.png'))
elif bl_type == 'point':
curr_item.setIcon(
QIcon(':/plugins/qrave_toolbar/layers/MultiDot.png'))
elif bl_type == 'raster':
curr_item.setIcon(
QIcon(':/plugins/qrave_toolbar/layers/Raster.png'))
else:
curr_item.setIcon(
QIcon(':/plugins/qrave_toolbar/RaveAddIn_16px.png'))
# Couldn't find this node. Ignore it.
meta = {
meta.attrib['name']: meta.text
for meta in new_proj_el.findall('MetaData/Meta')
}
new_proj_el.find('Path')
layer_name = None
layer_uri = os.path.join(self.project_dir,
new_proj_el.find('Path').text)
# If this is a geopackage it's special
if new_proj_el.getparent().tag == 'Layers':
layer_name = new_proj_el.find('Path').text
layer_uri = os.path.join(
self.project_dir,
new_proj_el.getparent().getparent().find('Path').text)
layer_type = bl_attr['type'] if 'type' in bl_attr else 'unknown'
map_layer = QRaveMapLayer(curr_label, layer_type, layer_uri,
bl_attr, meta, layer_name)
curr_item.setData(
ProjectTreeData(QRaveTreeTypes.LEAF,
project=self,
data=map_layer), Qt.UserRole)
if not map_layer.exists:
curr_item.setData(QBrush(Qt.red), Qt.ForegroundRole)
curr_item_font = curr_item.font()
curr_item_font.setItalic(True)
curr_item.setFont(curr_item_font)
curr_item.setToolTip('File not found: {}'.format(
map_layer.layer_uri))
elif map_layer.layer_uri:
curr_item.setToolTip(map_layer.layer_uri)
if parent:
parent.appendRow(curr_item)
return curr_item
def on_tab_data_change(self, itm):
if itm.column() < 4:
model = itm.model()
if itm.data(0) or itm.data(0) == .0:
if itm.column() == 0:
model.blockSignals(True)
if not model.item(itm.row(), 1):
model.setItem(itm.row(), 1, QStandardItem())
model.item(itm.row(), 1).setData(itm.data(0) / 60., 0)
if not model.item(itm.row(), 2):
model.setItem(itm.row(), 2, QStandardItem())
model.item(itm.row(), 2).setData(itm.data(0) / 3600., 0)
if not model.item(itm.row(), 3):
model.setItem(itm.row(), 3, QStandardItem())
model.item(itm.row(), 3).setData(itm.data(0) / 86400., 0)
if not model.item(itm.row(), 4):
date_itm = QStandardItem()
date_itm.setEditable(False)
model.setItem(itm.row(), 4, date_itm)
date = self.date_ref + timedelta(seconds=itm.data(0))
model.item(itm.row(),
4).setData(date.strftime('%d-%m-%Y %H:%M:%S'),
0)
model.blockSignals(False)
elif itm.column() == 1:
model.blockSignals(True)
if not model.item(itm.row(), 0):
model.setItem(itm.row(), 0, QStandardItem())
model.item(itm.row(), 0).setData(itm.data(0) * 60., 0)
if not model.item(itm.row(), 2):
model.setItem(itm.row(), 2, QStandardItem())
model.item(itm.row(), 2).setData(itm.data(0) / 60., 0)
if not model.item(itm.row(), 3):
model.setItem(itm.row(), 3, QStandardItem())
model.item(itm.row(), 3).setData(itm.data(0) / 1440., 0)
if not model.item(itm.row(), 4):
date_itm = QStandardItem()
date_itm.setEditable(False)
model.setItem(itm.row(), 4, date_itm)
date = self.date_ref + timedelta(minutes=itm.data(0))
model.item(itm.row(),
4).setData(date.strftime('%d-%m-%Y %H:%M:%S'),
0)
model.blockSignals(False)
elif itm.column() == 2:
model.blockSignals(True)
if not model.item(itm.row(), 0):
model.setItem(itm.row(), 0, QStandardItem())
model.item(itm.row(), 0).setData(itm.data(0) * 3600., 0)
if not model.item(itm.row(), 1):
model.setItem(itm.row(), 1, QStandardItem())
model.item(itm.row(), 1).setData(itm.data(0) * 60., 0)
if not model.item(itm.row(), 3):
model.setItem(itm.row(), 3, QStandardItem())
model.item(itm.row(), 3).setData(itm.data(0) / 24., 0)
if not model.item(itm.row(), 4):
date_itm = QStandardItem()
date_itm.setEditable(False)
model.setItem(itm.row(), 4, date_itm)
date = self.date_ref + timedelta(hours=itm.data(0))
model.item(itm.row(),
4).setData(date.strftime('%d-%m-%Y %H:%M:%S'),
0)
model.blockSignals(False)
elif itm.column() == 3:
model.blockSignals(True)
if not model.item(itm.row(), 0):
model.setItem(itm.row(), 0, QStandardItem())
model.item(itm.row(), 0).setData(itm.data(0) * 86400., 0)
if not model.item(itm.row(), 1):
model.setItem(itm.row(), 1, QStandardItem())
model.item(itm.row(), 1).setData(itm.data(0) * 1440., 0)
if not model.item(itm.row(), 2):
model.setItem(itm.row(), 2, QStandardItem())
model.item(itm.row(), 2).setData(itm.data(0) * 24., 0)
if not model.item(itm.row(), 4):
date_itm = QStandardItem()
date_itm.setEditable(False)
model.setItem(itm.row(), 4, date_itm)
date = self.date_ref + timedelta(days=itm.data(0))
model.item(itm.row(),
4).setData(date.strftime('%d-%m-%Y %H:%M:%S'),
0)
model.blockSignals(False)
if not self.filling_tab:
model.sort(0)
idx = itm.index()
self.ui.tab_sets.scrollTo(idx, 0)
self.update_courbe("all")
elif itm.column() > 4:
if not self.filling_tab:
idx = itm.index()
self.update_courbe([idx.column() - 5])
def addRow(self):
model = self.tblView.model()
items = [QStandardItem('0') for i in range(model.columnCount())]
model.appendRow(items)
def load(self, label: str, meta_type: str, meta: dict, show: bool = False):
# re-initialize our model
self.model.clear()
self.meta = meta
root_item = self.model.invisibleRootItem()
self.model.setColumnCount(2)
self.model.setHorizontalHeaderLabels(['Meta Name', 'Meta Value'])
if meta_type == MetaType.PROJECT:
self.treeView.setHeaderHidden(False)
self.setWindowTitle('Project MetaData: {}'.format(label))
self.treeView.setEnabled(True)
if meta is not None and len(meta.keys()) > 0:
if 'project' in meta and len(meta['project'].keys()) > 0:
proj_meta = QStandardItem('Project Meta')
proj_meta_font = proj_meta.font()
proj_meta_font.setBold(True)
proj_meta.setFont(proj_meta_font)
for k, v in meta['project'].items():
proj_meta.appendRow(
[QStandardItem(k),
QStandardItem(v)])
root_item.appendRow(proj_meta)
if 'warehouse' in meta and len(meta['warehouse'].keys()) > 0:
wh_meta = QStandardItem('Warehouse Meta')
wh_meta_font = proj_meta.font()
wh_meta_font.setBold(True)
wh_meta.setFont(wh_meta_font)
for k, v in meta['warehouse'].items():
wh_meta.appendRow([QStandardItem(k), QStandardItem(v)])
root_item.appendRow(wh_meta)
elif meta_type == MetaType.FOLDER:
self.setWindowTitle('Folder: {}'.format(label))
self.treeView.setHeaderHidden(True)
self.treeView.setEnabled(False)
self.model.setColumnCount(1)
self.model.setHorizontalHeaderLabels(['Meta Name'])
no_item = QStandardItem('Folders have no MetaData')
no_item.setTextAlignment(Qt.AlignCenter)
no_f = no_item.font()
no_f.setItalic(True)
no_item.setFont(no_f)
root_item.appendRow(no_item)
elif meta_type == MetaType.LAYER:
self.setWindowTitle('Layer MetaData: {}'.format(label))
self.treeView.setEnabled(True)
self.treeView.setHeaderHidden(False)
if meta is not None and len(meta.keys()) > 0:
for k, v in meta.items():
root_item.appendRow([QStandardItem(k), QStandardItem(v)])
else:
self.treeView.setHeaderHidden(True)
self.treeView.setEnabled(False)
self.model.setColumnCount(1)
self.model.setHorizontalHeaderLabels(['Meta Name'])
no_item = QStandardItem('This layer has no MetaData')
no_item.setTextAlignment(Qt.AlignCenter)
no_f = no_item.font()
no_f.setItalic(True)
no_item.setFont(no_f)
root_item.appendRow(no_item)
elif meta_type == MetaType.NONE:
self.treeView.setHeaderHidden(True)
self.treeView.setEnabled(False)
self.model.setColumnCount(1)
self.setWindowTitle('Riverscapes MetaData: {}'.format(label))
no_item = QStandardItem('This item cannot have metadata')
no_item.setTextAlignment(Qt.AlignCenter)
no_f = no_item.font()
no_f.setItalic(True)
no_item.setFont(no_f)
root_item.appendRow(no_item)
return
# self.tree.header().setDefaultSectionSize(180)
# self._populateTree(self.tree, )
# Finally expand all levels
self.treeView.expandAll()
if show is True:
self.show()
def fillTreeUsingProviders(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels(
[self.tr('Setting'), self.tr('Value')])
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
"""
Filter 'General', 'Models' and 'Scripts' items
"""
priorityKeys = [
self.tr('General'),
self.tr('Models'),
self.tr('Scripts')
]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
# add menu item only if it has any search matches
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
"""
Filter 'Providers' items
"""
providersItem = QStandardItem(self.tr('Providers'))
icon = QgsApplication.getThemeIcon("/processingAlgorithm.svg")
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in list(settings.keys()):
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
"""
Filter 'Menus' items
"""
self.menusItem = QStandardItem(self.tr('Menus'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
self.menusItem.setIcon(icon)
self.menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [self.menusItem, emptyItem])
button = QPushButton(self.tr('Reset to defaults'))
button.clicked.connect(self.resetMenusToDefaults)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(button)
layout.addStretch()
widget = QWidget()
widget.setLayout(layout)
self.tree.setIndexWidget(emptyItem.index(), widget)
for provider in QgsApplication.processingRegistry().providers():
providerDescription = provider.name()
groupItem = QStandardItem(providerDescription)
icon = provider.icon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algorithms():
algItem = QStandardItem(alg.displayName())
algItem.setIcon(icon)
algItem.setEditable(False)
try:
settingMenu = ProcessingConfig.settings["MENU_" + alg.id()]
settingButton = ProcessingConfig.settings["BUTTON_" +
alg.id()]
settingIcon = ProcessingConfig.settings["ICON_" + alg.id()]
except:
continue
self.items[settingMenu] = SettingItem(settingMenu)
self.items[settingButton] = SettingItem(settingButton)
self.items[settingIcon] = SettingItem(settingIcon)
menuLabelItem = QStandardItem("Menu path")
menuLabelItem.setEditable(False)
buttonLabelItem = QStandardItem("Add button in toolbar")
buttonLabelItem.setEditable(False)
iconLabelItem = QStandardItem("Icon")
iconLabelItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
algItem.insertRow(0, [menuLabelItem, self.items[settingMenu]])
algItem.insertRow(0,
[buttonLabelItem, self.items[settingButton]])
algItem.insertRow(0, [iconLabelItem, self.items[settingIcon]])
groupItem.insertRow(0, [algItem, emptyItem])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
self.menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def _add_token(self, token_info: dict):
self.token_model.appendRow(
[QStandardItem(token_info[k]) for k in ["name", "token"]])
