QT TableView自定义Model

头文件

#ifndef CTICKERDATAMODEL_H
#define CTICKERDATAMODEL_H

#include <QAbstractTableModel>
#include <QObject>
#include <QColor>
#include <QList>
#include <QStringList>
#include "CommonInterface/baseconfig.h"
#include "dataCenter/MarketDataModel/QuotationModel.h"
class TickerColorManage;
class CTickerDataModel : public QAbstractTableModel
{
    Q_OBJECT

public:
    enum ColumnType{
        COLUMN_ONE_TIME = 0,
        COLUMN_ONE_PRICE,
        COLUMN_ONE_VOLUMN,
        COLUMN_ONE_LABEL,
    };

    explicit CTickerDataModel(QObject *parent = nullptr,int type = 1);
    ~CTickerDataModel();

    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;

    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
    void setAlignmentFlag(int column, Qt::AlignmentFlag flag);
    void initheader(const QStringList &list);
    void setRowCount(int rowCount);
    void setColumnCount(int rowCount);

    void updateTickerData(const QMap<int,Quotation::TradeTickerItem> &tickerMarp);
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole)const override;
    void clearData();

private:
    QVariant getAlignmentFlag(const QModelIndex &index) const;
    QVariant getColor(const QModelIndex &index) const;
    QVariant getData(const QModelIndex &index) const;
    QVariant getBackGroupCol(const QModelIndex &index) const;
    void updateRowData(int row);
    QString getIconPath(const QModelIndex &index)const;
    void setColorManage(int row, const Quotation::TradeTickerItem &itemData)const;
    QVariant getBackgroundColor(const QModelIndex &index) const;
private:
    QColor m_Color;
    QMap<int, Qt::AlignmentFlag>  m_alignmentFlag;
    QStringList m_headerList;
    int m_rowCount;
    int m_columnCount = 4;
    QMap<int,Quotation::TradeTickerItem> m_tradeTickerData;
    TickerColorManage *m_colorManage = nullptr;
    int m_modelType ;

};

class TickerColorManage : public QObject
{
    Q_OBJECT
public:
    TickerColorManage();
    ~TickerColorManage();
    void updateBackgroundColor(int row,int column, QColor color);
    QColor getBackgroundColor(int column, const QString &key);
    void clearData();
private slots:
    void on_themeChanged(BaseConfig::ThemesType);
private:
    struct BackgroundColorData
    {
        int m_red = 0;
        int m_green = 0;
        int m_blue = 0;
        int m_twinkleStep;
    };
    typedef QMap<int, BackgroundColorData>  ColorDataMap;
    QMap<QString, ColorDataMap> m_backgroundColorDataMap;
    QColor m_upColor;
    QColor m_downColor;
    QColor m_srcColor;
};



#endif // CTICKERDATAMODEL_H

.cpp

#include "CTickerDataModel.h"
#include "CommonInterface/UiData.h"
#include <algorithm>
#include <QDebug>

CTickerDataModel::CTickerDataModel(QObject *parent,int type)
    : QAbstractTableModel(parent),m_modelType(type)
{
    m_colorManage = new TickerColorManage();
}
CTickerDataModel::~CTickerDataModel()
{
    delete m_colorManage;
}

void CTickerDataModel::initheader(const QStringList &list)
{
    m_headerList = list;
}

QVariant CTickerDataModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(orientation == Qt::Orientation::Vertical)
        return QVariant();

    if(role == Qt::TextAlignmentRole)
    {
        if(section == ColumnType::COLUMN_ONE_VOLUMN)
            return Qt::AlignmentFlag(int(Qt::AlignVCenter | Qt::AlignRight));
        else
            return Qt::AlignmentFlag(int(Qt::AlignVCenter | Qt::AlignLeft));
    }

    if(role == Qt::InitialSortOrderRole)
        return QVariant::fromValue(Qt::DescendingOrder);

    return QVariant();
}
void CTickerDataModel::setAlignmentFlag(int column, Qt::AlignmentFlag flag)
{
    m_alignmentFlag[column] = flag;
}
void CTickerDataModel::setRowCount(int rowCount)
{
    if(rowCount < 0)
        return;
    if(m_rowCount != rowCount)
    {
        beginResetModel();
        m_rowCount = rowCount;
        endResetModel();
    }
}
void CTickerDataModel::setColumnCount(int columnCount)
{
    if(columnCount < 0)
        return;
    if(m_columnCount != columnCount)
    {
        beginResetModel();
        m_columnCount = columnCount;
        endResetModel();
    }
}
int CTickerDataModel::rowCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return 0;

    return m_rowCount;
}


