python类QTreeWidgetItem()的实例源码

def main(): 
    app     = QApplication (sys.argv)
    tree    = QTreeWidget ()
    headerItem  = QTreeWidgetItem()
    item    = QTreeWidgetItem()

    for i in range(3):
        parent = QTreeWidgetItem(tree)
        parent.setText(0, "Parent {}".format(i))
        parent.setFlags(parent.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)
        for x in range(5):
            child = QTreeWidgetItem(parent)
            child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
            child.setText(0, "Child {}".format(x))
            child.setCheckState(0, Qt.Unchecked)
    tree.show() 
    sys.exit(app.exec_())

def add_cpu_sensors(self):
        """Add selected temperature sensor(s) to the "Selected CPU sensor(s)" three widget."""

        items = [item for item in self.ui.treeWidgetHWMonData.selectedItems()]

        # The new items should have the tree widget itself as parent
        parent = self.ui.treeWidgetSelectedCPUSensors

        for item in items:
            sensor_item = QtWidgets.QTreeWidgetItem(parent)
            sensor_item.setText(0, item.text(0))
            sensor_item.setText(1, item.text(1))
            sensor_item.setForeground(0, QtGui.QBrush(QtCore.Qt.blue))  # Text color blue

        # Deselect all items in the HWMon tree widget after they have been added
        self.ui.treeWidgetHWMonData.clearSelection()

def tree_widget(self, tree, structure):
        """
        Used to traverse a QTreeWidget and adding the items in a
        dict or list.

        :param tree: pass a QTreeWidget instance
        :param structure: pass a dictionary
        """
        if type(structure) is dict:
            for key, val in structure.items():
                child = QTreeWidgetItem()
                child.setText(0, key)
                tree.addChild(child)
                self.tree_widget(child, val)
        elif type(structure) is str:
            child = QTreeWidgetItem()
            child.setText(0, structure)
            tree.addChild(child)
        elif isinstance(structure, QWidget):
            self.index += 1
            tree.setText(1, str(self.index))
            self.display.addWidget(structure)

def add_cpu_sensors(self):
        """Add selected temperature sensor(s) to the "Selected CPU sensor(s)" three widget."""

        items = [item for item in self.treeWidgetHWMonData.selectedItems()]

        # The new items should have the tree widget itself as parent
        parent = self.treeWidgetSelectedCPUSensors

        for item in items:
            sensor_item = QtWidgets.QTreeWidgetItem(parent)
            sensor_item.setText(0, item.text(0))
            sensor_item.setText(1, item.text(1))
            sensor_item.setForeground(0, QtGui.QBrush(QtCore.Qt.blue))  # Text color blue

        # Deselect all items in the HWMon tree widget after they have been added
        self.treeWidgetHWMonData.clearSelection()

def update(self):
        # Update files.
        self._ui.project_tree.clear()
        items = []
        icon_provider = QFileIconProvider()

        for cur_file in self.project.files:
            file_info = QFileInfo(cur_file)
            item = QTreeWidgetItem(None, [
                os.path.relpath(cur_file, self.project.proj_dir), 
                "N/A",
            ])
            item.setData(0, Qt.UserRole, Project.file_to_idb(cur_file))
            item.setIcon(0, icon_provider.icon(file_info))
            items.append(item)

        self._ui.project_tree.insertTopLevelItems(0, items)

        # Update other stuff.
        self._ui.project_path.setText(self.project.proj_dir)

def discoverWorkers(self):
        """Discover new workers via udp broadcasts"""
        rlist, wlist, elist = select([self.discoverysocket], [], [], 0)
        if rlist:
            received = self.discoverysocket.recvfrom(4096)[0]
            discoverydata = {}
            try:
                discoverydata = json.loads(bytes.decode(received))
            except json.JSONDecodeError:
                pass

            if "ip" in discoverydata and "port" in discoverydata:
                if "host" in discoverydata:
                    name = discoverydata["host"]
                else:
                    name = discoverydata["ip"] + ":" + str(discoverydata["port"])
                if name not in self.workers:
                    treeItem = QTreeWidgetItem(1001)    # Type 1000 for Worker Item
                    treeItem.setText(0, name)
                    self.treeWidget.addTopLevelItem(treeItem)
                    self.grabPeriodicInfos()    # Grab monitor data
                    self.workers[name] = Worker(discoverydata, treeItem, nodeDataJar=self.nodeDataJar)
                    self.workers[name].tick(self.sheetDeltaMemory)
                    self.workers[name].synchronize()

