python类QStandardItem()的实例源码

def ThreadEvent_OnLoadBiocPackageCompleted(self, packagelist):
        self.model_package.removeRows(0, self.model_package.rowCount())
        for pkg in packagelist:
            itemName = QStandardItem(pkg['Name'])
            itemName.setCheckable(True)
            itemTitle = QStandardItem(pkg['Title'])
            self.model_package.appendRow([itemName, itemTitle])

        # Apply the model to the list view
        self.lstPackages.setModel(self.package_list_proxy)
        #self.lstPackages.resizeColumnToContents(0)
        self.lstPackages.setColumnWidth(0, 190)
        self.lstPackages.setColumnWidth(1, 130)

def buildEntitiesTree(self, entities_list):
        """
        This method populates the Entities (blocks) QTreeView with
        all the elements contained in the entities_list
        Method must be called each time a new .dxf file is loaded.
        options
        @param entities_list: list of the layers and shapes (created in the main)
        """

        self.entities_list = entities_list
        if self.entity_item_model:
            self.entity_item_model.clear()  # Remove any existing item_model
        self.entity_item_model = QStandardItemModel()
        self.entity_item_model.setHorizontalHeaderItem(0, QStandardItem(self.tr("[en]")))
        self.entity_item_model.setHorizontalHeaderItem(1, QStandardItem(self.tr("Name")))
        self.entity_item_model.setHorizontalHeaderItem(2, QStandardItem(self.tr("Nr")))
        self.entity_item_model.setHorizontalHeaderItem(3, QStandardItem(self.tr("Type")))
        self.entity_item_model.setHorizontalHeaderItem(4, QStandardItem(self.tr("Base point")))
        self.entity_item_model.setHorizontalHeaderItem(5, QStandardItem(self.tr("Scale")))
        self.entity_item_model.setHorizontalHeaderItem(6, QStandardItem(self.tr("Rotation")))
        modele_root_element = self.entity_item_model.invisibleRootItem()

        self.buildEntitiesSubTree(modele_root_element, entities_list)

        # Signal to get events when a checkbox state changes (enable or disable shapes)
        self.entity_item_model.itemChanged.connect(self.on_itemChanged)

        self.ui.entitiesTreeView.setModel(self.entity_item_model)

        self.ui.entitiesTreeView.expandToDepth(0)

        for i in range(6):
            self.ui.entitiesTreeView.resizeColumnToContents(i)

def updateGUI(self):
        self.model.clear()
        if self.ui.showTalente.isChecked():
            for itm in self.datenbank.talente:
                item = QtGui.QStandardItem(itm + " : Talent")
                item.setEditable(False)
                self.model.appendRow(item)
        if self.ui.showVorteile.isChecked():
            for itm in self.datenbank.vorteile:
                item = QtGui.QStandardItem(itm + " : Vorteil")
                item.setEditable(False)
                self.model.appendRow(item) 
        if self.ui.showFertigkeiten.isChecked():
            for itm in self.datenbank.fertigkeiten:
                item = QtGui.QStandardItem(itm + " : Fertigkeit")
                item.setEditable(False)
                self.model.appendRow(item) 
        if self.ui.showUebernatuerlicheFertigkeiten.isChecked():
            for itm in self.datenbank.übernatürlicheFertigkeiten:
                item = QtGui.QStandardItem(itm + " : Übernatürliche Fertigkeit")
                item.setEditable(False)
                self.model.appendRow(item) 
        if self.ui.showWaffen.isChecked():
            for itm in self.datenbank.waffen:
                item = QtGui.QStandardItem(itm + " : Waffe")
                item.setEditable(False)
                self.model.appendRow(item) 
        self.ui.listDatenbank.setModel(self.model)

def set_server_mgr(self, server_mgr):
        self.server_mgr = server_mgr
        self.nodesets = []
        self.model.clear()
        self.model.setHorizontalHeaderLabels(['Node Sets'])
        item = QStandardItem("Opc.Ua.NodeSet2.xml")
        item.setFlags(Qt.NoItemFlags)
        self.model.appendRow([item])
        self.view.expandAll()

def add_namespace(self):
        uries = self.node.get_value()
        newidx = len(uries)
        it = self.model.item(0, 0)
        uri_it = QStandardItem("")
        it.appendRow([QStandardItem(), QStandardItem(str(newidx)), uri_it])
        idx = self.model.indexFromItem(uri_it)
        self.view.edit(idx)

