QAbstractTableModel练习

#ifndef PARACONFIGUREMODULE_H
#define PARACONFIGUREMODULE_H

#include <QAbstractItemModel>
#include <QMap>
#include <QBitArray>

class paraConfigureModule : public QAbstractTableModel
{
    Q_OBJECT

public:
    paraConfigureModule(QObject *parent = nullptr);

    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;

    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
    bool setData(const QModelIndex &index, const QVariant &value, int role) override;

    Qt::ItemFlags flags(const QModelIndex &index) const override;

private:
    void initParameter();

public slots:
    void updatedata();

signals:
    void updateViewport();
    void select(int row);

private:
    QBitArray m_select;
    QVector<QString> m_num;
    QVector<QString> m_name;
    QVector<QString> m_value;
    QVector<QString> m_range;
    QVector<QString> m_unit;
    QVector<QString> m_default;
};

#endif // PARACONFIGUREMODULE_H

 

#include "paraconfiguremodule.h"
#include <QDebug>
#include <QBrush>
#include <QColor>

enum
{
    RowCount = 4,
    ColumnCount = 7,

    CheckColumn = 0,
    NumColumn = 1,
    NameColumn = 2,
    ValueColumn = 3,
    RangeColumn = 4,
    UnitColumn = 5,
    DefaultColumn = 6
};

paraConfigureModule::paraConfigureModule(QObject *parent)
    : QAbstractTableModel(parent)
    ,m_select(RowCount,false)

{
    this->initParameter();
}

int paraConfigureModule::rowCount(const QModelIndex &/*parent*/) const
{
    return RowCount;
}

int paraConfigureModule::columnCount(const QModelIndex &/*parent*/) const
{
    return ColumnCount;
}

QVariant paraConfigureModule::data(const QModelIndex &index, int role) const
{
    if (!index.isValid() || index.row() >= RowCount || index.column() >= ColumnCount)
    {
        return QVariant();
    }

    Q_ASSERT(m_select.count() == RowCount);
    Q_ASSERT(m_num.count() == RowCount);
    Q_ASSERT(m_name.count() == RowCount);
    Q_ASSERT(m_value.count() == RowCount);
    Q_ASSERT(m_range.count() == RowCount);
    Q_ASSERT(m_unit.count() == RowCount);
    Q_ASSERT(m_default.count() == RowCount);

    if (index.column() == CheckColumn && role == Qt::CheckStateRole)
    {
        return m_select.at(index.row())? Qt::Checked : Qt::Unchecked;
    }

    if (index.column() == CheckColumn && role == Qt::BackgroundColorRole)
    {
        return QBrush(QColor(Qt::yellow));
    }

    if (index.column() == NumColumn && role == Qt::DisplayRole)
    {
        return m_num.at(index.row());
    }

    if (index.column() == NameColumn && role == Qt::DisplayRole)
    {
        return m_name.at(index.row());
    }

    if (index.column() == ValueColumn && role == Qt::DisplayRole)
    {
        return m_value.at(index.row());
    }

    if (index.column() == RangeColumn && role == Qt::DisplayRole)
    {
        return m_range.at(index.row());
    }

    if (index.column() == UnitColumn && role == Qt::DisplayRole)
    {
        return m_unit.at(index.row());
    }

    if (index.column() == DefaultColumn && role == Qt::DisplayRole)
    {
        return m_default.at(index.row());
    }

    return QVariant();
}

QVariant paraConfigureModule::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role != Qt::DisplayRole)
        return QVariant();

    if (orientation == Qt::Horizontal) {
        switch (section) {
        case CheckColumn:
            return QStringLiteral("");
        case NumColumn:
            return QStringLiteral("参数编号");
        case NameColumn:
            return QStringLiteral("参数名称");
        case ValueColumn:
            return QStringLiteral("参数值");
        case RangeColumn:
            return QStringLiteral("参数范围");
        case UnitColumn:
            return QStringLiteral("单位");
        case DefaultColumn:
            return QStringLiteral("默认值");
        default:
            break;
        }
    }
    return QVariant();

}

bool paraConfigureModule::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (!index.isValid() || index.row() >= RowCount || index.column() >= ColumnCount)
        return false;

    Q_ASSERT(m_select.count() == RowCount);
    Q_ASSERT(m_value.count() == RowCount);

    if (index.column() == CheckColumn && role == Qt::CheckStateRole)
    {
        auto s = static_cast<Qt::CheckState>(value.toUInt());
        s == Qt::Checked ? m_select.setBit(index.row()) : m_select.clearBit(index.row());
        if(s == Qt::Checked)
        {
            emit select(index.row());
        }
        qDebug() << s;
        emit dataChanged(index, index);
        return true;
    }

    if (index.column() == ValueColumn && role == Qt::EditRole)
    {
        QString newValue = value.toString();
        m_value[index.row()] = newValue;
        emit dataChanged(index, index);
        qDebug() << m_value[index.row()];
        return true;
    }

    return false;
}

Qt::ItemFlags paraConfigureModule::flags(const QModelIndex &index) const
{
    if (!index.isValid() || index.row() >= RowCount || index.column() >= ColumnCount)
        return QAbstractTableModel::flags(index);

    Qt::ItemFlags flags = QAbstractTableModel::flags(index);
    if (index.column() == CheckColumn)
    {
        return flags | Qt::ItemIsUserCheckable;
    }

    if (index.column() == ValueColumn)
    {
        return flags | Qt::ItemIsEditable;
    }

    else
    {
        return flags | Qt::ItemIsEnabled;
    }
}

void paraConfigureModule::initParameter()
{
    m_select.resize(4);
    m_value.resize(4);

    m_num.append("p0_00");
    m_num.append("p0_01");
    m_num.append("p0_02");
    m_num.append("p0_03");

    m_name.append("速度1");
    m_name.append("速度2");
    m_name.append("速度3");
    m_name.append("速度4");

    m_range.append("0~10");
    m_range.append("0~30");
    m_range.append("0~300");
    m_range.append("0~3000");

    m_unit.append("s");
    m_unit.append("ms");
    m_unit.append("m");
    m_unit.append("v");

    m_default.append("0");
    m_default.append("10");
    m_default.append("100");
    m_default.append("1000");
}

void paraConfigureModule::updatedata()
{
    m_value[0] = "12";
    m_value[1] = "33";
    m_value[2] = "22";
    m_value[3] = "24";
    emit updateViewport();
    qDebug()<< "ok";
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QTimer>
#include "paraconfiguremodule.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private:
    Ui::MainWindow* ui;
    paraConfigureModule* m_paraModule;
    QTimer* m_timer;

};

#endif // MAINWINDOW_H

 

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    m_paraModule = new paraConfigureModule(this);
    ui->tableView->setModel(m_paraModule);

    QList<int> columnWidth;
    columnWidth << 50 << 150 << 150 << 170 << 150 << 170 << 160;

    for (int i = 0; i < 7; i++) {
        ui->tableView->setColumnWidth(i, columnWidth.at(i));
    }



    connect(m_paraModule, &paraConfigureModule::updateViewport
            ,ui->tableView->viewport(),static_cast<void (QWidget::*)()>(&QWidget::update));

    m_timer = new QTimer;
    m_timer->setInterval(3000);
    connect(m_timer,SIGNAL(timeout()),m_paraModule,SLOT(updatedata()));
    m_timer->start();
}

MainWindow::~MainWindow()
{
    delete ui;
    delete m_timer;
    delete m_paraModule;
}

https://gitee.com/feiyangqingyun