Python QTreeWidgetItem.addChild方法代码示例

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

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import addChild [as 别名]
 def fillConflictsTree(self):
     topTreeItems = {}
     for c in self.conflicts:
         path = os.path.dirname(c.path)
         if path in topTreeItems:
             topItem = topTreeItems[path]
         else:
             topItem = QTreeWidgetItem()
             topItem.setText(0, path)
             topItem.setIcon(0, layerIcon)
             topTreeItems[path] = topItem
         conflictItem = ConflictItem(c)
         topItem.addChild(conflictItem)
     for item in list(topTreeItems.values()):
         self.conflictsTree.addTopLevelItem(item)

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

        self.actionSaveAll.setIcon(QgsApplication.getThemeIcon('/mActionFileSave.svg'))
        self.actionSaveSelected.setIcon(QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
        self.actionOpenTracker.setIcon(QgsApplication.getThemeIcon('/mActionHelpAPI.png'))

        self.actionSaveAll.triggered.connect(lambda: self.saveResults(True))
        self.actionSaveSelected.triggered.connect(lambda: self.saveResults(False))

        self.resultsTree.clear()

        results = report.results

        self.saveFailed(results)

        self.reopen = False

        allResults = defaultdict(list)
        for result in results:
            test = result.test
            allResults[test.group].append(result)

        for group, groupResults in list(allResults.items()):
            groupItem = QTreeWidgetItem()
            groupItem.setText(0, group)
            for result in groupResults:
                resultItem = QTreeWidgetItem()
                resultItem.result = result
                resultItem.setText(0, result.test.name)
                resultItem.setForeground(0, self.resultColor[result.status])
                groupItem.addChild(resultItem)
            self.resultsTree.addTopLevelItem(groupItem)

        self.resultsTree.expandAll()
        self.resultsTree.itemClicked.connect(self.itemClicked)
        self.resultsTree.customContextMenuRequested.connect(self.showPopupMenu)

        button = QPushButton("Re-open test selector");
        def _reopen():
            self.reopen = True
            self.close()
        button.clicked.connect(_reopen)

        self.buttonBox.addButton(button, QDialogButtonBox.ActionRole);

        self.buttonBox.rejected.connect(self.close)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import addChild [as 别名]
 def fillInputsTree(self):
     icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
     parametersItem = QTreeWidgetItem()
     parametersItem.setText(0, self.tr('Parameters'))
     sortedParams = sorted(QgsApplication.instance().processingRegistry().parameterTypes(), key=lambda pt: pt.name())
     for param in sortedParams:
         if param.flags() & QgsProcessingParameterType.ExposeToModeler:
             paramItem = QTreeWidgetItem()
             paramItem.setText(0, param.name())
             paramItem.setData(0, Qt.UserRole, param.id())
             paramItem.setIcon(0, icon)
             paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
             paramItem.setToolTip(0, param.description())
             parametersItem.addChild(paramItem)
     self.inputsTree.addTopLevelItem(parametersItem)
     parametersItem.setExpanded(True)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import addChild [as 别名]
    def fillAlgorithmTreeUsingProviders(self):
        self.algorithmTree.clear()
        text = unicode(self.searchBox.text())
        allAlgs = ModelerUtils.allAlgs
        for providerName in allAlgs.keys():
            name = 'ACTIVATE_' + providerName.upper().replace(' ', '_')
            if not ProcessingConfig.getSetting(name):
                continue
            groups = {}
            provider = allAlgs[providerName]
            algs = provider.values()

            # Add algorithms
            for alg in algs:
                if not alg.showInModeler or alg.allowOnlyOpenedLayers:
                    continue
                if alg.commandLineName() == self.alg.commandLineName():
                    continue
                if text == '' or text.lower() in alg.name.lower():
                    if alg.group in groups:
                        groupItem = groups[alg.group]
                    else:
                        groupItem = QTreeWidgetItem()
                        name = alg.i18n_group or 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,
                                     ModelerUtils.providers[providerName].getDescription())
                providerItem.setToolTip(0,
                                        ModelerUtils.providers[providerName].getDescription())
                providerItem.setIcon(0,
                                     ModelerUtils.providers[providerName].getIcon())
                for groupItem in groups.values():
                    providerItem.addChild(groupItem)
                self.algorithmTree.addTopLevelItem(providerItem)
                providerItem.setExpanded(text != '')
                for groupItem in groups.values():
                    if text != '':
                        groupItem.setExpanded(True)

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

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import addChild [as 别名]
    def __setupModelData(self):
        dsList = DataSourcesList().data_sources.values()
        groupInfoList = GroupsList().groups
        groupsItems = []
        groups = []
        for ds in dsList:
            if ds.group in groups:
                group_item = groupsItems[groups.index(ds.group)]
            else:
                group_item = QTreeWidgetItem()
                group_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.group)
                group_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
                group_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole, ds.category)
                group_item.setCheckState(self.COLUMN_VISIBILITY, Qt.Unchecked)

                groupInfo = groupInfoList.get(ds.group)
                if groupInfo is not None:
                    group_item.setIcon(self.COLUMN_GROUP_DS, QIcon(groupInfo.icon))
                else:
                    group_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.group + " (%s!)" % self.tr("group not found"))
                group_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole, groupInfo)

                groups.append(ds.group)
                groupsItems.append(group_item)
                self.rootItem.addChild(group_item)

            ds_item = QTreeWidgetItem()
            ds_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.alias)
            ds_item.setIcon(self.COLUMN_GROUP_DS, QIcon(ds.icon_path))
            ds_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole, ds)
            ds_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
            ds_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole, ds.category)

            ds_check_state = Qt.Checked
            if ds.id in PluginSettings.get_hide_ds_id_list():
                ds_check_state = Qt.Unchecked
            ds_item.setCheckState(self.COLUMN_VISIBILITY, ds_check_state)

            if group_item.childCount() != 0 and group_item.checkState(1) != ds_check_state:
                group_item.setCheckState(self.COLUMN_VISIBILITY, Qt.PartiallyChecked)
            else:
                group_item.setCheckState(self.COLUMN_VISIBILITY, ds_check_state)

            group_item.addChild(
                ds_item
            )

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import addChild [as 别名]
    def computeDiffs(self):
        self.commit1 = self.commit1Panel.getRef()
        self.commit2 = self.commit2Panel.getRef()

        self.featuresTree.clear()
        changes = execute(lambda: self.repo.diff(self.commit1.commitid, self.commit2.commitid))
        layerItems = {}
        layerSubItems = {}
        self.changes = {}
        for c in changes:
            self.changes[c.path] = c
            layername = c.path.split("/")[0]
            featureid = c.path.split("/")[-1]
            if layername not in layerItems:
                item = QTreeWidgetItem()
                item.setText(0, layername)
                item.setIcon(0, layerIcon)
                layerItems[layername] = item
                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[layername] = {FEATURE_ADDED: addedItem,
                                            FEATURE_REMOVED: removedItem,
                                            FEATURE_MODIFIED:modifiedItem}
            item = FeatureItem(layername, featureid)
            layerSubItems[layername][c.changetype].addChild(item)
        for layername, item in layerItems.iteritems():
            for i in [FEATURE_ADDED, FEATURE_REMOVED, FEATURE_MODIFIED]:
                subItem = layerSubItems[layername][i]
                item.addChild(subItem)
                subItem.setText(0, "%s [%i features]" %
                                                    (subItem.text(0),
                                                     subItem.childCount()))

            self.featuresTree.addTopLevelItem(item)
        self.attributesTable.clear()
        self.attributesTable.verticalHeader().hide()
        self.attributesTable.horizontalHeader().hide()
        
        self.featuresTree.expandAll()