def show_array(self):
        self.model.setHorizontalHeaderLabels(['Browse Name', 'Index', 'Value'])

        name_item = QStandardItem(self.node.get_browse_name().Name)
        self.model.appendRow([name_item, QStandardItem(""), QStandardItem()])
        it = self.model.item(0, 0)
        val = self.node.get_value()
        for idx, url in enumerate(val):
            it.appendRow([QStandardItem(), QStandardItem(str(idx)), QStandardItem(url)])
        self.view.expandAll()

def add_item(self):
        self.model.appendRow(QStandardItem('Hello , world!!'))

def Update_Server_Status(self, data):
        self.status_model.clear()

        for status in data:
            loc = ""
            for locale in status[ServerLocales]:
                loc += "%s, " % locale

            game = QtGui.QStandardItem(status[ServerServices][0]["status"])
            game.setForeground(QtGui.QBrush(QtGui.QColor(28, 196, 2)) if status[ServerServices][0]["status"] == "online" else QtGui.QBrush(QtGui.QColor(255, 0, 0)))

            store = QtGui.QStandardItem(status[ServerServices][1]["status"])
            store.setForeground(QtGui.QBrush(QtGui.QColor(28, 196, 2)) if status[ServerServices][1]["status"] == "online" else QtGui.QBrush(QtGui.QColor(255, 0, 0)))

            website = QtGui.QStandardItem(status[ServerServices][2]["status"])
            website.setForeground(QtGui.QBrush(QtGui.QColor(28, 196, 2)) if status[ServerServices][2]["status"] == "online" else QtGui.QBrush(QtGui.QColor(255, 0, 0)))

            client = QtGui.QStandardItem(status[ServerServices][3]["status"])
            client.setForeground(QtGui.QBrush(QtGui.QColor(28, 196, 2)) if status[ServerServices][3]["status"] == "online" else QtGui.QBrush(QtGui.QColor(255, 0, 0)))

            client_update = QtGui.QStandardItem(status[ServerServices][4]["status"])
            client_update.setForeground(QtGui.QBrush(QtGui.QColor(28, 196, 2)) if status[ServerServices][4]["status"] == "online" else QtGui.QBrush(QtGui.QColor(255, 0, 0)))

            self.status_model.appendRow([QtGui.QStandardItem(status[ServerName]), 
                                        QtGui.QStandardItem(status[ServerHostName]), 
                                        QtGui.QStandardItem(status[ServerSlug]),
                                        game,
                                        store,
                                        website,
                                        client,
                                        client_update,
                                        QtGui.QStandardItem(loc)
                                    ])

        self.status_model.setHorizontalHeaderLabels(["Name", "Host Name", "Slug", "Game", "Store", "Website", "Client", "Client Update", "Locales"])

        self.serversView.resizeColumnsToContents()
        self.serversView.resizeRowsToContents()

        self.UpdateStatus("<b>Servers Status</b> added to UI successfully.")

def __init__(self, data=None, parent=None):
        QStandardItemModel.__init__(self, parent)
        for i, d in enumerate(data):
            col_1 = QStandardItem(d["name"])
            col_2 = QStandardItem(d["image"])
            col_3 = QStandardItem(d["color"])
            self.setItem(i, 0, col_1)
            self.setItem(i, 1, col_2)
            self.setItem(i, 2, col_3)
        self.setHorizontalHeaderLabels(["Name", "Image", "Color"])

def __init__(self, data=None, parent=None):
        QStandardItemModel.__init__(self, parent)
        for i, d in enumerate(data):
            item = QStandardItem(d["name"])
            item.setData(d["image"], Qt.DecorationRole)
            self.setItem(i, 0, item)

def __init__(self, data=None, parent=None):
        QStandardItemModel.__init__(self, parent)
        for i, d in enumerate(data):
            self.setItem(i, 0, QStandardItem(d))

def __init__(self):
        QWidget.__init__(self, flags=Qt.Widget)
        self.setWindowTitle("ItemView QListView")
        self.setFixedHeight(100)

        fruits = ["banana", "apple", "melon", "pear"]

        view = QListView(self)
        model = QStandardItemModel()
        for f in fruits:
            model.appendRow(QStandardItem(f))
        view.setModel(model)