def replyMonitors(self, msg):
        """Handle reply to monitors request"""
        self.monitors = msg["replydata"]

        for monitor in self.monitors:
            if monitor not in self.monitorState:    # Monitor is newly available
                self.monitorState[monitor] = {}
                self.monitorState[monitor]["treeItem"] = QTreeWidgetItem(1002)  # Type 1002 for monitor item
                self.monitorState[monitor]["treeItem"].setText(0, monitor)
                self.monitorState[monitor]["treeItem"].setIcon(0, self.monitorOkIcon)
                self.treeItem.addChild(self.monitorState[monitor]["treeItem"])
                self.treeItem.setExpanded(True)
                self.monitorState[monitor]["state"] = "stop"
                self.monitorState[monitor]["sheet"] = None
        for monitor in self.monitorState:
            if monitor not in self.monitors:    # Monitor exists in state, but is not available anymore
                self.monitorState[monitor]["state"] = "gone"
                self.monitorState[monitor]["treeItem"].setIcon(0, self.monitorGoneIcon)

        # TODO: Set sheet item state here (blue for active, but no sheet, red for gone, black for all good)

def selectNode(self, position, inType:type=None, outType:type=None):
        if self.searchAndCompareModules():
            for nodeName in self.availableNodes:
                if self.availableNodes[nodeName].placeable:
                    returnItem = self.checkOrCreateCategory(self.availableNodes[nodeName].Category, self.ui.treeWidget)
                    newItem = QTreeWidgetItem(1002)  # Type 1002 for modules
                    newItem.setText(0, self.availableNodes[nodeName].name)
                    returnItem.addChild(newItem)
                    newItem.setData(1, Qt.UserRole, nodeName)

        self.exec()

        if len(self.ui.treeWidget.selectedItems()) == 1:
            selectedItem = self.ui.treeWidget.selectedItems()[0]
            selectedItem.setSelected(False)
            if selectedItem.data(1, Qt.UserRole) in self.availableNodes:
                classToSpawn = self.availableNodes[selectedItem.data(1, Qt.UserRole)]
                newNode = classToSpawn()
                newNode.sendMessageCallback = self.sendMessageCallback

                if self.scene is not None:
                    self.scene.undostack.push(AddNodeToSceneCommand(newNode, position, self.scene))

def checkOrCreateCategory(self, categories, treeWidget):
        """Recursively add category folders to treeWidget unless they already exist"""
        currentItem = None
        currentCatTree = self.categoryTree
        for category in categories:
            if category in currentCatTree:
                currentItem = currentCatTree[category][0]
                currentCatTree = currentCatTree[category][1]
            else:
                newItem = QTreeWidgetItem(1001)     # Type 1001 for categories
                newItem.setText(0, category)
                if currentItem is None:
                    treeWidget.addTopLevelItem(newItem)
                else:
                    currentItem.addChild(newItem)
                currentItem = newItem
                currentCatTree[category] = [newItem, {}]
                currentCatTree = currentCatTree[category][1]
        return currentItem

def __init__(self, parent):
        self.parent = parent

        self.workerAccepted = False     # Whether or not the worker accepted the controller
        self.workerTreeItem = QTreeWidgetItem()

        self.monitorState = {}

        self.inbuf = ""
        self.connection = None

        self.requestJar = {}

        # Refresh monitors every 5 seconds
        self.monitorTimer = QTimer()
        self.monitorTimer.timeout.connect(self.requestMonitors)
        self.monitorTimer.start(5000)

        #
        self.errorIcon = QIcon("resources/icons/exclamation.png")