int CTickerDataModel::columnCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return 0;
    return m_columnCount;
}

void CTickerDataModel::clearData()
{
    beginResetModel();
    m_rowCount = 0;
    m_tradeTickerData.clear();
    m_colorManage->clearData();
    endResetModel();
}


void CTickerDataModel::updateTickerData(const QMap<int,Quotation::TradeTickerItem> &tickerMarp)
{
    m_tradeTickerData = tickerMarp;
    QMap<int, Quotation::TradeTickerItem>::const_iterator it = m_tradeTickerData.cbegin();
    for(; it != m_tradeTickerData.cend(); it++)
    {
        int row = it.key();
        if(m_modelType ==1 && row == m_rowCount -1)
            setColorManage(row,*it);
         updateRowData(row);
    }

}

void CTickerDataModel::updateRowData(int row)
{
    QVector<int> role;
    role.push_back(Qt::DisplayRole);
    role.push_back(Qt::TextAlignmentRole);
    role.push_back(Qt::TextColorRole);
    role.push_back(Qt::DecorationRole); //Item显示图片
    role.push_back(Qt::BackgroundRole);

    int columnCount = m_columnCount;
    for (int column = 0; column < columnCount; column++)
    {
        QModelIndex ChangeIndex = index(row, column);
        emit dataChanged(ChangeIndex, ChangeIndex, role);
    }
}

QString CTickerDataModel::getIconPath(const QModelIndex &index)const
{
    int row = index.row();
    if(index.column() >= 4)
        row = row + m_rowCount;

    BaseConfig::QuoteUpDownColor quoColor =(BaseConfig::QuoteUpDownColor)CLoginDataManager::GetInstance()->getUserInfoConfig(CLoginDataManager::APPEAR_UPDOWNCOLOR);
    if(quoColor == BaseConfig::QuoteUpDownColor::QUOTE_GREENUP_REDDOWN)
    {
        if(m_tradeTickerData[row].m_volumeDir == 1) //down
        {
            return ":/Resources/Dark_icons/icon_module/arrowred_trick_down.svg";
        }
        else if(m_tradeTickerData[row].m_volumeDir == 2) //up
        {
            return ":/Resources/Dark_icons/icon_module/arrowgreen_trick_up.svg";
        }
    }
    else if(quoColor == BaseConfig::QuoteUpDownColor::QUOTE_REDUP_GREENDOWN)
    {
        if(m_tradeTickerData[row].m_volumeDir == 1) //down
        {
            return "://Resources/Dark_icons/icon_module/arrowgreen_trick.svg";
        }
        else if(m_tradeTickerData[row].m_volumeDir == 2) //up
        {
            return "://Resources/Dark_icons/icon_module/arrowred_trick.svg";
        }
    }

    return "";

}
QVariant CTickerDataModel::data(const QModelIndex &index, int role)const
{
    if (!index.isValid())
        return QVariant();

    int column = index.column();

    if(role == Qt::DecorationRole && column == ColumnType::COLUMN_ONE_LABEL)
    {
        QString str = getIconPath(index);
        if(!str.isEmpty())
            return QIcon(str);
        else
            return "-";
    }

    switch (role)
    {
    case Qt::TextAlignmentRole: //文字对齐方式
        return getAlignmentFlag(index);
    case Qt::TextColorRole: //前景色
        return getColor(index);
    case Qt::DisplayRole: //显示的数据
        return getData(index);
    case Qt::BackgroundRole: //背景色
        return getBackgroundColor(index);
    default:
        return QVariant();
    }
   //还可以显示图片，提示等等
}
void CTickerDataModel::setColorManage(int row, const Quotation::TradeTickerItem &itemData)const
{
    m_colorManage->updateBackgroundColor(row,ColumnType::COLUMN_ONE_TIME,itemData.m_timeBackgroupCol);
    m_colorManage->updateBackgroundColor(row,ColumnType::COLUMN_ONE_PRICE,itemData.m_priceBackgroupCol);
    m_colorManage->updateBackgroundColor(row,ColumnType::COLUMN_ONE_VOLUMN,itemData.m_volumnBackgroupCol);
    m_colorManage->updateBackgroundColor(row,ColumnType::COLUMN_ONE_VOLUMN,itemData.m_arrowBackfroupCol);
}
QVariant CTickerDataModel::getBackgroundColor(const QModelIndex &index) const
{
    int row = index.row();
    int column = index.column();
    return m_colorManage->getBackgroundColor(column, QString::number(row));
}
QVariant CTickerDataModel::getAlignmentFlag(const QModelIndex &index) const
{
    if(!index.isValid())
        return QVariant();

    int colume = index.column();
    if(colume == ColumnType::COLUMN_ONE_VOLUMN)
        return Qt::AlignmentFlag(int(Qt::AlignVCenter | Qt::AlignRight));
    else
        return Qt::AlignmentFlag(int(Qt::AlignVCenter | Qt::AlignLeft));
}

