def tree_widget_item(self): item = QTreeWidgetItem([self.name]) item.setData(0, Qt.UserRole, deepcopy(self)) return item
def fillTree(self): layersItem = QTreeWidgetItem() layersItem.setText(0, self.tr('Values from data layers extents')) self.treeValues.addTopLevelItem(layersItem) layers = dataobjects.getAllLayers() for layer in layers: layerItem = QTreeWidgetItem() layerItem.setText(0, unicode(layer.name())) layerItem.addChild(TreeValueItem(self.tr('Min X'), layer.extent().xMinimum())) layerItem.addChild(TreeValueItem(self.tr('Max X'), layer.extent().xMaximum())) layerItem.addChild(TreeValueItem(self.tr('Min Y'), layer.extent().yMinimum())) layerItem.addChild(TreeValueItem(self.tr('Max Y'), layer.extent().yMaximum())) if isinstance(layer, QgsRasterLayer): cellsize = (layer.extent().xMaximum() - layer.extent().xMinimum()) / layer.width() layerItem.addChild(TreeValueItem(self.tr('Cellsize'), cellsize)) layersItem.addChild(layerItem) layersItem = QTreeWidgetItem() layersItem.setText(0, self.tr('Values from raster layers statistics')) self.treeValues.addTopLevelItem(layersItem) layers = dataobjects.getRasterLayers() for layer in layers: for i in range(layer.bandCount()): stats = layer.dataProvider().bandStatistics(i + 1) layerItem = QTreeWidgetItem() layerItem.setText(0, unicode(layer.name())) layerItem.addChild(TreeValueItem(self.tr('Mean'), stats.mean)) layerItem.addChild(TreeValueItem(self.tr('Std. deviation'), stats.stdDev)) layerItem.addChild(TreeValueItem(self.tr('Max value'), stats.maximumValue)) layerItem.addChild(TreeValueItem(self.tr('Min value'), stats.minimumValue)) layersItem.addChild(layerItem) canvasItem = QTreeWidgetItem() canvasItem.setText(0, self.tr('Values from QGIS map canvas')) self.treeValues.addTopLevelItem(canvasItem) extent = iface.mapCanvas().extent() extentItem = QTreeWidgetItem() extentItem.setText(0, self.tr('Current extent')) extentItem.addChild(TreeValueItem(self.tr('Min X'), extent.xMinimum())) extentItem.addChild(TreeValueItem(self.tr('Max X'), extent.xMaximum())) extentItem.addChild(TreeValueItem(self.tr('Min Y'), extent.yMinimum())) extentItem.addChild(TreeValueItem(self.tr('Max Y'), extent.yMaximum())) canvasItem.addChild(extentItem) extent = iface.mapCanvas().fullExtent() extentItem = QTreeWidgetItem() extentItem.setText(0, self.tr('Full extent of all layers in map canvas')) extentItem.addChild(TreeValueItem(self.tr('Min X'), extent.xMinimum())) extentItem.addChild(TreeValueItem(self.tr('Max X'), extent.xMaximum())) extentItem.addChild(TreeValueItem(self.tr('Min Y'), extent.yMinimum())) extentItem.addChild(TreeValueItem(self.tr('Max Y'), extent.yMaximum())) canvasItem.addChild(extentItem)
def populate_classified_values( unassigned_values, assigned_values, default_classes, list_unique_values, tree_mapping_widget): """Populate lstUniqueValues and treeClasses.from the parameters. :param unassigned_values: List of values that haven't been assigned to a class. It will be put in list_unique_values. :type unassigned_values: list :param assigned_values: Dictionary with class as the key and list of value as the value of the dictionary. It will be put in tree_mapping_widget. :type assigned_values: dict :param default_classes: Default classes from unit. :type default_classes: list :param list_unique_values: List Widget for unique values :type list_unique_values: QListWidget :param tree_mapping_widget: Tree Widget for classifying. :type tree_mapping_widget: QTreeWidget """ # Populate the unique values list list_unique_values.clear() list_unique_values.setSelectionMode( QAbstractItemView.ExtendedSelection) for value in unassigned_values: value_as_string = value is not None and str(value) or 'NULL' list_item = QListWidgetItem(list_unique_values) list_item.setFlags( Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled) list_item.setData(Qt.UserRole, value) list_item.setText(value_as_string) list_unique_values.addItem(list_item) # Populate assigned values tree tree_mapping_widget.clear() bold_font = QFont() bold_font.setItalic(True) bold_font.setBold(True) bold_font.setWeight(75) tree_mapping_widget.invisibleRootItem().setFlags( Qt.ItemIsEnabled) for default_class in default_classes: # Create branch for class tree_branch = QTreeWidgetItem(tree_mapping_widget) tree_branch.setFlags( Qt.ItemIsDropEnabled | Qt.ItemIsEnabled) tree_branch.setExpanded(True) tree_branch.setFont(0, bold_font) if 'name' in default_class: default_class_name = default_class['name'] else: default_class_name = default_class['key'] tree_branch.setText(0, default_class_name) tree_branch.setData(0, Qt.UserRole, default_class['key']) if 'description' in default_class: tree_branch.setToolTip(0, default_class['description']) # Assign known values for value in assigned_values[default_class['key']]: string_value = value is not None and str(value) or 'NULL' tree_leaf = QTreeWidgetItem(tree_branch) tree_leaf.setFlags( Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled) tree_leaf.setData(0, Qt.UserRole, value) tree_leaf.setText(0, string_value)
def on_btnAdd_clicked(self): item = QTreeWidgetItem() item.setText(0, '0.00') item.setText(1, '0.00') item.setBackground(2, QBrush(QColor(127, 127, 127))) self.reliefClassTree.addTopLevelItem(item)
def setupLayerList(self, layerList): self.mSublayersTreeWidget.setHeaderLabels(["Layer"]) self.mSublayersTreeWidget.setSortingEnabled(False) for layer in layerList: newItem = QTreeWidgetItem(self.mSublayersTreeWidget, [layer]) self.mSublayersTreeWidget.addTopLevelItem(newItem)
def __init__(self, iface, layer, tree, dlg): QTreeWidgetItem.__init__(self) self.iface = iface self.layer = layer self.setText(0, layer.name()) self.setIcon(0, self.layerIcon) project = QgsProject.instance() if project.layerTreeRoot().findLayer(layer.id()).isVisible(): self.setCheckState(0, Qt.Checked) else: self.setCheckState(0, Qt.Unchecked) self.visibleItem = QTreeWidgetItem(self) self.visibleCheck = QCheckBox() vis = layer.customProperty("qgis2web/Visible", True) if vis == 0 or str(vis).lower() == "false": self.visibleCheck.setChecked(False) else: self.visibleCheck.setChecked(True) self.visibleItem.setText(0, "Visible") self.addChild(self.visibleItem) tree.setItemWidget(self.visibleItem, 1, self.visibleCheck) self.interactiveItem = QTreeWidgetItem(self) self.interactiveCheck = QCheckBox() int = True if int == 0 or str(int).lower() == "false": self.interactiveCheck.setChecked(False) else: self.interactiveCheck.setChecked(True) self.interactiveItem.setText(0, "Popups") self.addChild(self.interactiveItem) tree.setItemWidget(self.interactiveItem, 1, self.interactiveCheck) if layer.type() == layer.VectorLayer: if layer.providerType() == 'WFS': self.jsonItem = QTreeWidgetItem(self) self.jsonCheck = QCheckBox() if layer.customProperty("qgis2web/Encode to JSON") == 2: self.jsonCheck.setChecked(True) self.jsonItem.setText(0, "Encode to JSON") self.jsonCheck.stateChanged.connect(self.changeJSON) self.addChild(self.jsonItem) tree.setItemWidget(self.jsonItem, 1, self.jsonCheck) if layer.geometryType() == QgsWkbTypes.PointGeometry: self.clusterItem = QTreeWidgetItem(self) self.clusterCheck = QCheckBox() if layer.customProperty("qgis2web/Cluster") == 2: self.clusterCheck.setChecked(True) self.clusterItem.setText(0, "Cluster") self.clusterCheck.stateChanged.connect(self.changeCluster) self.addChild(self.clusterItem) tree.setItemWidget(self.clusterItem, 1, self.clusterCheck) self.popupItem = QTreeWidgetItem(self) self.popupItem.setText(0, "Popup fields") options = [] fields = self.layer.fields() for f in fields: fieldIndex = fields.indexFromName(f.name()) editorWidget = layer.editorWidgetSetup(fieldIndex).type() if editorWidget == 'Hidden': continue options.append(f.name()) for option in options: self.attr = QTreeWidgetItem(self) self.attrWidget = QComboBox() self.attrWidget.addItem("no label") self.attrWidget.addItem("inline label") self.attrWidget.addItem("header label") custProp = layer.customProperty("qgis2web/popup/" + option) if (custProp != "" and custProp is not None): self.attrWidget.setCurrentIndex( self.attrWidget.findText( layer.customProperty("qgis2web/popup/" + option))) self.attr.setText(1, option) self.popupItem.addChild(self.attr) tree.setItemWidget(self.attr, 2, self.attrWidget) self.addChild(self.popupItem) else: if layer.providerType() == 'wms': self.getFeatureInfoItem = QTreeWidgetItem(self) self.getFeatureInfoCheck = QCheckBox() if layer.customProperty("qgis2web/GetFeatureInfo") == 2: self.getFeatureInfoCheck.setChecked(True) self.getFeatureInfoItem.setText(0, "Enable GetFeatureInfo?") self.getFeatureInfoCheck.stateChanged.connect( self.changeGetFeatureInfo) self.addChild(self.getFeatureInfoItem) tree.setItemWidget(self.getFeatureInfoItem, 1, self.getFeatureInfoCheck)
def populate(self): groups = {} count = 0 provider = algList.algs[self.providerName] algs = list(provider.values()) name = 'ACTIVATE_' + self.providerName.upper().replace(' ', '_') active = ProcessingConfig.getSetting(name) # Add algorithms for alg in algs: if not alg.showInToolbox: continue if alg.group in groups: groupItem = groups[alg.group] else: groupItem = QTreeWidgetItem() name = alg.i18n_group or alg.group if not active: groupItem.setForeground(0, Qt.darkGray) groupItem.setText(0, name) groupItem.setToolTip(0, name) groups[alg.group] = groupItem algItem = TreeAlgorithmItem(alg) if not active: algItem.setForeground(0, Qt.darkGray) groupItem.addChild(algItem) count += 1 actions = Processing.actions[self.providerName] for action in actions: if action.group in groups: groupItem = groups[action.group] else: groupItem = QTreeWidgetItem() groupItem.setText(0, action.group) groups[action.group] = groupItem algItem = TreeActionItem(action) groupItem.addChild(algItem) text = self.provider.getDescription() if not active: def activateProvider(): self.toolbox.activateProvider(self.providerName) label = QLabel(text + " <a href='%s'>Activate</a>") label.setStyleSheet( "QLabel {background-color: white; color: grey;}") label.linkActivated.connect(activateProvider) self.tree.setItemWidget(self, 0, label) else: text += QCoreApplication.translate( "TreeProviderItem", " [{0} geoalgorithms]").format(count) self.setText(0, text) self.setToolTip(0, self.text(0)) for groupItem in list(groups.values()): self.addChild(groupItem) self.setHidden(self.childCount() == 0)
def on_addUpdatePushButton_clicked(self): """ Creates a new reclassification button ready to be used """ #checking if the button name is defined if self.buttonNameLineEdit.text() == '': QMessageBox.critical(self, self.tr('Critical!'), self.tr('Enter a button name!')) return if not self.validateShortcut(self.buttonNameLineEdit.text()): QMessageBox.critical(self, self.tr('Critical!'), self.tr('Shortcut already set to another tool!')) return # invisible root item rootItem = self.treeWidget.invisibleRootItem() # class row in the classListWidget classRow = self.tableComboBox.currentText() schemaName, tableName = self.abstractDb.getTableSchema(classRow) if self.abstractDb.db.driverName() == 'QSQLITE': category = schemaName + '_' + tableName.split('_')[0] else: if self.edgvVersion == 'Non_EDGV': category = schemaName else: category = schemaName + '.' + tableName.split('_')[0] # creating items in tree buttonInTree = False leafChildInTree = False leafInTree = False for i in range(rootItem.childCount()): leaf = rootItem.child(i) if leaf.text(0) == category: leafInTree = True item = leaf for j in range(leaf.childCount()): leafChild = leaf.child(j) if leafChild.text(0) == self.tableComboBox.currentText(): leafChildInTree = True item = leafChild for k in range(leafChild.childCount()): leafGrandson = leafChild.child(k) if leafGrandson.text(0) == self.buttonNameLineEdit.text(): buttonItem = leafGrandson buttonItem.setText(0, self.buttonNameLineEdit.text()) buttonInTree = True break if not leafInTree: item = QTreeWidgetItem(rootItem) item.setText(0, category) if not leafChildInTree: item = QTreeWidgetItem(item) item.setText(0, classRow) if not buttonInTree: # item that will be used to create the button buttonItem = QTreeWidgetItem(item) buttonItem.setText(0, self.buttonNameLineEdit.text()) if self.abstractDb.db.driverName() == 'QSQLITE': self.qmlPath = os.path.join(self.qmlDir, tableName+'.qml') fullTableName = schemaName+'_'+tableName else: fullTableName = schemaName+'.'+tableName qmlDict = self.buildQmlDict(fullTableName) #add optional parameters to self.buttonPropDict if fullTableName not in list(self.buttonPropDict.keys()): self.buttonPropDict[fullTableName] = dict() #parameter dict from buttonPropWidget has the following format: #{'buttonColor':--color of the button--, 'buttonToolTip'--button toolTip--, 'buttonGroupTag':--group tag of the button--} self.buttonPropDict[fullTableName][self.buttonNameLineEdit.text()] = self.buttonPropWidget.getParameterDict() # accessing the attribute name and widget (QComboBox or QListWidget depending on data type) for i in range(self.attributeTableWidget.rowCount()): attribute = self.attributeTableWidget.item(i, 0).text() # this guy is a QComboBox or a QListWidget widgetItem = self.attributeTableWidget.cellWidget(i, 1) if attribute in list(qmlDict.keys()): if isinstance(qmlDict[attribute], dict): if widgetItem.currentText() in list(qmlDict[attribute].keys()): value = qmlDict[attribute][widgetItem.currentText()] if isinstance(qmlDict[attribute], tuple): (table, filterKeys) = qmlDict[attribute] valueRelation = self.makeValueRelationDict(table, filterKeys) values = [] for i in range(widgetItem.count()): if widgetItem.item(i).checkState() == Qt.Checked: key = widgetItem.item(i).text() values.append(valueRelation[key]) value = '{%s}' % ','.join(map(str, values)) else: if isinstance(widgetItem, DsgCustomComboBox): value = widgetItem.currentText() else: value = widgetItem.text() #sweep tree for attribute attrFound = False for k in range(buttonItem.childCount()): attrItem = buttonItem.child(k) if attribute == attrItem.text(0): attrFound = True attributeItem = attrItem break if not attrFound: attributeItem = QTreeWidgetItem(buttonItem) attributeItem.setText(0, attribute) attributeItem.setText(1, value) for j in [2,3]: itemCell = self.attributeTableWidget.cellWidget(i, j) if itemCell: if itemCell.isEnabled(): itemText = itemCell.currentText() attributeItem.setText(j, self.optionalDict[itemText])
def fill_tree_with_element(widget, treeItem, elt, ns_imap={}, custom_viewers={}, ns_map={}): """ :param widget: the QTreeWidget :param treeItem: a QTreeWidgetItem to fill :param elt: the XML node :param ns_imap: an "inverse" namespace map { uri : prefix } :param custom_viewers: a dict giving a custom viewer plugin (QWidget) for some elements {tag : constructor} :param ns_map: a namespace map { prefix : uri } """ is_root = treeItem == widget.invisibleRootItem() # tag ns, tag = split_tag(elt.tag) if ns and ns_imap.get(ns): treeItem.setText(0, ns_imap[ns] + ":" + tag) else: treeItem.setText(0, tag) f = treeItem.font(0) f.setBold(True) treeItem.setFont(0, f) # custom viewer if elt.tag in custom_viewers: custom_viewer_widget, filter = custom_viewers[elt.tag] if filter is None or elt.find(filter, ns_map) is not None: btn = QToolButton(widget) btn.setIcon(custom_viewer_widget.icon()) btn.setIconSize(QSize(32, 32)) def show_viewer(btn): widget.w = custom_viewer_widget.init_from_xml(elt) widget.w.setWindowModality(Qt.WindowModal) widget.w.show() btn.clicked.connect(show_viewer) w = QWidget(widget) l = QHBoxLayout() l.addWidget(btn) l.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding)) w.setLayout(l) if is_root: # insert an item child = QTreeWidgetItem() treeItem.addChild(child) widget.setItemWidget(child, 0, w) else: widget.setItemWidget(treeItem, 1, w) # attributes for k, v in elt.attrib.items(): child = QTreeWidgetItem() treeItem.addChild(child) if "}" in k: i = k.index("}") ns = k[1:i] # get ns prefix from ns uri p = ns_imap.get(ns) if p is not None: n = p + ":" + k[i + 1:] else: n = k[i + 1:] else: n = no_prefix(k) child.setText(0, "@" + n) if n == "xlink:href" and v.startswith("http"): html = QLabel(widget) html.setOpenExternalLinks(True) html.setTextFormat(Qt.RichText) html.setText('<a href="{}">{}</a>'.format(v, v)) child.setData(1, Qt.UserRole, v) widget.setItemWidget(child, 1, html) else: child.setText(1, v) # text if elt.text: treeItem.setText(1, elt.text) # children for xmlChild in elt: child = QTreeWidgetItem() treeItem.addChild(child) fill_tree_with_element(widget, child, xmlChild, ns_imap, custom_viewers, ns_map)
def collect_overlays_summary(root, layer_data): sublayers = layer_data.get('layers') if sublayers: item = QTreeWidgetItem(root) item.setText(0, layer_data['name']) for sublayer_data in sublayers: collect_overlays_summary(item, sublayer_data) item.setExpanded(True) else: if 'visibility_scale_max' in layer_data: scale_visibility = 'Maximum (inclusive): {0}, Minimum (exclusive): {1}'.format( layer_data['visibility_scale_max'], layer_data['visibility_scale_min']) else: scale_visibility = '' if layer_data.get('hidden'): create_formatted_tree(root, {layer_data['name']: "Hidden: True"}) return create_formatted_tree( root, { '{0}': [ "Visible: {1}", "Queryable: {2}", "Extent: {3}", "CRS: {4}", "Geometry type: {5}", "Scale based visibility: {6}", "Labels: {7}", "Provider type: {8}", "Attributes: {9}", "Attribution:", ["Title: {10}", "URL: {11}"], "Metadata:", [ "Title: {12}", "Abstract: {13}", "Keyword list: {14}" ], "Time settings", [ "Time data: {15}{16}", "Output datetime format: {17}", "Unix attribute created: {18}" ] ] }, [ layer_data['name'], layer_data['visible'], layer_data['queryable'], layer_data['extent'], layer_data['projection'], layer_data.get('geom_type', ''), scale_visibility, layer_data.get('labels', False), layer_data['provider_type'], ", ".join([ attribute.get('title', attribute['name']) for attribute in layer_data.get('attributes', []) ]), opt_value(layer_data, 'attribution.title'), opt_value(layer_data, 'attribution.url'), layer_data['metadata']['title'], layer_data['metadata']['abstract'], layer_data['metadata']['keyword_list'], opt_value(layer_data, 'original_time_attribute'), opt_value(layer_data, 'time_stamp'), opt_value(layer_data, 'output_datetime_mask'), opt_value(layer_data, 'unix'), ])
def collect_base_layer_summary(root, layer_data): sublayers = layer_data.get('layers') if sublayers: item = QTreeWidgetItem(root) item.setText(0, layer_data['name']) for sublayer_data in sublayers: collect_base_layer_summary(item, sublayer_data) else: resolutions = layer_data['resolutions'] if 'min_resolution' in layer_data: resolutions = [ res for res in resolutions if res >= layer_data['min_resolution'] and res <= layer_data['max_resolution'] ] scales = self.plugin.resolutions_to_scales(resolutions) # Regular QGIS base layers if layer_data['type'] not in ('blank', 'osm', 'mapbox', 'bing'): if 'visibility_scale_max' in layer_data: scale_visibility = 'Maximum (inclusive): {0}, Minimum (exclusive): {1}'.format( layer_data['visibility_scale_max'], layer_data['visibility_scale_min']) else: scale_visibility = '' create_formatted_tree( root, { '{0}': [ "Extent: {1}", "CRS: {2}", "Scale based visibility: {3}", "Visible scales: {4}", "Visible resolutions: {5}", "Provider type: {6}", "Attribution", ["Title: {7}", "URL: {8}"], "Metadata", [ "Title: {9}", "Abstract: {10}", "Keyword list: {11}" ] ] }, [ layer_data['name'], layer_data['extent'], layer_data['projection'], scale_visibility, scales, resolutions, layer_data.get('provider_type', ''), opt_value(layer_data, 'attribution.title'), opt_value(layer_data, 'attribution.url'), layer_data['metadata']['title'], layer_data['metadata']['abstract'], layer_data['metadata']['keyword_list'] ]) # Special base layers else: layer_summary = [ "Name: {0}", "Abstract: {1}", "Keywords: {2}", "Extent: {3}", "Visible scales: {4}", "Visible resolutions: {5}" ] if layer_data['type'] == 'mapbox': layer_summary.append("MapId: {}".format( layer_data['mapid'])) layer_summary.append("ApiKey: {}".format( layer_data['apikey'])) elif layer_data['type'] == 'bing': layer_summary.append("ApiKey: {}".format( layer_data['apikey'])) create_formatted_tree(root, {'{0}': layer_summary}, [ layer_data['name'], opt_value(layer_data, 'metadata.abstract'), opt_value(layer_data, 'metadata.keyword_list'), layer_data['extent'], scales, resolutions, ])
def add_child(self, fields): """Add a child result to the last inserted parent """ QTreeWidgetItem(self.result_parent, fields)
def __init__(self): super(TestSelector, self).__init__() self.setupUi(self) self.tests = None self.bar = QgsMessageBar() self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.layout().insertWidget(1, self.bar) allTests = defaultdict(list) for test in tests.tests: allTests[test.group].append(test) for group, groupTests in allTests.items(): groupItem = QTreeWidgetItem() groupItem.setText(0, group) groupItem.setFlags(groupItem.flags() | Qt.ItemIsTristate) unitItem = QTreeWidgetItem() unitItem.setText(0, 'Fully Automated Tests') unitItem.setFlags(unitItem.flags() | Qt.ItemIsTristate) manualItem = QTreeWidgetItem() manualItem.setText(0, 'Manual and Semi-Automated Tests') manualItem.setFlags(manualItem.flags() | Qt.ItemIsTristate) unitTestsByCategories = defaultdict(list) manualTestsByCategories = defaultdict(list) for test in groupTests: if isinstance(test, UnitTestWrapper): unitTestsByCategories[test.category].append(test) else: manualTestsByCategories[test.category].append(test) for testsList, parentItem in [(unitTestsByCategories, unitItem), (manualTestsByCategories, manualItem) ]: for cat, catTests in testsList.items(): categoryItem = QTreeWidgetItem() categoryItem.setText(0, cat) categoryItem.setFlags(manualItem.flags() | Qt.ItemIsTristate) for test in catTests: testItem = QTreeWidgetItem() testItem.setFlags(testItem.flags() | Qt.ItemIsUserCheckable) testItem.setCheckState(0, Qt.Unchecked) testItem.test = test testItem.setText(0, test.name) categoryItem.addChild(testItem) parentItem.addChild(categoryItem) if manualItem.childCount(): groupItem.addChild(manualItem) if unitItem.childCount(): groupItem.addChild(unitItem) self.testsTree.addTopLevelItem(groupItem) groupItem.setExpanded(True) self.testsTree.itemChanged.connect(self.toggleRunButton) self.buttonBox.button( QDialogButtonBox.Ok).setText('Run Selected Tests') self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False) self.buttonBox.accepted.connect(self.okPressed) self.buttonBox.rejected.connect(self.cancelPressed) self.selectAllLabel.linkActivated.connect( lambda: self.checkTests(lambda t: Qt.Checked)) self.unselectAllLabel.linkActivated.connect( lambda: self.checkTests(lambda t: Qt.Unchecked)) def _onlyManual(t): if isinstance(t, UnitTestWrapper): return Qt.Unchecked else: return Qt.Checked self.onlyManualLabel.linkActivated.connect( lambda: self.checkTests(_onlyManual)) def _onlyUnit(t): if isinstance(t, UnitTestWrapper): return Qt.Checked else: return Qt.Unchecked self.onlyUnitLabel.linkActivated.connect( lambda: self.checkTests(_onlyUnit)) filepath = os.path.expanduser('~/.testerplugin/failed.txt') if os.path.exists(filepath): with open(filepath) as f: failed = json.load(f) else: failed = [] def _onlyLastFailures(t): if t.group in failed and t.name in failed[t.group]: return Qt.Checked else: return Qt.Unchecked self.onlyLastFailuresLabel.linkActivated.connect( lambda: self.checkTests(_onlyLastFailures)) self.exportButton.clicked.connect(self.export)
def run(self): """Run method that performs all the real work""" # Create the dialog with elements (after translation) and keep reference # Only create GUI ONCE in callback, so that it will only load when the plugin is started if self.first_start == True: self.first_start = False self.dlg = DiversityCalcDialog() self.dlg.mcbPoly.setFilters(QgsMapLayerProxyModel.PolygonLayer) self.dlg.mcbPoint.setFilters(QgsMapLayerProxyModel.PointLayer) self.dlg.fcbCategory.setFilters(QgsFieldProxyModel.String) self.dlg.fcbSpecies.setFilters(QgsFieldProxyModel.String) self.dlg.fcbCategory.setLayer(self.dlg.mcbPoly.currentLayer()) self.dlg.fcbSpecies.setLayer(self.dlg.mcbPoint.currentLayer()) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: # Get required input parameters from the dialog lyrPoly = self.dlg.mcbPoly.currentLayer() lyrPoint = self.dlg.mcbPoint.currentLayer() fldCategory = self.dlg.fcbCategory.currentField() fldSpecies = self.dlg.fcbSpecies.currentField() dctMain = {} for poly in lyrPoly.getFeatures(): sCategory = poly.attribute(fldCategory) QgsMessageLog.logMessage("Category: {}".format(sCategory), "Diversity Calculator", level=Qgis.Info) dctSummary = dc_summarizePoly(poly, lyrPoint, fldSpecies) QgsMessageLog.logMessage("Summary: {}".format(dctSummary), "Diversity Calculator", level=Qgis.Info) dctMain = dc_mergeDictionaries(dctMain, sCategory, dctSummary) QMessageBox.information(self.dlg, "Summary", dc_resultString(dctMain)) dlgResults = DlgResults() for category, summary in dctMain.items(): total = sum(summary.values()) twiCat = QTreeWidgetItem(dlgResults.trwResults, [ category, str(total), str(dc_richness(summary)), "{:3.3f}".format( dc_evenness(summary)), "{:3.3f}".format( dc_shannons(summary)), "{:3.3f}".format( dc_simpsons(summary)) ]) for species, obs in summary.items(): twiCat.addChild( QTreeWidgetItem(twiCat, [species, str(obs)])) dlgResults.trwResults.addTopLevelItem(twiCat) dlgResults.show() dlgResults.exec_()
def tree_widget_item(self): item = QTreeWidgetItem([self.name]) item.addChildren([child.tree_widget_item() for child in self.children]) item.setData(0, Qt.UserRole, deepcopy(self)) return item
def __init__(self, parent=None): """Constructor.""" QDialog.__init__(self) self.parent = parent self.setupUi(self) self.menu.clicked.connect(self.expand) self.menu.clicked.connect(self.display_content) self.tree_menu = [ { 'label': 'Import', 'icon': resource('import.png'), 'content': [{ 'label': 'Shapefile', 'icon': resource('shp.png'), 'content': { 'widget': OpenShapefileWidget(), 'help': help_open_shapefile() } }, { 'label': 'Raster', 'icon': resource('raster.png'), 'content': { 'widget': OpenRasterWidget(), 'help': help_open_raster() } }, { 'label': 'Table XLS/DBF', 'icon': resource('xls.png'), 'content': { 'widget': OpenXlsDbfFileWidget(), 'help': help_open_table() } }, { 'label': 'Table CSV', 'icon': resource('csv.png'), 'content': { 'widget': OpenCsv(), 'help': help_open_csv() } }, { 'label': 'XY to map', 'icon': resource('xy.png'), 'content': { 'widget': OpenCsv(), 'help': help_open_csv() } }] }, { 'label': 'Analyse', 'icon': resource('gears.png'), 'content': [{ 'label': 'Blur', 'icon': resource('blur.png'), 'content': [{ 'label': 'Blur', 'icon': resource('blur.png'), 'content': { 'widget': BlurWidget(), 'help': help_blur() } }, { 'label': 'Stats', 'icon': resource('sigma.png'), 'content': { 'widget': StatsWidget(), 'help': help_stats_blurring() } }] }, { 'label': 'Autocorrelation', 'icon': resource('autocorrelation.png'), 'content': [{ 'label': 'Polygon layer only', 'icon': resource('autocorrelation.png'), 'content': { 'widget': AutocorrelationDialog(), 'help': help_autocorrelation() } }] }, { 'label': 'Composite Index', 'icon': resource('composite_index.png'), 'content': [{ 'label': 'Polygon layer only', 'icon': resource('composite_index.png'), 'content': { 'widget': CompositeIndexDialog(), 'help': help_composite_index() } }] }, { 'label': 'Incidence', 'icon': resource('incidence.png'), 'content': [{ 'label': 'Polygon layer only', 'icon': resource('incidence.png'), 'content': { 'widget': IncidenceDialog(), 'help': help_incidence() } }, { 'label': 'Case and aggregation layers', 'icon': resource('incidence.png'), 'content': { 'widget': IncidencePointDialog(), 'help': help_incidence_point() } }] }, { 'label': 'Density', 'icon': resource('incidence.png'), 'content': [{ 'label': 'Polygon layer only', 'icon': resource('incidence.png'), 'content': { 'widget': DensityDialog(), 'help': help_density() } }, { 'label': 'Case and aggregation layers', 'icon': resource('incidence.png'), 'content': { 'widget': DensityPointDialog(), 'help': help_density_point() } }] }] }, { 'label': 'Export', 'icon': resource('export.png'), 'content': [ { 'label': 'Attribute table', 'icon': resource('csv.png'), 'content': { 'widget': CsvExport(), 'help': help_attribute_table() } }, { # ajoute par Rachel Goree 30/05/2017 'label': 'KML', 'icon': resource('kml.png'), 'content': { 'widget': KmlExport(), 'help': help_export_kml() } } ] } ] self.stack.addWidget(AboutWidget()) self.help_list = [] # A category is import, process and export. for category_def in self.tree_menu: category_menu = QTreeWidgetItem(self.menu) category_menu.setIcon(0, QIcon(category_def['icon'])) category_menu.setText(0, category_def['label']) # Sub item for sub_category_def in category_def['content']: menu_entry = QTreeWidgetItem(category_menu) menu_entry.setIcon(0, QIcon(sub_category_def['icon'])) menu_entry.setText(0, sub_category_def['label']) # Add widget or add tab if isinstance(sub_category_def['content'], dict): widget = sub_category_def['content']['widget'] self.stack.addWidget(widget) self.help_list.append(sub_category_def['content']['help']) else: tab = QTabWidget(self.stack) tab.setIconSize(QSize(32, 32)) self.stack.addWidget(tab) tab_help = [] tab_bar = sub_category_def['content'] for item in tab_bar: label = item['label'] icon = QIcon(item['icon']) widget = item['content']['widget'] help_widget = item['content']['help'] tab_help.append(help_widget) tab.addTab(widget, icon, label) self.help_list.append(tab_help) self.stack.setCurrentIndex(1) # https://github.com/Gustry/GeoPublicHealth/issues/20 self.menu.setAttribute(Qt.WA_MacShowFocusRect, False)
def update_available_layers(self): self.trw_layers.setUpdatesEnabled( False) # Don't render until we're ready # Grab some context data show_domains = self.chk_show_domains.isChecked() show_structures = self.chk_show_structures.isChecked() show_associations = self.chk_show_associations.isChecked() top_level_items_expanded_info = [] for i in range(self.trw_layers.topLevelItemCount()): top_level_items_expanded_info.append( self.trw_layers.topLevelItem(i).isExpanded()) # Save selection self.update_selected_items() # Iterate models adding children self.trw_layers.blockSignals( True) # We don't want to get itemSelectionChanged here self.trw_layers.clear() self.trw_layers.blockSignals(False) sorted_models = sorted(self.models_tree.keys()) for model in sorted_models: children = [] model_item = QTreeWidgetItem([model]) # Filter by search text list_tables = self.filter_tables_by_search_text( self.models_tree[model].keys(), self.txt_search_text.text()) sorted_tables = sorted(list_tables) for table in sorted_tables: current_table_info = self.models_tree[model][table] if current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_DOMAIN and not show_domains \ or current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_STRUCTURE and not show_structures \ or current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_ASSOCIATION and not show_associations: continue table_item = QTreeWidgetItem([table]) table_item.setData(0, Qt.UserRole, self.models_tree[model][table]) geometry_type = QgsWkbTypes().geometryType( QgsWkbTypes().parseType(current_table_info[ QueryNames.GEOMETRY_TYPE_MODEL_BAKER]) ) if current_table_info[ QueryNames.GEOMETRY_TYPE_MODEL_BAKER] else None icon_name = self.icon_names[ 3 if geometry_type is None else geometry_type] # Is the layer already loaded in canvas? if self.app.core.get_ladm_layer_from_qgis( self._db, current_table_info[QueryNames.TABLE_NAME_MODEL_BAKER], EnumLayerRegistryType.IN_LAYER_TREE) is not None: table_item.setText( 0, table + QCoreApplication.translate( "LoadLayersDialog", " [already loaded]")) table_item.setData(0, Qt.ForegroundRole, QBrush(Qt.lightGray)) table_item.setFlags(Qt.ItemIsEnabled) # Not selectable else: # Laye not in QGIS Layer Tree if not current_table_info[ QueryNames. KIND_SETTINGS_MODEL_BAKER]: # This is a class font = QFont() font.setBold(True) table_item.setData(0, Qt.FontRole, font) if current_table_info[ QueryNames. KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_DOMAIN: icon_name = self.icon_names[4] elif current_table_info[ QueryNames. KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_STRUCTURE: if geometry_type is None: icon_name = self.icon_names[5] elif current_table_info[ QueryNames. KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_ASSOCIATION: icon_name = self.icon_names[6] icon = QIcon(":/Asistente-LADM-COL/resources/images/{}".format( icon_name)) table_item.setData(0, Qt.DecorationRole, icon) children.append(table_item) model_item.addChildren(children) self.trw_layers.addTopLevelItem(model_item) # Set selection iterator = QTreeWidgetItemIterator(self.trw_layers, QTreeWidgetItemIterator.Selectable) self.trw_layers.blockSignals( True) # We don't want to get itemSelectionChanged here while iterator.value(): item = iterator.value() if item.text(0) in self.selected_items_dict: item.setSelected(True) iterator += 1 self.trw_layers.blockSignals(False) # Make model items non selectable # Set expand taking previous states into account for i in range(self.trw_layers.topLevelItemCount()): self.trw_layers.topLevelItem(i).setFlags( Qt.ItemIsEnabled) # Not selectable self.trw_layers.topLevelItem(i).setExpanded( top_level_items_expanded_info[i] if top_level_items_expanded_info else True) self.trw_layers.setUpdatesEnabled(True) # Now render!
def create_root_node(self, name): root = QTreeWidgetItem(self.twEntityDepend, 0) root.setText(0, name) return root
def populate(self): groups = {} count = 0 algs = self.provider.algorithms() active = self.provider.isActive() # Add algorithms for alg in algs: if alg.flags() & QgsProcessingAlgorithm.FlagHideFromToolbox: continue if alg.group() in groups: groupItem = groups[alg.group()] else: groupItem = QTreeWidgetItem() name = alg.group() if not active: groupItem.setForeground(0, Qt.darkGray) groupItem.setText(0, name) groupItem.setToolTip(0, name) groups[alg.group()] = groupItem algItem = TreeAlgorithmItem(alg) if not active: algItem.setForeground(0, Qt.darkGray) groupItem.addChild(algItem) count += 1 if self.provider.id() in ProviderActions.actions: actions = ProviderActions.actions[self.provider.id()] for action in actions: if action.group in groups: groupItem = groups[action.group] else: groupItem = QTreeWidgetItem() groupItem.setText(0, action.group) groups[action.group] = groupItem algItem = TreeActionItem(action) groupItem.addChild(algItem) text = self.provider.name() if not active: def activateProvider(): self.toolbox.activateProvider(self.provider.id()) label = QLabel(text + " <a href='%s'>Activate</a>") label.setStyleSheet( "QLabel {background-color: white; color: grey;}") label.linkActivated.connect(activateProvider) self.tree.setItemWidget(self, 0, label) else: text += QCoreApplication.translate( "TreeProviderItem", " [{0} geoalgorithms]").format(count) self.setText(0, text) self.setToolTip(0, self.text(0)) for groupItem in list(groups.values()): self.addChild(groupItem) self.setHidden(self.childCount() == 0)
def __init__(self): super(TestSelector, self).__init__() self.setupUi(self) self.tests = None self.bar = QgsMessageBar() self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.layout().insertWidget(1, self.bar) allTests = defaultdict(list) for test in tests.tests: allTests[test.group].append(test) for group, groupTests in iteritems(allTests): groupItem = QTreeWidgetItem() groupItem.setText(0, group) groupItem.setFlags(groupItem.flags() | Qt.ItemIsTristate) unitItem = QTreeWidgetItem() unitItem.setText(0, "Fully automated tests") unitItem.setFlags(unitItem.flags() | Qt.ItemIsTristate) manualItem = QTreeWidgetItem() manualItem.setText(0, "Manual and semi-automated tests") manualItem.setFlags(manualItem.flags() | Qt.ItemIsTristate) unitTestsByCategories = defaultdict(list) manualTestsByCategories = defaultdict(list) for test in groupTests: if isinstance(test, UnitTestWrapper): unitTestsByCategories[test.category].append(test) else: manualTestsByCategories[test.category].append(test) for testsList, parentItem in [(unitTestsByCategories, unitItem), (manualTestsByCategories, manualItem) ]: for cat, catTests in iteritems(testsList): categoryItem = QTreeWidgetItem() categoryItem.setText(0, cat) categoryItem.setFlags(manualItem.flags() | Qt.ItemIsTristate) for test in catTests: testItem = QTreeWidgetItem() testItem.setFlags(testItem.flags() | Qt.ItemIsUserCheckable) testItem.setCheckState(0, Qt.Unchecked) testItem.test = test testItem.setText(0, test.name) categoryItem.addChild(testItem) parentItem.addChild(categoryItem) if manualItem.childCount(): groupItem.addChild(manualItem) if unitItem.childCount(): groupItem.addChild(unitItem) self.testsTree.addTopLevelItem(groupItem) groupItem.setExpanded(True) self.buttonBox.button( QDialogButtonBox.Ok).setText("Run selected tests") self.buttonBox.accepted.connect(self.okPressed) self.buttonBox.rejected.connect(self.cancelPressed) self.selectAllLabel.linkActivated.connect( lambda: self.checkTests(lambda t: Qt.Checked)) self.unselectAllLabel.linkActivated.connect( lambda: self.checkTests(lambda t: Qt.Unchecked)) def _onlyManual(t): if isinstance(t, UnitTestWrapper): return Qt.Unchecked else: return Qt.Checked self.onlyManualLabel.linkActivated.connect( lambda: self.checkTests(_onlyManual)) def _onlyUnit(t): if isinstance(t, UnitTestWrapper): return Qt.Checked else: return Qt.Unchecked self.onlyUnitLabel.linkActivated.connect( lambda: self.checkTests(_onlyUnit)) self.exportButton.clicked.connect(self.export)
def addAlgorithmsFromProvider(self, provider, parent): groups = {} count = 0 algs = provider.algorithms() active = provider.isActive() # Add algorithms for alg in algs: if alg.flags() & QgsProcessingAlgorithm.FlagHideFromToolbox: continue groupItem = None if alg.group() in groups: groupItem = groups[alg.group()] else: # check if group already exists for i in range(parent.childCount()): if parent.child(i).text(0) == alg.group(): groupItem = parent.child(i) groups[alg.group()] = groupItem break if not groupItem: groupItem = QTreeWidgetItem() name = alg.group() if not active: groupItem.setForeground(0, Qt.darkGray) groupItem.setText(0, name) groupItem.setToolTip(0, name) if provider.id() in ('qgis', 'native'): groupItem.setIcon(0, provider.icon()) groups[alg.group()] = groupItem algItem = TreeAlgorithmItem(alg) if not active: algItem.setForeground(0, Qt.darkGray) groupItem.addChild(algItem) count += 1 if provider.id() in ProviderActions.actions: actions = ProviderActions.actions[provider.id()] for action in actions: if action.group in groups: groupItem = groups[action.group] else: groupItem = QTreeWidgetItem() groupItem.setText(0, action.group) groups[action.group] = groupItem algItem = TreeActionItem(action) groupItem.addChild(algItem) text = provider.name() if not provider.id() in ('qgis', 'native'): if not active: def activateProvider(): self.activateProvider(provider.id()) label = QLabel( text + " <a href='%s'>Activate</a>") label.setStyleSheet( "QLabel {background-color: white; color: grey;}") label.linkActivated.connect(activateProvider) self.algorithmTree.setItemWidget(parent, 0, label) else: text += QCoreApplication.translate( "TreeProviderItem", " [{0} geoalgorithms]").format(count) parent.setText(0, text) parent.setToolTip(0, parent.text(0)) for groupItem in list(groups.values()): parent.addChild(groupItem) if not provider.id() in ('qgis', 'native'): parent.setHidden(parent.childCount() == 0)
def data(self, profile_data): """Set data for the widget. :param profile_data: profile data. :type profile_data: dict It will replace the previous data. """ default_profile = generate_default_profile() self.clear() for hazard in sorted(default_profile.keys()): classifications = default_profile[hazard] hazard_widget_item = QTreeWidgetItem() hazard_widget_item.setData(0, Qt.UserRole, hazard) hazard_widget_item.setText(0, get_name(hazard)) for classification in sorted(classifications.keys()): # Filter out classification that doesn't support population. # TODO(IS): This is not the best place to put the filtering. # It's more suitable in the generate_default_profile method # in safe/definitions/utilities. classification_definition = definition(classification) supported_exposures = classification_definition.get( 'exposures', []) # Empty list means support all exposure if supported_exposures != []: if exposure_population not in supported_exposures: continue classes = classifications[classification] classification_widget_item = QTreeWidgetItem() classification_widget_item.setData(0, Qt.UserRole, classification) classification_widget_item.setText(0, get_name(classification)) hazard_widget_item.addChild(classification_widget_item) for the_class, the_value in list(classes.items()): the_class_widget_item = QTreeWidgetItem() the_class_widget_item.setData(0, Qt.UserRole, the_class) the_class_widget_item.setText( 0, get_class_name(the_class, classification)) classification_widget_item.addChild(the_class_widget_item) # Adding widget must be happened after addChild affected_check_box = QCheckBox(self) # Set from profile_data if exist, else get default profile_value = profile_data.get(hazard, {}).get( classification, {}).get(the_class, the_value) affected_check_box.setChecked(profile_value['affected']) self.setItemWidget(the_class_widget_item, 1, affected_check_box) displacement_rate_spinbox = PercentageSpinBox(self) displacement_rate_spinbox.setValue( profile_value['displacement_rate']) displacement_rate_spinbox.setEnabled( profile_value['affected']) self.setItemWidget(the_class_widget_item, 2, displacement_rate_spinbox) # Behaviour when the check box is checked # noinspection PyUnresolvedReferences affected_check_box.stateChanged.connect( displacement_rate_spinbox.setEnabled) if hazard_widget_item.childCount() > 0: self.widget_items.append(hazard_widget_item) self.addTopLevelItems(self.widget_items) self.expandAll()
def fillAlgorithmTreeUsingProviders(self): self.algorithmTree.clear() text = str(self.searchBox.text()) search_strings = text.split(' ') qgis_groups = {} for provider in QgsApplication.processingRegistry().providers(): if not provider.isActive(): continue groups = {} # Add algorithms for alg in provider.algorithms(): if alg.flags() & QgsProcessingAlgorithm.FlagHideFromModeler: continue if alg.id() == self.model.id(): continue item_text = [alg.displayName().lower()] item_text.extend(alg.tags()) show = not search_strings or all( any(part in t for t in item_text) for part in search_strings) if show: if alg.group() in groups: groupItem = groups[alg.group()] elif provider.id() in ( 'qgis', 'native') and alg.group() in qgis_groups: groupItem = qgis_groups[alg.group()] else: groupItem = QTreeWidgetItem() name = alg.group() groupItem.setText(0, name) groupItem.setToolTip(0, name) groupItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) if provider.id() in ('qgis', 'native'): groupItem.setIcon(0, provider.icon()) qgis_groups[alg.group()] = groupItem else: groups[alg.group()] = groupItem algItem = TreeAlgorithmItem(alg) groupItem.addChild(algItem) if len(groups) > 0: providerItem = QTreeWidgetItem() providerItem.setText(0, provider.name()) providerItem.setToolTip(0, provider.name()) providerItem.setIcon(0, provider.icon()) providerItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) for groupItem in list(groups.values()): providerItem.addChild(groupItem) self.algorithmTree.addTopLevelItem(providerItem) providerItem.setExpanded(text != '') for groupItem in list(groups.values()): if text != '': groupItem.setExpanded(True) if len(qgis_groups) > 0: for groupItem in list(qgis_groups.values()): self.algorithmTree.addTopLevelItem(groupItem) for groupItem in list(qgis_groups.values()): if text != '': groupItem.setExpanded(True) self.algorithmTree.sortItems(0, Qt.AscendingOrder)
def create_dummy_tree_item(dummy_text): item = QTreeWidgetItem() item.setText(0, dummy_text) return item