Python QTableWidgetItem.setData方法代码示例

# 需要导入模块: from qgis.PyQt.QtWidgets import QTableWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTableWidgetItem import setData [as 别名]
def append_row(table, label, data):
    """Append new row to table widget.

    :param table: The table that shall have the row added to it.
    :type table: QTableWidget

    :param label: Label for the row.
    :type label: str

    :param data: custom data associated with label value.
    :type data: str
    """
    # noinspection PyUnresolvedReferences
    count = table.rowCount()
    # noinspection PyUnresolvedReferences
    table.insertRow(table.rowCount())

    items = QTableWidgetItem(label)

    # see for details of why we follow this pattern
    # http://stackoverflow.com/questions/9257422/
    # how-to-get-the-original-python-data-from-qvariant
    # Make the value immutable.
    variant = (data,)
    # To retrieve it again you would need to do:
    # value = myVariant.toPyObject()[0]
    items.setData(Qt.UserRole, variant)
    # set scenario status (ready or not) into table
    # noinspection PyUnresolvedReferences
    table.setItem(count, 0, items)
    # noinspection PyUnresolvedReferences
    table.setItem(count, 1, QTableWidgetItem(data['status']))

# 需要导入模块: from qgis.PyQt.QtWidgets import QTableWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTableWidgetItem import setData [as 别名]
 def selectSource(self): 
     '''
     source feature selection procedure
     '''
     if self.layerHighlighted:
         self.resetSource()
     try:
         self.dock.tableWidget.itemChanged.disconnect(self.highLightCellOverride)
     except:
         pass
     #take first selected feature as source feature
     self.sourceFeat = self.selectedFeature
     #hightlight source feature with rubberband
     self.sourceEvid.setToGeometry(self.sourceFeat.geometry(),self.selectedLayer)
     #get current layer attributes labels list
     field_names = self.scanLayerFieldsNames(self.selectedLayer)
     field_types = self.scanLayerFieldsTypes(self.selectedLayer)
     self.sourceAttrsTab=[]
     self.dock.tableWidget.setRowCount(len(field_names))
     #loading attributes labels and values in QTableWidget
     for n in range(0,len(field_names)):
             item=QTableWidgetItem()
             item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
             item.setCheckState(Qt.Unchecked)
             item.setText("")
             #set first column as checkbox
             self.dock.tableWidget.setItem(n,0,item)
             #set second colunm as attribute label as qcombobox widget
             self.dock.tableWidget.setCellWidget(n,1,self.setComboField(field_names[n],field_types[n],self.canvas.currentLayer()))
             #set third column as attribute value
             item = QTableWidgetItem()
             item.setData(Qt.DisplayRole,self.sourceFeat.attributes()[n])
             self.dock.tableWidget.setItem(n,2,item)
     #resize table to contents
     self.dock.tableWidget.resizeColumnsToContents()
     self.dock.tableWidget.horizontalHeader().setStretchLastSection(True)
     #procedure to recover same field selection if current source feature has the same layer of the precedent one
     if self.selectedLayer.id() != self.activeLayer:
         self.sourceAttrs={}
         self.activeLayer = self.selectedLayer.id()
     else:
         for Attr in self.sourceAttrs:
             self.dock.tableWidget.item(Attr,0).setCheckState(Qt.Checked)
     #Enable button to apply or reset
     self.dock.ResetSource.setEnabled(True)
     self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride)
     self.checkOnLayerChange(self.canvas.currentLayer())

# 需要导入模块: from qgis.PyQt.QtWidgets import QTableWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTableWidgetItem import setData [as 别名]
    def populate_function_table_1(self):
        """Populate the tblFunctions1 table with available functions."""
        hazards = deepcopy(hazard_all)
        exposures = exposure_all

        self.lblAvailableFunctions1.clear()
        self.tblFunctions1.clear()
        self.tblFunctions1.setColumnCount(len(hazards))
        self.tblFunctions1.setRowCount(len(exposures))
        for i in range(len(hazards)):
            hazard = hazards[i]
            item = QTableWidgetItem()
            item.setIcon(QIcon(get_image_path(hazard)))
            item.setText(hazard['name'].capitalize())
            item.setTextAlignment(Qt.AlignLeft)
            self.tblFunctions1.setHorizontalHeaderItem(i, item)
        for i in range(len(exposures)):
            exposure = exposures[i]
            item = QTableWidgetItem()
            item.setIcon(QIcon(get_image_path(exposure)))
            item.setText(exposure['name'].capitalize())
            self.tblFunctions1.setVerticalHeaderItem(i, item)
        developer_mode = setting('developer_mode', False, bool)
        for hazard in hazards:
            for exposure in exposures:
                item = QTableWidgetItem()
                if (exposure in hazard['disabled_exposures'] and not
                        developer_mode):
                    background_colour = unavailable_option_color
                    # Set it disable and un-selectable
                    item.setFlags(
                        item.flags() & ~
                        Qt.ItemIsEnabled & ~
                        Qt.ItemIsSelectable
                    )
                else:
                    background_colour = available_option_color
                item.setBackground(QBrush(background_colour))
                item.setFont(big_font)
                item.setTextAlignment(Qt.AlignCenter | Qt.AlignHCenter)
                item.setData(RoleHazard, hazard)
                item.setData(RoleExposure, exposure)
                self.tblFunctions1.setItem(
                    exposures.index(exposure), hazards.index(hazard), item)
        self.parent.pbnNext.setEnabled(False)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTableWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTableWidgetItem import setData [as 别名]
    def restoreState(self,layer,table):
        if layer.id() in self.states.keys():
            table.blockSignals(True)
            #clear dock widget
            while table.rowCount()>0:
                table.removeRow(0)
            #add rows
            table.setRowCount(len(self.states[layer.id()]))
            for n in range(0, len(self.states[layer.id()])):
                row = self.states[layer.id()][n]
                #set first column as checkbox
                item=QTableWidgetItem()
                item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
                if row[0]:
                    item.setCheckState(Qt.Checked)
                else:
                    item.setCheckState(Qt.Unchecked)
                item.setText("")
                table.setItem(n,0,item)
                #set second column as combobox
                combo = QComboBox();
                combo.addItems(row[1])
                #print (row[1],row[2])
                combo.setCurrentIndex(row[2])
                table.setCellWidget(n,1,combo)
                #set third column as attribute value
                item = QTableWidgetItem(row[3])
                item.setData(Qt.DisplayRole,row[4])
                if row[5]:
                    item.setForeground(QBrush(QColor(0,0,0)))
                else:
                    item.setForeground(QBrush(QColor(130,130,130)))
                if row[6]:
                    item.setBackground(QBrush(QColor(183,213,225)))
                table.setItem(n,2,item)

            table.blockSignals(False)
            return True

        else:
            return None

