选择新委托时如何更新QTableWidgetItems?

下面是我用来更新委托的代码示例:

//here is the item delegate I used
#include <QItemDelegate>
#include <QSpinBox>
#include <limits>

class IntDelegate : public QItemDelegate {
    int m_min;
    int m_max;
public:
    explicit IntDelegate(int min = std::numeric_limits<int>::min(),
                         int max = std::numeric_limits<int>::max(),
                         QObject *parent = nullptr) : QItemDelegate(
            parent), m_min(min), m_max(max) {
    }

    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                          const QModelIndex &index) const override {
        auto spinbox = new QSpinBox(parent);
        spinbox->setMinimum(m_min);
        spinbox->setMaximum(m_max);
        return spinbox;
    }

    void setEditorData(QWidget *editor,
                       const QModelIndex &index) const override {
        int value = index.model()->data(index, Qt::EditRole).toInt();
        auto *spinBox = static_cast<QSpinBox *>(editor);
        spinBox->setValue(value);
    }

    void setModelData(QWidget *editor, QAbstractItemModel *model,
                      const QModelIndex &index) const override {
        auto *spinBox = static_cast<QSpinBox *>(editor);
        spinBox->interpretText();
        int value = spinBox->value();

        model->setData(index, value, Qt::EditRole);
    }

    void updateEditorGeometry(QWidget *editor,
                              const QStyleOptionViewItem &option,
                              const QModelIndex &index) const override {
        editor->setGeometry(option.rect);
    }
};

#include <QItemDelegate>
#include <QDoubleSpinBox>
#include <limits>

class DoubleDelegate : public QItemDelegate {
double m_min;
double m_max;
public:
explicit DoubleDelegate(double min = -std::numeric_limits<double>::max(),
                        double max = std::numeric_limits<double>::max(),
                        QObject *parent = nullptr) : QItemDelegate(
        parent), m_min(min), m_max(max) {
}

QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                      const QModelIndex &index) const override {
    auto spinbox = new QDoubleSpinBox(parent);
    spinbox->setMinimum(m_min);
    spinbox->setMaximum(m_max);
    spinbox->setDecimals(323);

    return spinbox;
}

void setEditorData(QWidget *editor,
                   const QModelIndex &index) const override {
    double value = index.model()->data(index, Qt::EditRole).toDouble();
    auto *spinBox = static_cast<QDoubleSpinBox *>(editor);
    spinBox->setValue(value);
}

void
setModelData(QWidget *editor, QAbstractItemModel *model,
             const QModelIndex &index) const override {
    auto *spinBox = static_cast<QDoubleSpinBox *>(editor);
    spinBox->interpretText();
    double value = spinBox->value();

    model->setData(index, value, Qt::EditRole);
}

void updateEditorGeometry(QWidget *editor,
                          const QStyleOptionViewItem &option,
                          const QModelIndex &index) const override {
    editor->setGeometry(option.rect);
}

};

 #include <QTableWidget> // table matrix box
 #include <QLabel>
 #include <QVBoxLayout>
 #include <QGridLayout>
 #include <QFileDialog>
 #include "intdelegate.h"
 #include "doubledelegate.h"
 #include <QComboBox> // selection of QT type
 #include <limits>


 #define CV_8U 0
 #define CV_8S 1
 #define CV_16U 2
 #define CV_16S 3
 #define CV_32S 4
 #define CV_32F 5
 #define CV_64F 6

// inside area where widget is created
class MatrixBoxWidget : public QWidget {
     Q_OBJECT