QVariant CTickerDataModel::getColor(const QModelIndex &index) const
{
    QColor color(Qt::gray);
    if(!index.isValid())
        return color;

    int row = index.row();
    int column = index.column();

    if(m_tradeTickerData.find(row) == m_tradeTickerData.end())
        return color;

    const Quotation::TradeTickerItem itemData = m_tradeTickerData[row];
    if(column == ColumnType::COLUMN_ONE_PRICE)
        return itemData.m_priceCol;
    else if(column == ColumnType::COLUMN_ONE_VOLUMN)
        return itemData.m_volumeCol;
    else if(column == ColumnType::COLUMN_ONE_TIME)
        return QColor("#8789B1");
    else
        return color;
}


QVariant CTickerDataModel::getData(const QModelIndex &index) const
{
    if(!index.isValid())
        return QVariant();

    int row = index.row();
    if(m_tradeTickerData.find(row) == m_tradeTickerData.end())
        return QVariant();

    const Quotation::TradeTickerItem itemData = m_tradeTickerData[row];
    switch (index.column())
    {
    case ColumnType::COLUMN_ONE_TIME:
        return itemData.m_datetime;
    case ColumnType::COLUMN_ONE_PRICE:
        return itemData.m_price;
    case ColumnType::COLUMN_ONE_VOLUMN:
        return itemData.m_volume;
    default:
        return QVariant();
    }
}



// TickerColorManage class
// 这个类是实现背景色动态闪烁的
TickerColorManage::TickerColorManage()
{
    m_upColor   = UiData::GetInstance()->getThemeColor(UiData::ThemeColorType::QUOT_LEVEL_UP);
    m_downColor = UiData::GetInstance()->getThemeColor(UiData::ThemeColorType::QUOT_LEVEL_DOWN);
    m_srcColor  = UiData::GetInstance()->getThemeColor(UiData::ThemeColorType::QUOT_LEVEL_SRC);
    connect(UiData::GetInstance(), SIGNAL(themeChangedSignal(BaseConfig::ThemesType)), this, SLOT(on_themeChanged(BaseConfig::ThemesType)));
}

void TickerColorManage::on_themeChanged(BaseConfig::ThemesType)
{
    m_upColor   = UiData::GetInstance()->getThemeColor(UiData::ThemeColorType::QUOT_LEVEL_UP);
    m_downColor = UiData::GetInstance()->getThemeColor(UiData::ThemeColorType::QUOT_LEVEL_DOWN);
    m_srcColor  = UiData::GetInstance()->getThemeColor(UiData::ThemeColorType::QUOT_LEVEL_SRC);
}
TickerColorManage::~TickerColorManage()
{

}
void TickerColorManage::updateBackgroundColor( int row,int column, QColor color)
{
    QString key = QString::number(row);
    if(m_backgroundColorDataMap.find(key) == m_backgroundColorDataMap.end())
        m_backgroundColorDataMap[key] = ColorDataMap();

    BackgroundColorData data;
    if(color == m_srcColor){
        data.m_twinkleStep = 0;
    }
    else{
        data.m_twinkleStep = 5;
        data.m_red = (color.red() - m_srcColor.red()) / 5;
        data.m_green = (color.green() - m_srcColor.green()) / 5;
        data.m_blue = (color.blue() - m_srcColor.blue()) / 5;
    }
    m_backgroundColorDataMap[key][column] = data;
}

QColor TickerColorManage::getBackgroundColor(int column, const QString &key)
{
    if(m_backgroundColorDataMap.find(key) == m_backgroundColorDataMap.end())
        return m_srcColor;

    if(m_backgroundColorDataMap[key].find(column) == m_backgroundColorDataMap[key].end())
        return m_srcColor;

    BackgroundColorData &data = m_backgroundColorDataMap[key][column];
    if(data.m_twinkleStep > 0)
    {
        QColor change;
        change.setRed(m_srcColor.red() + data.m_red*data.m_twinkleStep);
        change.setGreen(m_srcColor.green() + data.m_green*data.m_twinkleStep);
        change.setBlue(m_srcColor.blue() + data.m_blue*data.m_twinkleStep);
        data.m_twinkleStep--;
        return change;
    }
    else if(data.m_twinkleStep == 0)
    {
        return m_srcColor;
    }
}

void TickerColorManage::clearData()
{
    m_backgroundColorDataMap.clear();
}