Python QTreeWidgetItem.setText方法代码示例

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    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 + "&nbsp;&nbsp;&nbsp;&nbsp;<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)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    def computeDiffs(self):
        self.featuresTree.clear()
        self.changes = self.localChanges(self.layer)
        layerItem = QTreeWidgetItem()
        layerItem.setText(0, self.layer.name())
        layerItem.setIcon(0, layerIcon)
        self.featuresTree.addTopLevelItem(layerItem)
        addedItem = QTreeWidgetItem()
        addedItem.setText(0, "Added")
        addedItem.setIcon(0, addedIcon)
        removedItem = QTreeWidgetItem()
        removedItem.setText(0, "Removed")
        removedItem.setIcon(0, removedIcon)
        modifiedItem = QTreeWidgetItem()
        modifiedItem.setText(0, "Modified")
        modifiedItem.setIcon(0, modifiedIcon)
        layerSubItems = {LOCAL_FEATURE_ADDED: addedItem,
                         LOCAL_FEATURE_REMOVED: removedItem,
                         LOCAL_FEATURE_MODIFIED: modifiedItem}

        for c in list(self.changes.values()):
            item = QTreeWidgetItem()
            item.setText(0, c.fid)
            item.setIcon(0, featureIcon)
            layerSubItems[c.changetype].addChild(item)

        for i in [LOCAL_FEATURE_ADDED, LOCAL_FEATURE_REMOVED, LOCAL_FEATURE_MODIFIED]:
            layerItem.addChild(layerSubItems[i])
            layerSubItems[i].setText(0, "%s [%i features]" % (layerSubItems[i].text(0), layerSubItems[i].childCount()))

        self.attributesTable.clear()
        self.attributesTable.verticalHeader().hide()
        self.attributesTable.horizontalHeader().hide()

        self.featuresTree.expandAll()

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    def addRecentAlgorithms(self, updating):
        showRecent = ProcessingConfig.getSetting(
            ProcessingConfig.SHOW_RECENT_ALGORITHMS)
        if showRecent:
            recent = ProcessingLog.getRecentAlgorithms()
            if len(recent) != 0:
                found = False
                if updating:
                    recentItem = self.algorithmTree.topLevelItem(0)
                    if recentItem.text(0) == self.tr('Recently used'):
                        treeWidget = recentItem.treeWidget()
                        treeWidget.takeTopLevelItem(
                            treeWidget.indexOfTopLevelItem(recentItem))

                recentItem = QTreeWidgetItem()
                recentItem.setText(0, self.tr('Recently used'))
                for algname in recent:
                    alg = QgsApplication.processingRegistry().createAlgorithmById(algname)
                    if alg is not None:
                        algItem = TreeAlgorithmItem(alg)
                        recentItem.addChild(algItem)
                        found = True
                if found:
                    self.algorithmTree.insertTopLevelItem(0, recentItem)
                    recentItem.setExpanded(True)

            self.algorithmTree.setWordWrap(True)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    def showCompletion(self, rows):
        # Rows is an iterable of tuples like [("text",object1),("text2", object2),...]
        pal = self.editor.palette()
        color = pal.color(QPalette.Disabled, QPalette.WindowText)

        self.popup.setUpdatesEnabled(False)
        self.popup.clear()
        if rows is None or len( rows ) < 1:
            return

        for row in rows:
            item = QTreeWidgetItem(self.popup)
            item.setText(0, row[0])
            #item.setText(1, hit['type'])
            item.setTextAlignment(1, Qt.AlignRight)
            item.setForeground(1, color)
            item.setData(2, Qt.UserRole, (row[1],)) # Try immutable py obj #http://stackoverflow.com/questions/9257422/how-to-get-the-original-python-data-from-qvariant

        self.popup.setCurrentItem(self.popup.topLevelItem(0))
        self.popup.resizeColumnToContents(0)
        #self.popup.resizeColumnToContents(1)
        self.popup.adjustSize()
        self.popup.setUpdatesEnabled(True)

        h = self.popup.sizeHintForRow(0) * min(15, len(rows)) + 3
        w = max(self.popup.width(), self.editor.width())
        self.popup.resize(w, h)

        self.popup.move(self.editor.mapToGlobal(QPoint(0, self.editor.height())))
        self.popup.setFocus()
        self.popup.show()

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    def on_btnLoad_clicked(self):
        fileName, _ = QFileDialog.getOpenFileName(None,
                                                  self.tr('Import Colors and elevations from XML'),
                                                  QDir.homePath(),
                                                  self.tr('XML files (*.xml *.XML)'))
        if fileName == '':
            return

        doc = QDomDocument()
        with codecs.open(fileName, 'r', encoding='utf-8') as f:
            content = f.read()

        if not doc.setContent(content):
            QMessageBox.critical(None,
                                 self.tr('Error parsing XML'),
                                 self.tr('The XML file could not be loaded'))
            return

        self.reliefClassTree.clear()
        reliefColorList = doc.elementsByTagName('ReliefColor')
        for i in range(reliefColorList.length()):
            elem = reliefColorList.at(i).toElement()
            item = QTreeWidgetItem()
            item.setText(0, elem.attribute('MinElevation'))
            item.setText(1, elem.attribute('MaxElevation'))
            item.setBackground(2, QBrush(QColor(int(elem.attribute('red')),
                                                int(elem.attribute('green')),
                                                int(elem.attribute('blue')))))
            self.reliefClassTree.addTopLevelItem(item)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    def __init__(self):
        super(ScriptSelector, self).__init__(None)
        self.setupUi(self)

        self.scripts = None

        allScripts = defaultdict(list)
        alglist = algList.getProviderFromName("script").algs
        for script in alglist:
            allScripts[script.group].append(script)

        for group, groupScripts in list(allScripts.items()):
            groupItem = QTreeWidgetItem()
            groupItem.setText(0, group)
            groupItem.setFlags(groupItem.flags() | Qt.ItemIsTristate)
            for script in groupScripts:
                scriptItem = QTreeWidgetItem()
                scriptItem.setFlags(scriptItem.flags() | Qt.ItemIsUserCheckable)
                scriptItem.setCheckState(0, Qt.Checked)
                scriptItem.script = script
                scriptItem.setText(0, script.name)
                groupItem.addChild(scriptItem)
            self.scriptsTree.addTopLevelItem(groupItem)

        self.scriptsTree.expandAll()

        self.selectAllLabel.linkActivated.connect(lambda: self.checkScripts(True))
        self.unselectAllLabel.linkActivated.connect(lambda: self.checkScripts(False))

        self.folderButton.clicked.connect(self.selectFolder)

        self.buttonBox.accepted.connect(self.okPressed)
        self.buttonBox.rejected.connect(self.cancelPressed)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
 def populateColors(self, colors):
     self.reliefClassTree.clear()
     for c in colors:
         item = QTreeWidgetItem()
         item.setText(0, str(c.minElevation))
         item.setText(1, str(c.maxElevation))
         item.setBackground(2, QBrush(c.color))
         self.reliefClassTree.addTopLevelItem(item)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
 def _getItem(self, name, icon, params):
     icon = QIcon(icon)
     item = QTreeWidgetItem()
     item.setText(0, name)
     item.setIcon(0, icon)
     for param in params:
         subItem = TreeSettingItem(item, self.tree, name, param)
         item.addChild(subItem)
     return item

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    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 + "&nbsp;&nbsp;&nbsp;&nbsp;<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)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
 def fillTree(self):
     self.tree.clear()
     entries = ProcessingLog.getLogEntries()
     groupItem = QTreeWidgetItem()
     groupItem.setText(0, 'ALGORITHM')
     groupItem.setIcon(0, self.groupIcon)
     for entry in entries:
         item = TreeLogEntryItem(entry, True)
         item.setIcon(0, self.keyIcon)
         groupItem.insertChild(0, item)
     self.tree.addTopLevelItem(groupItem)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
 def setValue(self, value):
     self.reliefClassTree.clear()
     rows = value.split(';')
     for r in rows:
         v = r.split(',')
         item = QTreeWidgetItem()
         item.setText(0, v[0])
         item.setText(1, v[1])
         color = QColor(int(v[2]), int(v[3]), int(v[4]))
         item.setBackground(2, QBrush(color))
         self.reliefClassTree.addTopLevelItem(item)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
 def fillTree(self):
     self.tree.clear()
     elements = ProcessingLog.getLogEntries()
     for category in list(elements.keys()):
         groupItem = QTreeWidgetItem()
         groupItem.setText(0, category)
         groupItem.setIcon(0, self.groupIcon)
         for entry in elements[category]:
             item = TreeLogEntryItem(entry, category == ProcessingLog.LOG_ALGORITHM)
             item.setIcon(0, self.keyIcon)
             groupItem.insertChild(0, item)
         self.tree.addTopLevelItem(groupItem)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
 def fillInputsTree(self):
     icon = QIcon(os.path.join(pluginPath, 'images', 'input.png'))
     parametersItem = QTreeWidgetItem()
     parametersItem.setText(0, self.tr('Parameters'))
     for paramType in ModelerParameterDefinitionDialog.paramTypes:
         paramItem = QTreeWidgetItem()
         paramItem.setText(0, paramType)
         paramItem.setIcon(0, icon)
         paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
         parametersItem.addChild(paramItem)
     self.inputsTree.addTopLevelItem(parametersItem)
     parametersItem.setExpanded(True)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    def fillTree(self):
        allLessons = defaultdict(list)
        for lesson in lessons:
            allLessons[lesson.group].append(lesson)

        self.lessonsTree.clear()
        lessonIcon = QIcon(os.path.dirname(__file__) + "/lesson.gif")
        for group, groupLessons in list(allLessons.items()):
            groupItem = QTreeWidgetItem()
            groupItem.setText(0, group)
            groupItem.description = groups.get(group, "")
            for lesson in groupLessons:
                lessonItem = QTreeWidgetItem()
                lessonItem.lesson = lesson
                lessonItem.setText(0, lesson.name)
                lessonItem.setIcon(0, lessonIcon)
                groupItem.addChild(lessonItem)
                if lesson.version[0] is not None and str(lesson.version[0]) > QGis.QGIS_VERSION:
                    lessonItem.setText(0, lesson.name + " (requires QGIS >= {})".format(lesson.version[0]))
                    lessonItem.setDisabled(True)
                if lesson.version[1] is not None and str(lesson.version[1]) < QGis.QGIS_VERSION:
                    lessonItem.setText(0, lesson.name + " (requires QGIS <= {})".format(lesson.version[1]))
                    lessonItem.setDisabled(True)
            self.lessonsTree.addTopLevelItem(groupItem)

        self.lessonsTree.sortItems(0, 0)

        self.lessonsTree.expandAll()

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setText [as 别名]
    def fillAlgorithmTreeUsingProviders(self):
        self.algorithmTree.clear()
        text = str(self.searchBox.text())
        search_strings = text.split(' ')
        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.alg.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()]
                    else:
                        groupItem = QTreeWidgetItem()
                        name = alg.group()
                        groupItem.setText(0, name)
                        groupItem.setToolTip(0, name)
                        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())
                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)

        self.algorithmTree.sortItems(0, Qt.AscendingOrder)