# 需要导入模块: from qgis.PyQt.QtWidgets import QTableWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTableWidgetItem import setData [as 别名]
 def addCoord(self, lat, lon, label='', data=[]):
     '''Add a coordinate to the list.'''
     rowcnt = self.resultsTable.rowCount()
     if rowcnt >= self.maxResults:
         return
     self.resultsTable.blockSignals(True)
     self.resultsTable.insertRow(rowcnt)
     item = QTableWidgetItem(str(lat))
     item.setData(Qt.UserRole, LatLonItem(lat, lon, label, data))
     item.setFlags(item.flags() & ~Qt.ItemIsEditable)
     self.resultsTable.setItem(rowcnt, 0, item)
     item = QTableWidgetItem(str(lon))
     item.setFlags(item.flags() & ~Qt.ItemIsEditable)
     self.resultsTable.setItem(rowcnt, 1, item)
     self.resultsTable.setItem(rowcnt, 2, QTableWidgetItem(label))
     if self.numCol > 3 and len(data) > 0:
         for i in range( min(self.numCol-3, len(data))):
             self.resultsTable.setItem(rowcnt, i+3, QTableWidgetItem(data[i]))
         
     self.resultsTable.blockSignals(False)
     return(rowcnt)

# 需要导入模块: from qgis.PyQt.QtWidgets import QTableWidgetItem [as 别名]
# 或者: from qgis.PyQt.QtWidgets.QTableWidgetItem import setData [as 别名]
    def reloadProject(self):
        """
        Load all layers from the map layer registry into the table.
        """
        self.unsupportedLayersList = list()
        self.layersTable.setRowCount(0)
        self.layersTable.setSortingEnabled(False)
        for layer in list(self.project.mapLayers().values()):
            layer_source = LayerSource(layer)
            if not layer_source.is_supported:
                self.unsupportedLayersList.append(layer_source)
            count = self.layersTable.rowCount()
            self.layersTable.insertRow(count)
            item = QTableWidgetItem(layer.name())
            item.setData(Qt.UserRole, layer_source)
            item.setData(Qt.EditRole, layer.name())
            self.layersTable.setItem(count, 0, item)

            cbx = QComboBox()
            for action, description in layer_source.available_actions:
                cbx.addItem(description)
                cbx.setItemData(cbx.count() - 1, action)
                if layer_source.action == action:
                    cbx.setCurrentIndex(cbx.count() - 1)

            self.layersTable.setCellWidget(count, 1, cbx)
        self.layersTable.resizeColumnsToContents()
        self.layersTable.sortByColumn(0, Qt.AscendingOrder)
        self.layersTable.setSortingEnabled(True)

        # Load Map Themes
        for theme in self.project.mapThemeCollection().mapThemes():
            self.mapThemeComboBox.addItem(theme)

        self.layerComboBox.setFilters(QgsMapLayerProxyModel.RasterLayer)

        self.__project_configuration = ProjectConfiguration(self.project)
        self.createBaseMapGroupBox.setChecked(self.__project_configuration.create_base_map)

        if self.__project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER:
            self.singleLayerRadioButton.setChecked(True)
        else:
            self.mapThemeRadioButton.setChecked(True)

        self.mapThemeComboBox.setCurrentIndex(
            self.mapThemeComboBox.findText(self.__project_configuration.base_map_theme))
        layer = QgsProject.instance().mapLayer(self.__project_configuration.base_map_layer)
        self.layerComboBox.setLayer(layer)
        self.mapUnitsPerPixel.setText(str(self.__project_configuration.base_map_mupp))
        self.tileSize.setText(str(self.__project_configuration.base_map_tile_size))
        self.onlyOfflineCopyFeaturesInAoi.setChecked(self.__project_configuration.offline_copy_only_aoi)

        if self.unsupportedLayersList:
            self.unsupportedLayers.setVisible(True)

            unsuppoerted_layers_text = '<b>{}</b><br>'.format(self.tr('Warning'))
            unsuppoerted_layers_text += self.tr("There are unsupported layers in your project. They will not be available on QField.")

            unsuppoerted_layers_text += '<ul>'
            for layer in self.unsupportedLayersList:
                unsuppoerted_layers_text += '<li>' + '<b>' + layer.name + ':</b> ' + layer.warning
            unsuppoerted_layers_text += '<ul>'

            self.unsupportedLayers.setText(unsuppoerted_layers_text)