使用组合委托排序QTableView会删除删除对象，除非双击后

Question

我有QTableView，它查看一个熊猫表。第一行具有QComboBox委托。当我按列对表格进行排序时，代表消失了。

下面是我的代码的工作示例。

import sys
import pandas as pd
import numpy as np

from PyQt5.QtCore import (QAbstractTableModel, Qt, pyqtProperty, pyqtSlot,
                          QVariant, QModelIndex)
from PyQt5.QtWidgets import (QItemDelegate, QComboBox, QMainWindow, QTableView,
                             QApplication)


class DataFrameModel(QAbstractTableModel):
    DtypeRole = Qt.UserRole + 1000
    ValueRole = Qt.UserRole + 1001
    ActiveRole = Qt.UserRole + 1

    def __init__(self, df=pd.DataFrame(), parent=None):
        super(DataFrameModel, self).__init__(parent)
        self._dataframe = df

    def setDataFrame(self, dataframe):
        self.beginResetModel()
        self._dataframe = dataframe.copy()
        self.endResetModel()

    def dataFrame(self):
        return self._dataframe

    dataFrame = pyqtProperty(pd.DataFrame, fget=dataFrame, fset=setDataFrame)

    @pyqtSlot(int, Qt.Orientation, result=str)
    def headerData(self, section, orientation, role=Qt.DisplayRole):
        if role != Qt.DisplayRole:
            return QVariant()

        if orientation == Qt.Horizontal:
            try:
                return self._dataframe.columns.tolist()[section]
            except (IndexError, ):
                return QVariant()
        elif orientation == Qt.Vertical:
            try:
                if section in [0]:
                    pass
                else:
                    return self._dataframe.index.tolist()[section - 1]
            except (IndexError, ):
                return QVariant()

    def rowCount(self, parent=QModelIndex()):
        if parent.isValid():
            return 0
        return len(self._dataframe.index)

    def columnCount(self, parent=QModelIndex()):

        if parent.isValid():
            return 0
        return self._dataframe.columns.size

    def data(self, index, role=Qt.DisplayRole):
        if not index.isValid() or not (0 <= index.row() < self.rowCount()
                                       and 0 <= index.column() <
                                       self.columnCount()):
            return QVariant()
        row = self._dataframe.index[index.row()]
        col = self._dataframe.columns[index.column()]
        dt = self._dataframe[col].dtype

        val = self._dataframe.iloc[row][col]

        if role == Qt.DisplayRole:
            return str(val)
        elif role == DataFrameModel.ValueRole:
            return val
        if role == DataFrameModel.DtypeRole:
            return dt
        return QVariant()

    def roleNames(self):
        roles = {
            Qt.DisplayRole: b'display',
            DataFrameModel.DtypeRole: b'dtype',
            DataFrameModel.ValueRole: b'value'
        }
        return roles

    def setData(self, index, value, role):
        col = index.column()
        row = index.row()
        if index.row() == 0:
            if isinstance(value, QVariant):
                value = value.value()
            if hasattr(value, 'toPyObject'):
                value = value.toPyObject()
            self._dataframe.iloc[row, col] = value
            self.dataChanged.emit(index, index, (Qt.DisplayRole,))
        else:
            try:
                value = eval(value)
                if not isinstance(
                        value,
                        self._dataframe.applymap(type).iloc[row, col]):
                    value = self._dataframe.iloc[row, col]
            except Exception as e:
                value = self._dataframe.iloc[row, col]
            self._dataframe.iloc[row, col] = value
            self.dataChanged.emit(index, index, (Qt.DisplayRole,))
        return True

    def flags(self, index):
        return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable

    def sort(self, column, order):
        self.layoutAboutToBeChanged.emit()
        col_name = self._dataframe.columns.tolist()[column]
        sheet1 = self._dataframe.iloc[:1, :]
        sheet2 = self._dataframe.iloc[1:, :].sort_values(
            col_name, ascending=order == Qt.AscendingOrder, inplace=False)

        sheet2.reset_index(drop=True, inplace=True)
        sheet3 = pd.concat([sheet1, sheet2], ignore_index=True)
        self.setDataFrame(sheet3)
        self.layoutChanged.emit()