def loadWorkers(self, loadData):
        for workerData in loadData:
            newWorker = Worker(self)
            newconn = Connection(workerData[0], workerData[1], newWorker.messagecallback)
            newWorker.connection = newconn
            if not newconn.valid:
                newWorker.createTreeitem()
                newWorker.connectionLost()

            self.connections[newconn.socket] = (newconn, newWorker)

            for state in workerData[2]:
                newWorker.monitorState[state[0]] = {}
                newWorker.monitorState[state[0]]["state"] = state[1]

                monitorTreeitem = QTreeWidgetItem()
                monitorTreeitem.setText(0, state[0])
                newWorker.workerTreeItem.addChild(monitorTreeitem)
                newWorker.monitorState[state[0]]["treeitem"] = monitorTreeitem

                newWorker.monitorState[state[0]]["sheet"] = newWorker.parent.sheethandler.newMonitorSheet(str(newWorker.connection.ip) + ":" + str(newWorker.connection.port) + " - " + state[0], monitorTreeitem)
                newWorker.monitorState[state[0]]["sheet"].relations = state[2]

def add_product(self, pname, cname, _):
        """ Add product

        :param str pname: Product name
        :param str cname: Category name
        """
        cat_widget = None
        for widget in self.categories:
            if widget.text(0) == cname:
                cat_widget = widget
        if not cat_widget:
            cat_widget = QtWidgets.QTreeWidgetItem(self, [cname])
            self.categories.append(cat_widget)

        pro_widget = QtWidgets.QTreeWidgetItem(cat_widget, [pname])
        self.products.append(pro_widget)

def add_category(self, name, id_):
        """ Add product category to product list.
        This function can't add product to database.

        :param str name: Category name
        :param int id_: Category id
        """
        cat_widget = QtWidgets.QTreeWidgetItem(self, [name])
        self.categories.append(cat_widget)
        for prod in api.products.get(category=id_):
            self.add_product(prod['name'], name, prod['percentage'])


#
# Category
#

def make_entry(self,root,text,true_false):
        depth=0
        pointer=root
        for depth in range(0,len(text)):
            found=False
            for i in range(0,pointer.childCount()):
                if pointer.child(i).text(0)==text[depth]:
                    found=True
                    pointer=pointer.child(i)
                    break
            if found==False:
                pointer=QTreeWidgetItem(pointer, [text[depth]])
                pointer.setFlags(pointer.flags() | Qt.ItemIsUserCheckable)
                #if depth==0:
                #   pointer.setIcon(0,QIcon_load("folder"))

                if true_false==True:
                    pointer.setCheckState(0, Qt.Checked ) 
                else:
                    pointer.setCheckState(0, Qt.Unchecked )

def addFileListItem(self, filelist_item, filelist):
        for myfile in filelist:
            if isinstance(myfile, myfunc.FileList):
                _filelist_item = QtWidgets.QTreeWidgetItem(filelist_item)
                _filelist_item.setFlags(_filelist_item.flags() | QtCore.Qt.ItemIsTristate | QtCore.Qt.ItemIsUserCheckable)
                _filelist_item.setText(0, myfile.name)
                size = self.getSizeUnit(myfile.size)
                _filelist_item.setText(1, size)
                _filelist_item.setText(2, myfile.file_path)
                _filelist_item.setCheckState(0, QtCore.Qt.Checked)
                self.addFileListItem(_filelist_item, myfile)
                continue
            file_item = QtWidgets.QTreeWidgetItem(filelist_item)
            file_item.setFlags(file_item.flags() | QtCore.Qt.ItemIsUserCheckable)
            file_item.setText(0, myfile.name)
            size = self.getSizeUnit(myfile.size)
            file_item.setText(1, size)
            file_item.setText(2, myfile.file_path)
            file_item.setCheckState(0, QtCore.Qt.Checked)

