Python QTreeWidgetItem.setIcon方法代码示例

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [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 setIcon [as 别名]
    def fillInputsTree(self):
        from processing.core.Processing import Processing

        icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
        parametersItem = QTreeWidgetItem()
        parametersItem.setText(0, self.tr('Parameters'))
        sortedParams = sorted(Processing.registeredParameters().items())
        for param in sortedParams:
            if param[1]['exposeToModeller']:
                paramItem = QTreeWidgetItem()
                paramItem.setText(0, param[1]['name'])
                paramItem.setData(0, Qt.UserRole, param[0])
                paramItem.setIcon(0, icon)
                paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
                paramItem.setToolTip(0, param[1]['description'])
                parametersItem.addChild(paramItem)
        self.inputsTree.addTopLevelItem(parametersItem)
        parametersItem.setExpanded(True)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setIcon [as 别名]
 def populateSchemas(self):
     if self.childCount() != 0:
         return
     settings = QSettings()
     connSettings = '/PostgreSQL/connections/' + self.connection
     database = settings.value(connSettings + '/database')
     user = settings.value(connSettings + '/username')
     host = settings.value(connSettings + '/host')
     port = settings.value(connSettings + '/port')
     passwd = settings.value(connSettings + '/password')
     uri = QgsDataSourceURI()
     uri.setConnection(host, str(port), database, user, passwd)
     connInfo = uri.connectionInfo()
     (success, user, passwd) = QgsCredentials.instance().get(connInfo, None, None)
     if success:
         QgsCredentials.instance().put(connInfo, user, passwd)
         geodb = GeoDB(host, int(port), database, user, passwd)
         schemas = geodb.list_schemas()
         for oid, name, owner, perms in schemas:
             item = QTreeWidgetItem()
             item.setText(0, name)
             item.setIcon(0, self.schemaIcon)
             self.addChild(item)

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

# 需要导入模块: from qgis.PyQt.QtWidgets import QTreeWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTreeWidgetItem import setIcon [as 别名]
class GetScriptsAndModelsDialog(BASE, WIDGET):

    HELP_TEXT = QCoreApplication.translate('GetScriptsAndModelsDialog',
                                           '<h3> Processing resources manager </h3>'
                                           '<p>Check/uncheck algorithms in the tree to select the ones that you '
                                           'want to install or remove</p>'
                                           '<p>Algorithms are divided in 3 groups:</p>'
                                           '<ul><li><b>Installed:</b> Algorithms already in your system, with '
                                           'the latest version available</li>'
                                           '<li><b>Updatable:</b> Algorithms already in your system, but with '
                                           'a newer version available in the server</li>'
                                           '<li><b>Not installed:</b> Algorithms not installed in your '
                                           'system</li></ul>')
    MODELS = 0
    SCRIPTS = 1
    RSCRIPTS = 2

    tr_disambiguation = {0: 'GetModelsAction',
                         1: 'GetScriptsAction',
                         2: 'GetRScriptsAction'}

    def __init__(self, resourceType):
        super(GetScriptsAndModelsDialog, self).__init__(iface.mainWindow())
        self.setupUi(self)
        self.manager = QgsNetworkAccessManager.instance()

        repoUrl = ProcessingConfig.getSetting(ProcessingConfig.MODELS_SCRIPTS_REPO)

        self.resourceType = resourceType
        if self.resourceType == self.MODELS:
            self.folder = ModelerUtils.modelsFolders()[0]
            self.urlBase = '{}/models/'.format(repoUrl)
            self.icon = QIcon(os.path.join(pluginPath, 'images', 'model.png'))
        elif self.resourceType == self.SCRIPTS:
            self.folder = ScriptUtils.scriptsFolders()[0]
            self.urlBase = '{}/scripts/'.format(repoUrl)
            self.icon = QIcon(os.path.join(pluginPath, 'images', 'script.png'))
        else:
            self.folder = RUtils.RScriptsFolders()[0]
            self.urlBase = '{}/rscripts/'.format(repoUrl)
            self.icon = QIcon(os.path.join(pluginPath, 'images', 'r.svg'))

        self.lastSelectedItem = None
        self.updateProvider = False
        self.populateTree()
        self.buttonBox.accepted.connect(self.okPressed)
        self.buttonBox.rejected.connect(self.cancelPressed)
        self.tree.currentItemChanged.connect(self.currentItemChanged)

    def popupError(self, error=None, url=None):
        """Popups an Error message bar for network errors."""
        disambiguation = self.tr_disambiguation[self.resourceType]
        widget = iface.messageBar().createMessage(self.tr('Connection problem', disambiguation),
                                                  self.tr('Could not connect to scripts/models repository', disambiguation))
        if error and url:
            QgsMessageLog.logMessage(self.tr(u"Network error code: {} on URL: {}").format(error, url), self.tr(u"Processing"), QgsMessageLog.CRITICAL)
            button = QPushButton(QCoreApplication.translate("Python", "View message log"), pressed=show_message_log)
            widget.layout().addWidget(button)

        iface.messageBar().pushWidget(widget, level=QgsMessageBar.CRITICAL, duration=5)

    def grabHTTP(self, url, loadFunction, arguments=None):
        """Grab distant content via QGIS internal classes and QtNetwork."""
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        request = QUrl(url)
        reply = self.manager.get(QNetworkRequest(request))
        if arguments:
            reply.finished.connect(partial(loadFunction, reply, arguments))
        else:
            reply.finished.connect(partial(loadFunction, reply))

    def populateTree(self):
        self.uptodateItem = QTreeWidgetItem()
        self.uptodateItem.setText(0, self.tr('Installed'))
        self.toupdateItem = QTreeWidgetItem()
        self.toupdateItem.setText(0, self.tr('Updatable'))
        self.notinstalledItem = QTreeWidgetItem()
        self.notinstalledItem.setText(0, self.tr('Not installed'))
        self.toupdateItem.setIcon(0, self.icon)
        self.uptodateItem.setIcon(0, self.icon)
        self.notinstalledItem.setIcon(0, self.icon)
        self.grabHTTP(self.urlBase + 'list.txt', self.treeLoaded)

    def treeLoaded(self, reply):
        """
        update the tree of scripts/models whenever
        HTTP request is finished
        """
        QApplication.restoreOverrideCursor()
        if reply.error() != QNetworkReply.NoError:
            self.popupError(reply.error(), reply.request().url().toString())
        else:
            resources = unicode(reply.readAll()).splitlines()
            resources = [r.split(',') for r in resources]
            self.resources = {f: (v, n) for f, v, n in resources}
            for filename, version, name in sorted(resources, key=lambda kv: kv[2].lower()):
                treeBranch = self.getTreeBranchForState(filename, float(version))
                item = TreeItem(filename, name, self.icon)
                treeBranch.addChild(item)
                if treeBranch != self.notinstalledItem:
#.........这里部分代码省略.........