def suggest(self): self.dlg.ui.lookupinfo.setHtml('') search_text = self.dlg.geocoderSearch.text() if len(search_text) <= 1: # QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ( \ # "meer input aub: {}".format(search_text) # ), QMessageBox.Ok, QMessageBox.Ok) return # QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ( \ # "zoeken: {}".format(search_text) # ), QMessageBox.Ok, QMessageBox.Ok) results = self.pdokgeocoder.suggest(search_text, self.createfq()) if len(results) == 0: # ignore, as we are suggesting, maybe more characters will reveal something... return for result in results: #print address adrestekst = QStandardItem("%s" % (result["adrestekst"])) adrestekst.setData(result, Qt.UserRole) type = QStandardItem("%s" % (result["type"])) id = QStandardItem("%s" % (result["id"])) score = QStandardItem("%s" % (result["score"])) adrestekst.setData(result, Qt.UserRole) self.geocoderSourceModel.appendRow([adrestekst, type]) self.geocoderSourceModel.setHeaderData(0, Qt.Horizontal, "Resultaat") self.geocoderSourceModel.setHeaderData(1, Qt.Horizontal, "Type") self.geocoderSourceModel.horizontalHeaderItem(0).setTextAlignment(Qt.AlignLeft) self.dlg.geocoderResultView.resizeColumnsToContents() self.dlg.geocoderResultView.horizontalHeader().setStretchLastSection(True)
def rowFromData(self, data): row = [] for c in data: item = QStandardItem(str(c)) item.setFlags((item.flags() | Qt.ItemIsEditable) if self.editable else (item.flags() & ~Qt.ItemIsEditable)) row.append(item) return row
def populateList(self): model = QStandardItemModel() for i, option in enumerate(self.options): item = QStandardItem(option) item.setCheckState(Qt.Checked if i in self.selectedoptions else Qt.Unchecked) item.setCheckable(True) model.appendRow(item) self.lstLayers.setModel(model)
def _reloadHistory(self): self.model.clear() for i in self.parent.history: item = QStandardItem(i) if sys.platform.startswith('win'): item.setSizeHint(QSize(18, 18)) self.model.appendRow(item) self.listView.setModel(self.model) self.listView.scrollToBottom()
def __init__(self, setting): QStandardItem.__init__(self) self.setting = setting self.setData(setting, Qt.UserRole) if isinstance(setting.value, bool): self.setCheckable(True) self.setEditable(False) if setting.value: self.setCheckState(Qt.Checked) else: self.setCheckState(Qt.Unchecked) else: self.setData(setting.value, Qt.EditRole)
def setOptions(self, options): model = self.lstItems.model() for i in options: item = QStandardItem(i) item.setCheckable(True) item.setDropEnabled(False) item.setData(Qt.Unchecked) model.appendRow(item)
def addItem(self): model = self.lstItems.model() item = QStandardItem('new item') item.setCheckable(True) item.setDropEnabled(False) item.setData(Qt.Unchecked) model.appendRow(item)
def populateList(self): model = QStandardItemModel() for value, text in self.options: item = QStandardItem(text) item.setData(value, Qt.UserRole) item.setCheckState(Qt.Checked if value in self.selectedoptions else Qt.Unchecked) item.setCheckable(True) model.appendRow(item) self.lstLayers.setModel(model)
def addFiles(self): filter = self.getFileFilter(self.datatype) settings = QgsSettings() path = str(settings.value('/Processing/LastInputPath')) ret, selected_filter = QFileDialog.getOpenFileNames(self, self.tr('Select File(s)'), path, filter) if ret: files = list(ret) settings.setValue('/Processing/LastInputPath', os.path.dirname(str(files[0]))) for filename in files: item = QStandardItem(filename) item.setData(filename, Qt.UserRole) item.setCheckState(Qt.Checked) item.setCheckable(True) item.setDropEnabled(False) self.model.appendRow(item)
def addDirectory(self): settings = QgsSettings() path = str(settings.value('/Processing/LastInputPath')) ret = QFileDialog.getExistingDirectory(self, self.tr('Select File(s)'), path) if ret: exts = [] if self.datatype == QgsProcessing.TypeVector: exts = QgsVectorFileWriter.supportedFormatExtensions() elif self.datatype == QgsProcessing.TypeRaster: for t in QgsProviderRegistry.instance().fileRasterFilters().split(';;')[1:]: for e in t[t.index('(') + 1:-1].split(' '): if e != "*.*" and e.startswith("*."): exts.append(e[2:]) files = [] for pp in Path(ret).rglob("*"): if not pp.is_file(): continue if exts and pp.suffix[1:] not in exts: continue p = pp.as_posix() files.append(p) settings.setValue('/Processing/LastInputPath', ret) for filename in files: item = QStandardItem(filename) item.setData(filename, Qt.UserRole) item.setCheckState(Qt.Checked) item.setCheckable(True) item.setDropEnabled(False) self.model.appendRow(item)
def addSourceRow(self, serviceLayer): # you can attache different "data's" to to an QStandarditem # default one is the visible one: itemType = QStandardItem("%s" % (serviceLayer["type"].upper()) ) # userrole is a free form one: # only attach the data to the first item # service layer = a dict/object with all props of the layer itemType.setData( serviceLayer, Qt.UserRole ) itemType.setToolTip("%s - %s" % (serviceLayer["type"].upper() ,serviceLayer["title"] )) # only wms services have styles (sometimes) layername = serviceLayer["title"] if 'style' in serviceLayer: itemLayername = QStandardItem("%s [%s]" % (serviceLayer["title"], serviceLayer["style"]) ) layername = "%s [%s]" % (serviceLayer["title"], serviceLayer["style"]) else: itemLayername = QStandardItem("%s" % (serviceLayer["title"])) itemLayername.setToolTip("%s - %s" % (serviceLayer["type"].upper() ,serviceLayer["servicetitle"] )) # itemFilter is the item used to search filter in. That is why layername is a combi of layername + filter here itemFilter = QStandardItem("%s %s %s %s" % (serviceLayer["type"], layername, serviceLayer["servicetitle"], serviceLayer["abstract"]) ) itemServicetitle = QStandardItem("%s" % (serviceLayer["servicetitle"])) itemServicetitle.setToolTip("%s - %s" % (serviceLayer["type"].upper() ,serviceLayer["title"] )) self.sourceModel.appendRow( [ itemLayername, itemType, itemServicetitle, itemFilter ] )
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 __init__(self, parent=None): """Constructor.""" super(BDTopoImporterDialog, self).__init__(parent) # Set up the user interface from Designer through FORM_CLASS. # After self.setupUi() you can access any designer object by doing # self.<objectname>, and you can use autoconnect slots - see # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html # #widgets-and-dialogs-with-auto-connect self.setupUi(self) # load db connections self.dbselect = QgsProviderConnectionComboBox('postgres', self) self.horizontalLayout_4.addWidget(self.dbselect) self.schemaselect = QgsDatabaseSchemaComboBox('postgres', self.dbselect.currentConnection(), self) self.dbselect.connectionChanged.connect(self.schemaselect.setConnectionName) self.horizontalLayout_5.addWidget(self.schemaselect) # load layer list data_path = os.path.join(os.path.dirname(__file__), 'data.json') with open(data_path, 'r') as f: json_data = json.load(f) layer_data = json_data['themes'] model = QStandardItemModel() root = model.invisibleRootItem() for theme in layer_data: item = QStandardItem(theme['title']) item.setData(theme['pathname']) root.appendRow(item) for layer in theme['layers']: layeritem = QStandardItem(layer['name']) layeritem.setCheckable(True) # layeritem.setCheckState(Qt.Checked) layeritem.setData(layer['filename']) item.appendRow(layeritem) self.treeView_layers.setModel(model) self.treeView_layers.expandAll() # extract parameter dialog self.settings_dlg = ExtractorSettingsDialog(self) # file access buttons self.pushButton_folder_select.clicked.connect(self.onFolderSelectClicked) self.pushButton_file_select.clicked.connect(self.onFileSelectClicked) # check/uncheck all buttons self.pushButton_checkall.clicked.connect(self.onCheckAllClicked) self.pushButton_uncheckall.clicked.connect(self.onUncheckAllClicked) # settings button self.toolButton_extract_parameters.clicked.connect(self.onExtractParametersClicked)
def setColumnCombos(self, cols, quotedCols): # get sensible default columns. do this before sorting in case there's hints in the column order (eg, 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 populateList(self): self.model = QStandardItemModel() for value, text in self.options: item = QStandardItem(text) item.setData(value, Qt.UserRole) item.setCheckState(Qt.Checked if value in self.selectedoptions else Qt.Unchecked) item.setCheckable(True) item.setDropEnabled(False) self.model.appendRow(item) # add extra options (e.g. manually added layers) for t in [o for o in self.selectedoptions if not isinstance(o, int)]: if isinstance(t, QgsProcessingModelChildParameterSource): item = QStandardItem(t.staticValue()) else: item = QStandardItem(t) item.setData(item.text(), Qt.UserRole) item.setCheckState(Qt.Checked) item.setCheckable(True) item.setDropEnabled(False) self.model.appendRow(item) self.lstLayers.setModel(self.model)
def addRow(self): items = [QStandardItem('0') for i in range(self.tblView.model().columnCount())] self.tblView.model().appendRow(items)
def append_row(self, item: QStandardItem): """Add an item to the combobox.""" item.setEnabled(True) item.setCheckable(True) item.setSelectable(False) self.model.appendRow(item)
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 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 finished(self, result): self.geoClassList.clear() if self.examplequery != None: self.sparql.setPlainText(self.examplequery) self.sparql.columnvars = {} if len(self.resultlist) > 0: first = True for concept in self.resultlist: #self.layerconcepts.addItem(concept) item = QStandardItem() item.setData(concept, 1) item.setText(concept[concept.rfind('/') + 1:]) self.geoClassList.appendRow(item) if self.triplestoreconf["name"] == "Wikidata": self.completerClassList["completerClassList"][ concept[concept.rfind('/') + 1:]] = "wd:" + concept.split("(")[1].replace( " ", "_").replace(")", "") else: self.completerClassList["completerClassList"][ concept[concept.rfind('/') + 1:]] = "<" + concept + ">" self.sparql.updateNewClassList() self.geoClassListGui.selectionModel().setCurrentIndex( self.geoClassList.index(0, 0), QItemSelectionModel.SelectCurrent) self.dlg.viewselectaction() elif len(self.viewlist) > 0: for concept in self.viewlist: #self.layerconcepts.addItem(concept) item = QStandardItem() item.setData(concept, 1) item.setText(concept[concept.rfind('/') + 1:]) self.geoClassList.appendRow(item) if self.triplestoreconf["name"] == "Wikidata": self.completerClassList["completerClassList"][ concept[concept.rfind('/') + 1:]] = "wd:" + concept.split("(")[1].replace( " ", "_").replace(")", "") else: self.completerClassList["completerClassList"][ concept[concept.rfind('/') + 1:]] = "<" + concept + ">" #item=QListWidgetItem() #item.setData(1,concept) #item.setText(concept[concept.rfind('/')+1:]) #self.geoClassList.addItem(item) self.sparql.updateNewClassList() self.geoClassListGui.selectionModel().setCurrentIndex( self.geoClassList.index(0, 0), QItemSelectionModel.SelectCurrent) self.dlg.viewselectaction() if self.amountoflabels != -1: self.layercount.setText("[" + str(self.amountoflabels) + "]")
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 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 __init__(self, parent=None, selectMode=True, filter_data_source='', access_templates=[]): 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 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 populate_trv(self, trv_widget, result, expand=False): model = QStandardItemModel() trv_widget.setModel(model) trv_widget.setUniformRowHeights(False) main_parent = QStandardItem('{}'.format('Giswater')) font = main_parent.font() font.setPointSize(8) main_parent.setFont(font) self.icon_folder = self.plugin_dir + os.sep + 'icons' path_icon_blue = self.icon_folder + os.sep + '36.png' path_icon_red = self.icon_folder + os.sep + '100.png' if os.path.exists(path_icon_blue): icon = QIcon(path_icon_blue) main_parent.setIcon(icon) for group, functions in result['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 = self.controller.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']) enable_run = QStandardItem("True") if function['input_params'] is not None: if 'btnRunEnabled' in function['input_params']: bool_dict = {True: "True", False: "False"} enable_run = QStandardItem(bool_dict[ function['input_params']['btnRunEnabled']]) parent1.appendRow([label, func_name, enable_run]) main_parent.appendRow(parent1) model.appendRow(main_parent) index = model.indexFromItem(main_parent) trv_widget.expand(index) if expand: trv_widget.expandAll()
def addRow(self): model = self.tblView.model() items = [QStandardItem('0') for i in range(model.columnCount())] model.appendRow(items)
def reload_collections_model(self): """Reload the collections model with the current collections.""" self.collections_model.clear() for id in config.COLLECTIONS: collection_name = config.COLLECTIONS[id]['name'] collection_author = config.COLLECTIONS[id]['author'] collection_tags = config.COLLECTIONS[id]['tags'] collection_description = config.COLLECTIONS[id]['description'] collection_status = config.COLLECTIONS[id]['status'] item = QStandardItem(collection_name) item.setEditable(False) item.setData(id, COLLECTION_ID_ROLE) item.setData(collection_name, COLLECTION_NAME_ROLE) item.setData(collection_description, COLLECTION_DESCRIPTION_ROLE) item.setData(collection_author, COLLECTION_AUTHOR_ROLE) item.setData(collection_tags, COLLECTION_TAGS_ROLE) item.setData(collection_status, COLLECTION_STATUS_ROLE) self.collections_model.appendRow(item) self.collections_model.sort(0, Qt.AscendingOrder)
class ConfigDialog(BASE, WIDGET): def __init__(self, showSearch=True): super(ConfigDialog, self).__init__(None) self.setupUi(self) self.groupIcon = QgsApplication.getThemeIcon('mIconFolder.svg') self.model = QStandardItemModel() self.tree.setModel(self.model) self.delegate = SettingDelegate() self.tree.setItemDelegateForColumn(1, self.delegate) if showSearch: if hasattr(self.searchBox, 'setPlaceholderText'): self.searchBox.setPlaceholderText(QApplication.translate('ConfigDialog', 'Search…')) self.searchBox.textChanged.connect(self.textChanged) else: self.searchBox.hide() self.fillTree() self.saveMenus = False self.tree.expanded.connect(self.itemExpanded) self.auto_adjust_columns = True def textChanged(self, text=None): if text is not None: text = str(text.lower()) else: text = str(self.searchBox.text().lower()) found = self._filterItem(self.model.invisibleRootItem(), text) self.auto_adjust_columns = False if text: self.tree.expandAll() else: self.tree.collapseAll() self.adjustColumns() self.auto_adjust_columns = True if text: return found else: self.tree.collapseAll() return False def _filterItem(self, item, text, forceShow=False): if item.hasChildren(): show = forceShow or isinstance(item, QStandardItem) and bool(text) and (text in item.text().lower()) for i in range(item.rowCount()): child = item.child(i) show = self._filterItem(child, text, forceShow) or show self.tree.setRowHidden(item.row(), item.index().parent(), not show) return show elif isinstance(item, QStandardItem): show = forceShow or bool(text) and (text in item.text().lower()) self.tree.setRowHidden(item.row(), item.index().parent(), not show) return show def fillTree(self): self.fillTreeUsingProviders() 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]) if not group in settings: continue # 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 resetMenusToDefaults(self): for provider in QgsApplication.processingRegistry().providers(): for alg in provider.algorithms(): d = defaultMenuEntries.get(alg.id(), "") setting = ProcessingConfig.settings["MENU_" + alg.id()] item = self.items[setting] item.setData(d, Qt.EditRole) self.saveMenus = True def accept(self): qsettings = QgsSettings() for setting in list(self.items.keys()): if setting.group != menusSettingsGroup or self.saveMenus: if isinstance(setting.value, bool): setting.setValue(self.items[setting].checkState() == Qt.Checked) else: try: setting.setValue(str(self.items[setting].text())) except ValueError as e: QMessageBox.warning(self, self.tr('Wrong value'), self.tr('Wrong value for parameter "{0}":\n\n{1}').format(setting.description, str(e))) return setting.save(qsettings) with OverrideCursor(Qt.WaitCursor): for p in QgsApplication.processingRegistry().providers(): p.refreshAlgorithms() settingsWatcher.settingsChanged.emit() def itemExpanded(self, idx): if idx == self.menusItem.index(): self.saveMenus = True if self.auto_adjust_columns: self.adjustColumns() def adjustColumns(self): self.tree.resizeColumnToContents(0) self.tree.resizeColumnToContents(1)
class ConfigDialog(BASE, WIDGET): def __init__(self, showSearch=True): super(ConfigDialog, self).__init__(None) self.setupUi(self) self.groupIcon = QIcon() self.groupIcon.addPixmap(self.style().standardPixmap( QStyle.SP_DirClosedIcon), QIcon.Normal, QIcon.Off) self.groupIcon.addPixmap(self.style().standardPixmap( QStyle.SP_DirOpenIcon), QIcon.Normal, QIcon.On) self.model = QStandardItemModel() self.tree.setModel(self.model) self.delegate = SettingDelegate() self.tree.setItemDelegateForColumn(1, self.delegate) if showSearch: if hasattr(self.searchBox, 'setPlaceholderText'): self.searchBox.setPlaceholderText(QApplication.translate('ConfigDialog', 'Search…')) self.searchBox.textChanged.connect(self.textChanged) else: self.searchBox.hide() self.fillTree() self.saveMenus = False self.tree.expanded.connect(self.itemExpanded) self.auto_adjust_columns = True def textChanged(self, text=None): if text is not None: text = str(text.lower()) else: text = str(self.searchBox.text().lower()) found = self._filterItem(self.model.invisibleRootItem(), text) self.auto_adjust_columns = False if text: self.tree.expandAll() else: self.tree.collapseAll() self.adjustColumns() self.auto_adjust_columns = True if text: return found else: self.tree.collapseAll() return False def _filterItem(self, item, text, forceShow=False): if item.hasChildren(): show = forceShow or isinstance(item, QStandardItem) and bool(text) and (text in item.text().lower()) for i in range(item.rowCount()): child = item.child(i) show = self._filterItem(child, text, forceShow) or show self.tree.setRowHidden(item.row(), item.index().parent(), not show) return show elif isinstance(item, QStandardItem): show = forceShow or bool(text) and (text in item.text().lower()) self.tree.setRowHidden(item.row(), item.index().parent(), not show) return show def fillTree(self): self.fillTreeUsingProviders() 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]) if not group in settings: continue # 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 resetMenusToDefaults(self): for provider in QgsApplication.processingRegistry().providers(): for alg in provider.algorithms(): d = defaultMenuEntries.get(alg.id(), "") setting = ProcessingConfig.settings["MENU_" + alg.id()] item = self.items[setting] item.setData(d, Qt.EditRole) self.saveMenus = True def accept(self): qsettings = QgsSettings() for setting in list(self.items.keys()): if setting.group != menusSettingsGroup or self.saveMenus: if isinstance(setting.value, bool): setting.setValue(self.items[setting].checkState() == Qt.Checked) else: try: setting.setValue(str(self.items[setting].text())) except ValueError as e: QMessageBox.warning(self, self.tr('Wrong value'), self.tr('Wrong value for parameter "{0}":\n\n{1}').format(setting.description, str(e))) return setting.save(qsettings) with OverrideCursor(Qt.WaitCursor): for p in QgsApplication.processingRegistry().providers(): p.refreshAlgorithms() settingsWatcher.settingsChanged.emit() def itemExpanded(self, idx): if idx == self.menusItem.index(): self.saveMenus = True if self.auto_adjust_columns: self.adjustColumns() def adjustColumns(self): self.tree.resizeColumnToContents(0) self.tree.resizeColumnToContents(1)
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]) if group not in settings: continue # 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 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 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 _create_item(self, text): item = QStandardItem(text) return item
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.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 change_attribute(self, state): model = QStandardItemModel() for attr in self.data.getAttributes(self.currentPositionableClass): item = QStandardItem(attr) if attr in self.alwaysSelectedAttribute: item.setCheckable(False) item.setCheckState(Qt.Checked) self.data.setAttributeValue(self.currentPositionableClass, attr, True) else: item.setCheckable(True) self.data.setAttributeValue(self.currentPositionableClass, attr, state) if state: item.setCheckState(Qt.Checked) else: item.setCheckState(Qt.Unchecked) model.appendRow(item) model.itemChanged.connect(self.on_attribute_list_changed) self.dlg.attribute.setModel(model)
def add_layer_to_map(item: QStandardItem): """ Add a layer to the map :param layer: :return: """ # No multiselect so there is only ever one item pt_data: ProjectTreeData = item.data(Qt.UserRole) project = pt_data.project map_layer: QRaveMapLayer = pt_data.data settings = Settings() # Loop over all the parent group layers for this raster # ensuring they are in the tree in correct, nested order ancestry = [] if map_layer.exists is True: parent = item.parent() while parent is not None and len(ancestry) < 50: ancestry.append((parent.text(), parent.row())) parent = parent.parent() else: # Layer does not exist. do not try to put it on the map return ancestry.reverse() parentGroup = None for agroup in ancestry: parentGroup = QRaveMapLayer._addgrouptomap(agroup[0], agroup[1], parentGroup) assert parentGroup, "All rasters should be nested and so parentGroup should be instantiated by now" # Loop over all the parent group layers for this raster # ensuring they are in the tree in correct, nested order # Only add the layer if it's not already in the registry exists = False existing_layers = QgsProject.instance().mapLayersByName( map_layer.label) layers_ancestry = [ QRaveMapLayer.get_layer_ancestry(lyr) for lyr in existing_layers ] # Now we compare the ancestry group labels to the business logic ancestry branch names # to see if this layer is already in the map for lyr in layers_ancestry: if len(lyr) == len(ancestry) \ and all(iter([ancestry[x][0] == lyr[x] for x in range(len(ancestry))])): exists = True break if not exists: layer_uri = map_layer.layer_uri rOutput = None # This might be a basemap if map_layer.layer_type == QRaveMapLayer.LayerTypes.WEBTILE: rOutput = QgsRasterLayer(layer_uri, map_layer.label, 'wms') elif map_layer.layer_type in [ QRaveMapLayer.LayerTypes.LINE, QRaveMapLayer.LayerTypes.POLYGON, QRaveMapLayer.LayerTypes.POINT ]: if map_layer.layer_name is not None: layer_uri += "|layername={}".format(map_layer.layer_name) rOutput = QgsVectorLayer(layer_uri, map_layer.label, "ogr") elif map_layer.layer_type == QRaveMapLayer.LayerTypes.RASTER: # Raster rOutput = QgsRasterLayer(layer_uri, map_layer.label) if rOutput is not None: ########################################## # Symbology ########################################## symbology = map_layer.bl_attr[ 'symbology'] if map_layer.bl_attr is not None and 'symbology' in map_layer.bl_attr else None # If the business logic has symbology defined if symbology is not None: qml_fname = '{}.qml'.format(symbology) os.path.abspath( os.path.join(project.project_dir, qml_fname)) # Here are the search paths for QML files in order of precedence hierarchy = [ os.path.abspath( os.path.join(project.project_dir, qml_fname)), # This is the default one os.path.abspath( os.path.join(SYMBOLOGY_DIR, project.project_type, qml_fname)), os.path.abspath( os.path.join(SYMBOLOGY_DIR, 'Shared', qml_fname)) ] # Find the first match try: chosen_qml = next( iter([ candidate for candidate in hierarchy if os.path.isfile(candidate) ])) # Report to the terminal if we couldn't find a qml file to use if chosen_qml is None: settings.msg_bar( "Missing Symbology", "Could not find a valid .qml symbology file for layer {}. Search paths: [{}]" .format(layer_uri, ', '.join(hierarchy)), level=Qgis.Warning) # Apply the QML file else: rOutput.loadNamedStyle(chosen_qml) except StopIteration: settings.log( 'Could not find valid symbology for layer at any of the following search paths: [ {} ]' .format(', '.join(hierarchy)), Qgis.Warning) ############################################################ # Transparency. A few notes: # - QML transparency will prevail for rasters before 3.18 # - We set this here so that QML layer transparency will be # overruled ############################################################ transparency = 0 try: if 'transparency' in map_layer.bl_attr: transparency = int(map_layer.bl_attr['transparency']) except Exception as e: settings.log( 'Error deriving transparency from layer: {}'.format(e)) try: if transparency > 0: if rOutput.__class__ is QgsVectorLayer: rOutput.setLayerTransparency(transparency) # rOutput.triggerRepaint() elif rOutput.__class__ is QgsRasterLayer: renderer = rOutput.renderer() renderer.setOpacity((100 - transparency) / 100.0) # rOutput.triggerRepaint() except Exception as e: settings.log( 'Error deriving transparency from layer: {}'.format(e)) QgsProject.instance().addMapLayer(rOutput, False) parentGroup.insertLayer(item.row(), rOutput) # if the layer already exists trigger a refresh else: QgsProject.instance().mapLayersByName( map_layer.label)[0].triggerRepaint()
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 _add_token(self, token_info: dict): self.token_model.appendRow( [QStandardItem(token_info[k]) for k in ["name", "token"]])
def addColumn(self): model = self.tblView.model() items = [QStandardItem('0') for i in range(model.rowCount())] model.appendColumn(items)
def populate_columns_list(self): """ Populate the columns view. :return: :rtype: """ options = {} options['type'] = 'combobox' delegate = GenericDelegate(self.separators, options, self.column_code_view) # Set delegate to add widget self.column_code_view.setItemDelegate(delegate) self.column_code_view.setItemDelegateForColumn(1, delegate) model = QStandardItemModel(2, 2) i = 0 for row, col in enumerate(self._columns): column_item = QStandardItem(self._entity.columns[col].header()) column_item.setCheckable(True) model.setItem(i, 0, column_item) column_item.setData(col) self.column_code_view.setModel(model) i = i + 1 for col in self._entity.columns.values(): if col.name == 'id': continue if col.name not in self._columns: # Correct row by reducing by one due to removal of id column_item = QStandardItem(col.header()) column_item.setCheckable(True) model.setItem(i, 0, column_item) column_item.setData(col.name) self.column_code_view.setModel(model) i = i + 1
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 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]) if not group in settings: continue # 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 init_ui(self): model = QStandardItemModel() model.insertColumns(0, 4) model.setHeaderData(0, 1, 'ID', 0) model.setHeaderData(1, 1, 'Sigle', 0) model.setHeaderData(2, 1, 'Parameter', 0) model.setHeaderData(3, 1, 'Value', 0) sql = "SELECT id, sigle, text, value FROM {0}.tracer_physic WHERE type = '{1}' ORDER BY id".format( self.mdb.SCHEMA, self.cur_wq_mod) rows = self.mdb.run_query(sql, fetch=True) model.insertRows(0, len(rows)) for r, row in enumerate(rows): for c, val in enumerate(row): itm = QStandardItem() itm.setData(val, 0) if c == 3: itm.setData(data_to_float(val), 0) itm.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable) itm.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) else: itm.setData(val, 0) itm.setFlags(Qt.ItemIsEnabled) model.setItem(r, c, itm) self.ui.tab_param.setModel(model) self.ui.tab_param.hide() self.ui.tab_param.resizeColumnsToContents() self.ui.tab_param.resizeRowsToContents() self.ui.tab_param.setColumnHidden(0, True) self.ui.ui.tab_param.show()
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 _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"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 = [keyfield, valuefield] 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)
class ConfigDialog(BASE, WIDGET): def __init__(self, toolbox): super(ConfigDialog, self).__init__(None) self.setupUi(self) self.toolbox = toolbox self.groupIcon = QIcon() self.groupIcon.addPixmap(self.style().standardPixmap(QStyle.SP_DirClosedIcon), QIcon.Normal, QIcon.Off) self.groupIcon.addPixmap(self.style().standardPixmap(QStyle.SP_DirOpenIcon), QIcon.Normal, QIcon.On) if hasattr(self.searchBox, "setPlaceholderText"): self.searchBox.setPlaceholderText(self.tr("Search...")) self.model = QStandardItemModel() self.tree.setModel(self.model) self.delegate = SettingDelegate() self.tree.setItemDelegateForColumn(1, self.delegate) self.searchBox.textChanged.connect(self.textChanged) self.fillTree() self.saveMenus = False self.tree.expanded.connect(self.itemExpanded) def textChanged(self): text = str(self.searchBox.text().lower()) self._filterItem(self.model.invisibleRootItem(), text) if text: self.tree.expandAll() else: self.tree.collapseAll() def _filterItem(self, item, text): if item.hasChildren(): show = False for i in range(item.rowCount()): child = item.child(i) showChild = self._filterItem(child, text) show = showChild or show self.tree.setRowHidden(item.row(), item.index().parent(), not show) return show elif isinstance(item, QStandardItem): hide = bool(text) and (text not in item.text().lower()) self.tree.setRowHidden(item.row(), item.index().parent(), hide) return not hide def fillTree(self): self.fillTreeUsingProviders() 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 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) 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) self.menusItem.appendRow([groupItem, emptyItem]) self.tree.sortByColumn(0, Qt.AscendingOrder) self.adjustColumns() def resetMenusToDefaults(self): providers = Processing.providers for provider in providers: for alg in provider.algs: d = defaultMenuEntries.get(alg.commandLineName(), "") setting = ProcessingConfig.settings["MENU_" + alg.commandLineName()] item = self.items[setting] item.setData(d, Qt.EditRole) self.saveMenus = True def accept(self): QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) for setting in list(self.items.keys()): if setting.group != menusSettingsGroup or self.saveMenus: if isinstance(setting.value, bool): setting.setValue(self.items[setting].checkState() == Qt.Checked) else: try: setting.setValue(str(self.items[setting].text())) except ValueError as e: QMessageBox.warning( self, self.tr("Wrong value"), self.tr('Wrong value for parameter "%s":\n\n%s' % (setting.description, str(e))), ) return setting.save() Processing.updateAlgsList() settingsWatcher.settingsChanged.emit() QApplication.restoreOverrideCursor() QDialog.accept(self) def itemExpanded(self, idx): if idx == self.menusItem.index(): self.saveMenus = True self.adjustColumns() def adjustColumns(self): self.tree.resizeColumnToContents(0) self.tree.resizeColumnToContents(1)