def DataToTree(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and not self.DataChildCheck(sub_data[1], filter):
                    pass
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree_old_2LevelSearch(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and len(sub_data[1]) == 0:
                    #print(sub_data[0][0]) print(sub_data[1])
                    pass    
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and not self.DataChildCheck(sub_data[1], filter):
                    pass
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree_old_2LevelSearch(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and len(sub_data[1]) == 0:
                    #print(sub_data[0][0]) print(sub_data[1])
                    pass    
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def DataToTree(self, tree, cur_node, data, filter=''):
        node_info = data[0]
        node_info_child = data[1]
        [cur_node.setText(i, node_info[i]) for i in range(len(node_info))]
        target = re.compile(filter, re.IGNORECASE)
        for sub_data in node_info_child:
            if filter == '':
                new_node = QtWidgets.QTreeWidgetItem()
                cur_node.addChild(new_node)
                self.DataToTree(tree, new_node, sub_data)
            else:
                if not target.search(sub_data[0][0]) and not self.DataChildCheck(sub_data[1], filter):
                    pass
                else:
                    new_node = QtWidgets.QTreeWidgetItem()
                    cur_node.addChild(new_node)
                    new_node.setExpanded(1)
                    self.DataToTree(tree, new_node, sub_data, filter)

def setupUi(self, Master):
        Master.setObjectName("Master")
        Master.resize(718, 477)
        self.verticalLayout = QtWidgets.QVBoxLayout(Master)
        self.verticalLayout.setObjectName("verticalLayout")
        self.splitter = QtWidgets.QSplitter(Master)
        self.splitter.setOrientation(QtCore.Qt.Vertical)
        self.splitter.setObjectName("splitter")
        self.tab_widget = QtWidgets.QTabWidget(self.splitter)
        self.tab_widget.setObjectName("tab_widget")

        self.docker = QtWidgets.QDockWidget(self.splitter)
        self.docker.setObjectName("docker")
        self.docker.setAllowedAreas(QtCore.Qt.BottomDockWidgetArea)

        self.log_widget = QtWidgets.QTreeWidget(self.docker)
        self.log_widget.setHeaderItem(QtWidgets.QTreeWidgetItem(["date", "origin", "type", "message"]))
        self.docker.setWidget(self.log_widget)

        self.verticalLayout.addWidget(self.splitter)
        self.tab_widget.setCurrentIndex(-1)
        QtCore.QMetaObject.connectSlotsByName(Master)
        Master.setWindowTitle("IDASec")

def add_gpu_sensors(self):
        """Add selected temperature sensor(s) to the "Selected GPU sensor(s)" three widget."""
        items = [item for item in self.ui.treeWidgetHWMonData.selectedItems()]

        # The new items should have the tree widget itself as parent
        parent = self.ui.treeWidgetSelectedGPUSensors

        for item in items:
            sensor_item = QtWidgets.QTreeWidgetItem(parent)
            sensor_item.setText(0, item.text(0))
            sensor_item.setText(1, item.text(1))
            sensor_item.setForeground(0, QtGui.QBrush(QtCore.Qt.blue))  # Text color blue

        # Deselect all items in the HWMon tree widget after they have been added
        self.ui.treeWidgetHWMonData.clearSelection()

def add_gpu_sensors(self):
        """Add selected temperature sensor(s) to the "Selected GPU sensor(s)" three widget."""
        items = [item for item in self.treeWidgetHWMonData.selectedItems()]

        # The new items should have the tree widget itself as parent
        parent = self.treeWidgetSelectedGPUSensors

        for item in items:
            sensor_item = QtWidgets.QTreeWidgetItem(parent)
            sensor_item.setText(0, item.text(0))
            sensor_item.setText(1, item.text(1))
            sensor_item.setForeground(0, QtGui.QBrush(QtCore.Qt.blue))  # Text color blue

        # Deselect all items in the HWMon tree widget after they have been added
        self.treeWidgetHWMonData.clearSelection()

def populate_tree_linux(treeWidget):
    import psutil
    hardwares = psutil.sensors_temperatures()

    # No sensor data (empty list) indicates OpenHWMon is not running
    if not hardwares:
        return

    # Add hardware nodes and temperature sensors to the three widget
    for key, nodelist in hardwares.items():
        item_list = []
        parent = treeWidget
        item = QtWidgets.QTreeWidgetItem(parent)
        item.setText(0, key)  # First column, name of the node
        item.setText(1, key)  # Second column, node id
        item.setFlags(QtCore.Qt.ItemIsEnabled)  # Make hardware nodes "not selectable" in the UI
        for index, node in enumerate(nodelist):
            parent = item
            itema = QtWidgets.QTreeWidgetItem(parent)
            if not node.label:
                name = key
            else:
                name = node.label
            itema.setText(0, name)  # First column, name of the node
            itema.setText(1, name)  # Second column, node id
            itema.setText(2, str(node.current))  # Third column, temperature value
            itema.setForeground(0, QtGui.QBrush(QtCore.Qt.blue))
            itema.setForeground(2, QtGui.QBrush(QtCore.Qt.blue))

def newOtherSheet(self):
        newName = self.sheetWidget.newSheetLineedit.text()
        for sheet in self.sheets:   # Prevent duplicate names
            if newName == sheet.name:
                return
        if len(newName) > 0:
            newTreeitem = QTreeWidgetItem()
            newTreeitem.setText(0, newName)
            self.sheetWidget.sheetTree.addTopLevelItem(newTreeitem)

            self.sheets.append(Sheet(newName, newTreeitem))
            self.itemClickedOther(newTreeitem, -1) # Make new sheet current
            self.sheetWidget.sheetTree.setCurrentItem(newTreeitem)

def loadSheets(self, sheetData):
        for sheet in sheetData:
            newTreeitem = QTreeWidgetItem()
            newTreeitem.setText(0, sheet[0])
            self.sheetWidget.sheetTree.addTopLevelItem(newTreeitem)

            newSheet = Sheet(sheet[0], newTreeitem)
            newSheet.relations = sheet[1]
            newSheet.monitorSheet = sheet[2]
            self.sheets.append(newSheet)
            self.itemClickedOther(newTreeitem, -1)  # Make new sheet current
            self.sheetWidget.sheetTree.setCurrentItem(newTreeitem)

def load_list(self, mails):
        """ Load notes and display them in the list

        :param list mails: Preselected mails
        """
        for note in api.notes.get():
            widget = QtWidgets.QTreeWidgetItem(self.mail_list, (
                note['nickname'],
                note['mail'],
                note['firstname'],
                note['lastname']
            ))
            if note['mail'] in mails:
                widget.setSelected(True)

def __init__(self):
        super().__init__()
        uic.loadUi('ui/admin_stats_window.ui', self)
        nb_red, red = api.stats.get_red_sum()
        nb_green, green = api.stats.get_green_sum()
        self.red_label.setText("{:.2f} € ({})".format(red, nb_red))
        self.green_label.setText("{:.2f} € ({})".format(green, nb_green))
        self.total_label.setText("{:.2f} € ({})".format(green + red, nb_red + nb_green))
        self.ecocups_nb_label.setText(str(api.stats.get_ecocups_nb()))
        for note, value in api.stats.get_red_notes():
            QtWidgets.QTreeWidgetItem(self.red_notes, [note, "{:.2f}".format(value)])
        self.show()

def _build_recap(self):
        """ Parse a CSV file and try to build lines from it.
        """
        with open(self.file_path, 'r') as fd:
            reader = csv.DictReader(fd)
            for line in reader:
                mail = line.get('Mail')
                if mail:
                    mail = mail.lower()
                note = api.notes.get(lambda x: x['mail'] == mail)
                if note and not note[0]['hidden']:
                    note = note[0]['nickname']
                    self.notes.append(note)
                else:
                    note = None
                if note:
                    QtWidgets.QTreeWidgetItem(
                        self.recap,
                        (note,
                         mail
                        )
                    )
                else:
                    w = QtWidgets.QTreeWidgetItem(
                        self.recap,
                        ("[{} {}]".format(line["Nom"], line["Prénom"]),
                         mail
                        )
                    )
                    for i in range(2):
                        w.setBackground(i, QtCore.Qt.red)

def add_product(self, cname, pname, price_name, price):
        """ Add product to list

        :param str cname: Category name
        :param str pname: Product name
        :param str price_name: Price name
        :param float price: Price value
        """
        name = "{} ({}) - {}".format(pname, price_name, cname)
        for product in self.products:
            if product['name'] == name:
                product['price'] += price
                product['price'] = product['price']
                product['count'] += 1
                product['widget'].setText(0, str(product['count']))
                product['widget'].setText(2, str(round(product['price'], 2)))
                break
        else:
            product = {
                'name': name,
                'price': price,
                'count': 1,
                'category': cname,
                'product': pname,
                'price_name': price_name,
                'deletable': False if pname == settings.ECOCUP_NAME else True,
            }
            widget = QtWidgets.QTreeWidgetItem(['1', name, str(price)])
            self.addTopLevelItem(widget)
            product['widget'] = widget
            self.products.append(product)
        self.update_total()