def __init__(self, data):
        QStandardItemModel.__init__(self)
        self._data = data
        for j, d in enumerate(data):
            item = QStandardItem(d["type"])
            for obj in d["objects"]:
                child = QStandardItem(obj)
                child.setData(d["picture"], Qt.DecorationRole)  # Role ??? ? ?? ??? ? ??? ??
                item.appendRow(child)
            self.setItem(j, 0, item)

def __init__(self, data):
        QStandardItemModel.__init__(self)

        d = data[0]  # Fruit
        item = QStandardItem(d["type"])
        child = QStandardItem(d["objects"][0])  # Apple
        item.appendRow(child)
        child = QStandardItem(d["objects"][1])  # Banana
        item.appendRow(child)
        self.setItem(0, 0, item)

        d = data[1]  # Vegetable
        item = QStandardItem(d["type"])
        child = QStandardItem(d["objects"][0])  # Carrot
        item.appendRow(child)
        child = QStandardItem(d["objects"][1])  # Tomato
        item.appendRow(child)
        self.setItem(1, 0, item)

        # for ?? ???? ???? ??
        # for j, _type in enumerate(data):
        #   item = QStandardItem(_type["type"])
        #   for obj in _type["objects"]:
        #       child = QStandardItem(obj)
        #       item.appendRow(child)
        #   self.setItem(j, 0, item)

def add_path(self, path):
        if path not in self._paths:
            self._paths.append(path)
            item = QStandardItem(path)
            self.appendRow(item)
            self._save_settings()

def _load_settings(self):
        App.settings.beginGroup('sunvox')
        try:
            paths = App.settings.value('workspace_paths')
            if paths is not None:
                self._paths = paths
                self.clear()
                for path in paths:
                    self.appendRow(QStandardItem(path))
        finally:
            App.settings.endGroup()

def remove(self):
        selected = self.blockedList.selectedItems()
        if selected:
            item = selected[0]
            index = self.blockedList.indexFromItem(item)
            self.blockedList.takeItem(index.row())
            user = item.text()
            self.app.blocked.remove(user)
            if user in self.app.friends.keys():
                treeitem = QStandardItem(user)
                treeitem.setText(user)
                treeitem.setIcon(QIcon(self.app.theme["path"] + "/offline.png"))
                self.app.gui.friendsModel.appendRow(treeitem)

def _show_attr(self, attr, dv):
        if attr == ua.AttributeIds.DataType:
            string = data_type_to_string(dv.Value.Value)
        elif attr in (ua.AttributeIds.AccessLevel,
                      ua.AttributeIds.UserAccessLevel,
                      ua.AttributeIds.WriteMask,
                      ua.AttributeIds.UserWriteMask,
                      ua.AttributeIds.EventNotifier):
            string = enum_to_string(attr, dv.Value.Value)
        else:
            string = val_to_string(dv.Value.Value)
        name_item = QStandardItem(attr.name)
        vitem = QStandardItem(string)
        vitem.setData(AttributeData(attr, dv.Value.Value, dv.Value.VariantType), Qt.UserRole)
        self.model.appendRow([name_item, vitem, QStandardItem(dv.Value.VariantType.name)])

def _show_value_attr(self, attr, dv):
        name_item = QStandardItem("Value")
        vitem = QStandardItem()
        items = self._show_val(name_item, None, "Value", dv.Value.Value, dv.Value.VariantType)
        items[1].setData(AttributeData(attr, dv.Value.Value, dv.Value.VariantType), Qt.UserRole)
        row = [name_item, vitem, QStandardItem(dv.Value.VariantType.name)]
        self.model.appendRow(row)
        self._show_timestamps(name_item, dv)

def _show_val(self, parent, obj, name, val, vtype):
        name_item = QStandardItem(name)
        vitem = QStandardItem()
        vitem.setText(val_to_string(val))
        vitem.setData(MemberData(obj, name, val, vtype), Qt.UserRole)
        row = [name_item, vitem, QStandardItem(vtype.name)]
        # if we have a list or extension object we display children
        if isinstance(val, list):
            row[2].setText("List of " + vtype.name)
            self._show_list(name_item, val, vtype)
        elif vtype == ua.VariantType.ExtensionObject:
            self._show_ext_obj(name_item, val)
        parent.appendRow(row)
        return row