class ComboBoxDelegate(QItemDelegate):
    def __init__(self, owner, choices):
        super().__init__(owner)
        self.items = choices

    def createEditor(self, parent, option, index):
        editor = QComboBox(parent)
        editor.addItems(self.items)
        editor.currentIndexChanged.connect(self.currentIndexChanged)
        return editor

    def paint(self, painter, option, index):
        if isinstance(self.parent(), QItemDelegate):
            self.parent().openPersistentEditor(0, index)
        QItemDelegate.paint(self, painter, option, index)

    def setModelData(self, editor, model, index):
        value = editor.currentText()
        model.setData(index, value, Qt.EditRole)

    def updateEditorGeometry(self, editor, option, index):
        editor.setGeometry(option.rect)

    @pyqtSlot()
    def currentIndexChanged(self):
        self.commitData.emit(self.sender())


class MainWindow(QMainWindow):
    def __init__(self, pandas_sheet):
        super().__init__()
        self.pandas_sheet = pandas_sheet

        for i in range(1):
            self.pandas_sheet.loc[-1] = [''] * len(self.pandas_sheet.columns.values)
            self.pandas_sheet.index = self.pandas_sheet.index + 1
            self.pandas_sheet = self.pandas_sheet.sort_index()
        self.table = QTableView()
        self.setCentralWidget(self.table)
        delegate = ComboBoxDelegate(self.table,
                                    ['m1', 'm2', 'm3'])
        model = DataFrameModel(self.pandas_sheet, self)
        self.table.setModel(model)
        self.table.setSortingEnabled(True)
        self.table.setItemDelegateForRow(0, delegate)
        for i in range(model.columnCount()):
            ix = model.index(0, i)
            self.table.openPersistentEditor(ix)

        self.table.resizeColumnsToContents()
        self.table.resizeRowsToContents()


if __name__ == '__main__':
    df = pd.DataFrame({'a': ['col0'] * 5,
                       'b': np.arange(5),
                       'c': np.random.rand(5)})
    app = QApplication(sys.argv)
    window = MainWindow(df)
    window.show()
    sys.exit(app.exec_())

下图显示了排序前的表格。

下图按一列对表格进行排序后的图像。

我希望第一行的样式在按任何列排序之前和之后都相同。这可能吗？

Answer 1

默认情况下，不显示编辑器，除非用户使用分配给editTriggers的标志中指示的事件与项目进行交互，或者如果您使用openPersistentEditor（）强迫它们打开它们，则将其显示。

考虑到最后一个选项，您可以使显示的任务自动化，但是为此，必须可以从委托的paint方法访问该视图，因为始终通过解决方案将其作为父级传递来调用它（似乎您正在尝试实现）并使用openPersistentEditor（）（如果它是视图），在这种情况下会发生错误，因为父级不是QItemDelegate而是从QAbstractItemView继承，此外，您还必须传递QModelIndex。]

考虑到上述，解决方法是：

def paint(self, painter, option, index):
    if isinstance(self.parent(), QAbstractItemView):
        self.parent().openPersistentEditor(index)
因此，每次重新绘制委托时（例如，在排序之后），都​​将调用openPersistentEditor（）以使编辑器可见。

更新：

编辑器必须通过setModelData将信息保存在QModelIndex角色中，并使用setEditorData检索它们，在这种情况下，您将不实现第二个信息，因此当再次创建编辑器时，编辑器将无法获取信息。另外，setModelData将信息保存在Qt :: EditRole中，但是在您的模型中它不处理该角色，因此您必须使用Qt :: DisplayRole。

考虑到上述，解决方法是：

class ComboBoxDelegate(QItemDelegate):
    def __init__(self, parent, choices):
        super().__init__(parent)
        self.items = choices

    def createEditor(self, parent, option, index):
        editor = QComboBox(parent)
        editor.addItems(self.items)
        editor.currentIndexChanged.connect(self.currentIndexChanged)
        return editor

    def paint(self, painter, option, index):
        if isinstance(self.parent(), QAbstractItemView):
            self.parent().openPersistentEditor(index)

    def setModelData(self, editor, model, index):
        value = editor.currentText()
        model.setData(index, value, Qt.DisplayRole)

    def setEditorData(self, editor, index):
        text = index.data(Qt.DisplayRole) or ""
        editor.setCurrentText(text)

    def updateEditorGeometry(self, editor, option, index):
        editor.setGeometry(option.rect)

    @pyqtSlot()
    def currentIndexChanged(self):
        self.commitData.emit(self.sender())