     QTableWidget *m_matrix_table;
     QComboBox *m_cv_types_combobox;
public:
 explicit MatrixBoxWidget(QWidget *parent = nullptr){
    m_cv_types_combobox = new QComboBox(this);

    m_cv_types_combobox->addItem("uint8", QVariant::fromValue(CV_8U));
    m_cv_types_combobox->addItem("int8", QVariant::fromValue(CV_8S));
    m_cv_types_combobox->addItem("uint16", QVariant::fromValue(CV_16U));
    m_cv_types_combobox->addItem("int16", QVariant::fromValue(CV_16S));
    m_cv_types_combobox->addItem("int32", QVariant::fromValue(CV_32S));
    m_cv_types_combobox->addItem("float", QVariant::fromValue(CV_32F));
    m_cv_types_combobox->addItem("double", QVariant::fromValue(CV_64F));


    connect(m_cv_types_combobox,
        qOverload<int>(&QComboBox::currentIndexChanged), this,
        &MatrixBoxWidget::validateDisplayType);

    QTableWidget *m_matrix_table = new QTableWidget(this);
    auto delegate = new IntDelegate();
    m_matrix_table->setItemDelegate(delegate);
    m_matrix_table->setItem(0, 0, new QTableWidgetItem());
    m_matrix_table->item(0, 0)->setData(Qt::EditRole, 12723);
    m_matrix_table->setItem(0, 1, new QTableWidgetItem());
    m_matrix_table->item(0, 1)->setData(Qt::EditRole, 12723);
    m_matrix_table->setItem(1, 0, new QTableWidgetItem());
    m_matrix_table->item(1, 0)->setData(Qt::EditRole, 12723);
    m_matrix_table->setItem(1, 1, new QTableWidgetItem());
    m_matrix_table->item(1, 1)->setData(Qt::EditRole, 12723);

    auto type_layout = new QVBoxLayout();
    auto type_label = new QLabel("type", this);
    type_layout->addWidget(type_label);
    type_layout->addWidget(m_cv_types_combobox);

    auto layout = new QGridLayout(this);
    layout->addLayout(type_layout, 0, 2);
    layout->addWidget(m_matrix_table, 1, 0, 3, 3);

}
void validateDisplayType(int index) {
    QVariant current_data = m_cv_types_combobox->currentData();
    auto cv_type = current_data.value<int>();
    QItemDelegate *delegate;
    switch (cv_type) {
        case CV_8U:
            delegate = new IntDelegate(std::numeric_limits<uint8_t>::min(),
                                       std::numeric_limits<uint8_t>::max());
            m_matrix_table->setItemDelegate(delegate);
            break;
        case CV_8S:
            delegate = new IntDelegate(std::numeric_limits<int8_t>::min(),
                                       std::numeric_limits<int8_t>::max());
            m_matrix_table->setItemDelegate(delegate);
            break;
        case CV_16U:
            delegate = new IntDelegate(std::numeric_limits<uint16_t>::min(),
                                       std::numeric_limits<uint16_t>::max());
            m_matrix_table->setItemDelegate(delegate);
            break;
        case CV_16S:
            delegate = new IntDelegate(std::numeric_limits<int16_t>::min(),
                                       std::numeric_limits<int16_t>::max());
            m_matrix_table->setItemDelegate(delegate);
            break;
        case CV_32S:
            delegate = new IntDelegate(std::numeric_limits<int32_t>::min(),
                                       std::numeric_limits<int32_t>::max());
            m_matrix_table->setItemDelegate(delegate);
            break;
        case CV_32F:
            delegate = new DoubleDelegate(-std::numeric_limits<float>::max(),
                                          std::numeric_limits<float>::max());
            m_matrix_table->setItemDelegate(delegate);
            break;
        case CV_64F:
            delegate = new DoubleDelegate(-std::numeric_limits<double>::max(),
                                          std::numeric_limits<double>::max());
            m_matrix_table->setItemDelegate(delegate);
            break;
        default:
            assert((false, "unknown type format"));
            break;
    }
};

例如,一个委托是uint16\u t委托,我将项的值设置为1024。交换代理时,我希望显示相应地更改显示的值。当我去编辑一个项目时,它有完美的行为,委托值变成255,同样,如果我使用一个使用双精度的委托来显示,然后切换到整数,我就从2.234变为2。例如,所有人都使用相同的数字,但当代理发生变化并且为其限定了正确的范围(从uint16到uint8)时,我会进行编辑:

当我切换委托而不是手动单击显示时,如何以编程方式强制执行此行为?我尝试过更新视口,但我不认为它会像我认为的那样:

m_matrix_table->viewport()->update();