四、创建键盘数据模型

在设计好AbstractListModel之后，就是设定几个键鼠会用到的Model了。

一、按键

每个按键需要以下信息：

1、索引号，即在MCU端的索引，int；

2、普通按键出厂功能，3字节；

3、Fn组合键出厂功能，3字节；

4、当前普通按键出厂功能，3字节；

5、Fn组合键出厂功能，3字节；

6、该按键在矩阵里的行索引，int；

7、该按键在矩阵里的列索引，int；

8、如果该按键为鼠标按键，还需要一个鼠标按键功能，如左键、右键等，int；

#ifndef BTNINFOMODEL_H
#define BTNINFOMODEL_H

#include <QObject>
#include"abstractlistmodelbase.h"

class BtnInfoModel : public AbstractListModelBase
{
    Q_OBJECT
public:
    enum DataRoles{
        deviceIndex,  //索引号,int
        defaultStdUsage,//默认按键用途,VariantList
        defaultFnUsage,//默认组合键用途,VariantList
        stdUsage,   //当前按键用途,VariantList
        fnUsage, //当前组合键用途,VariantList
        row,
        col,
        mouseFunction
    };
    Q_ENUM(DataRoles)

    enum UsagePage {
        UsagePage_Disable,
        UsagePage_Default,
        UsagePage_Combination,
        UsagePage_Consumer,
        UsagePage_Mouse,
        UsagePage_SysCtrl,
        UsagePage_Macro,
        UsagePage_Custom,
    };
    Q_ENUM(UsagePage)

    enum MouseBtn {
        MouseBtn_Left,
        MouseBtn_Right,
        MouseBtn_Mid,
        MouseBtn_WheelUp,
        MouseBtn_WheelDown,
        MouseBtn_Forward,
        MouseBtn_Backward,
        MouseBtn_Top,
        MouseBnt_Bottom
    };
    Q_ENUM(MouseBtn)
public:
    explicit BtnInfoModel(QObject *parent = nullptr);

    QVariant byteArrayToVariant(const QByteArray&);
    QByteArray VariantTolByteArray(const QVariant&);
signals:

};

#endif // BTNINFOMODEL_H

二、灯效

每个灯效需要以下信息：

1、亮度，int

2、速度，int

3、运行方向，int

4、多彩模式，bool

5、用户自定义模式，bool

6、自定义色彩模型参数1，int

7、自定义色彩模型参数2，int

8、自定义色彩模型参数3，int

#ifndef LEDMODEL_H
#define LEDMODEL_H

#include<QObject>
#include"abstractlistmodelbase.h"

class LedModel : public AbstractListModelBase
{
    Q_OBJECT
public:
    enum DataRoles{
        lumin = Qt::UserRole + 1, //int
        speed,//int
        direction,//int
        multiColor,//bool
        userColor,//bool
        colorParam0,//int
        colorParam1,//int
        colorParam2,//int
    };

    Q_ENUM(DataRoles)

    enum EffectDirection: int
    {
        EffectDirection_Up,
        EffectDirection_Down,
        EffectDirection_Left,
        EffectDirection_Right,
    };

public:
    explicit LedModel(QObject *parent = nullptr);

signals:

};

#endif // LEDMODEL_H

三、全键自定义灯

每个按键灯需要以下信息：

1、索引号，int；

2、色彩，单色键盘或鼠标只有1个字节，RGB键盘3个字节；

class LedMapModel : public AbstractListModelBase
{
    Q_OBJECT
public:
    enum DataRoles
    {
        deviceIndex = Qt::UserRole + 1, //int
        color //VariantList
    };
    Q_ENUM(DataRoles)

public:
    explicit LedMapModel(QObject *parent = nullptr);

    QVariant byteArrayToVariant(const QByteArray&);
    QByteArray VariantTolByteArray(const QVariant&);
};

四、宏

一个宏信息需要以下信息：

1、用途页，int；

2、用途，int

3、持续时间：int

#ifndef MACROMODEL_H
#define MACROMODEL_H

#include <QObject>
#include"abstractlistmodelbase.h"

class MacroModel : public AbstractListModelBase
{
    Q_OBJECT
public:
    enum DataRoles{
        usagePage = Qt::UserRole + 1, //int
        usage, //int
        delayTime, //int
    };

    Q_ENUM(DataRoles)

    enum MacroUsagePage {
        MacroUsagePage_Empty,
        MacroUsagePage_KeyboardPress,
        MacroUsagePage_KeyboardRelease,
        MacroUsagePage_MouseBtnPress,
        MacroUsagePage_MouseBtnRelease,
        MacroUsagePage_MouseMoveX,
        MacroUsagePage_MouseMoveY,
    };
    Q_ENUM(MacroUsagePage)

    explicit MacroModel(QObject *parent = nullptr);

signals:

};

#endif // MACROMODEL_H

五、旋钮

旋钮与按键基本一致，多加了两条信息：旋钮索引号、旋钮动作；

#ifndef WHEELMODEL_H
#define WHEELMODEL_H

#include <QObject>
#include"abstractlistmodelbase.h"
class WheelModel : public AbstractListModelBase
{
    Q_OBJECT
public:
    enum DataRoles{
        deviceIndex,  //按键索引号,int
        wheelIndex,     //旋钮索引
        wheelFunction,  //旋钮动作
        defaultStdUsage,//默认按键用途,VariantList
        defaultFnUsage,//默认组合键用途,VariantList
        stdUsage,   //当前按键用途,VariantList
        fnUsage, //当前组合键用途,VariantList
        row,
        col
    };

    Q_ENUM(DataRoles)

    enum WheelFunc {
        WheelFunc_CCW,
        WheelFunc_CW,
        WheelFunc_Click
    };
    Q_ENUM(WheelFunc)

    explicit WheelModel(QObject *parent = nullptr);

    QVariant byteArrayToVariant(const QByteArray&);
    QByteArray VariantToByteArray(const QVariant&);

signals:

};

#endif // WHEELMODEL_H

六、鼠标

目前鼠标只有一个信息，Dpi值

#ifndef MOUSEMODEL_H
#define MOUSEMODEL_H

#include <QObject>
#include"abstractlistmodelbase.h"

class MouseModel : public AbstractListModelBase
{
    Q_OBJECT
public:
    enum DataRoles{
        dpiValue = Qt::UserRole + 1, //int
    };

    Q_ENUM(DataRoles)


    explicit MouseModel(QObject *parent = nullptr);

signals:

};
#endif // MOUSEMODEL_H

七、设备信息

需要以下信息：

1、名称，QString

2、图片路径，QUrl

3、设备路径，QString

#ifndef DEVICECARDMODEL_H
#define DEVICECARDMODEL_H

#include <QObject>
#include"abstractlistmodelbase.h"

class DeviceCardModel : public AbstractListModelBase
{
    Q_OBJECT
public:
    enum DataRoles{
        name, //QString
        imageUrl, //QUrl
        configUrl, //QUrl
        devicePath,//QString
    };
    Q_ENUM(DataRoles)

public:
    explicit DeviceCardModel(QObject *parent = nullptr);

signals:

};

#endif // DEVICECARDMODEL_H

八、基本功能

这个没有使用AbstractListModel，使用了Q_PROPERTY，这里面主要是一些功能的使能、基本设备信息配置信息，这些是从json文件里读取的。

#ifndef CONFIGMODEL_H
#define CONFIGMODEL_H

#include <QObject>
#include <QUrl>

class ConfigModel : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QUrl filePath READ filePath NOTIFY filePathChanged)
    Q_PROPERTY(QString deviceName READ deviceName NOTIFY deviceNameChanged)
    Q_PROPERTY(DeviceType deviceType READ deviceType NOTIFY deviceTypeChanged)
    Q_PROPERTY(bool updateEn READ updateEn NOTIFY updateEnChanged)
    Q_PROPERTY(bool stdBtnEn READ stdBtnEn NOTIFY stdBtnEnChanged)
    Q_PROPERTY(bool fnBtnEn READ fnBtnEn NOTIFY fnBtnEnChanged)
    Q_PROPERTY(bool wheelEn READ wheelEn NOTIFY wheelEnChanged)
    Q_PROPERTY(bool ledEn READ ledEn NOTIFY ledEnChanged)
    Q_PROPERTY(bool ledMapEn READ ledMapEn NOTIFY ledMapEnChanged)
    Q_PROPERTY(ColorMode colorMode READ colorMode NOTIFY colorModeChanged)
    Q_PROPERTY(ushort colorModeParam0 READ colorModeParam0 NOTIFY colorModeParam0Changed)
    Q_PROPERTY(ushort colorModeParam1 READ colorModeParam1 NOTIFY colorModeParam1Changed)
    Q_PROPERTY(ushort colorModeParam2 READ colorModeParam2 NOTIFY colorModeParam2Changed)
    Q_PROPERTY(int luminLimit READ luminLimit NOTIFY luminLimitChanged)
    Q_PROPERTY(int speedLimit READ speedLimit NOTIFY speedLimitChanged)
    Q_PROPERTY(int ledMapLimit READ ledMapLimit NOTIFY ledMapLimitChanged)
    Q_PROPERTY(bool macroEn READ macroEn NOTIFY macroEnChanged)
    Q_PROPERTY(bool usbRateEn READ usbRateEn NOTIFY usbRateEnChanged)
    Q_PROPERTY(bool sleepEn READ sleepEn NOTIFY sleepEnChanged)
    Q_PROPERTY(bool batteryEn READ batteryEn NOTIFY batteryEnChanged)
    Q_PROPERTY(int batteryLimit READ batteryLimit NOTIFY batteryLimitChanged)
    Q_PROPERTY(bool lockQuit READ lockQuit NOTIFY lockQuitChanged)
    Q_PROPERTY(bool shiftWASD READ shiftWASD NOTIFY shiftWASDChanged)
    Q_PROPERTY(bool lockGui READ lockGui NOTIFY lockGuiChanged)
    Q_PROPERTY(bool btnReponseEn READ btnReponseEn NOTIFY btnReponseEnChanged)
    Q_PROPERTY(bool otaEn READ otaEn NOTIFY otaEnChanged)
    Q_PROPERTY(QString otaUrl READ otaUrl NOTIFY otaUrlChanged)

    Q_PROPERTY(int macroItems READ macroItems NOTIFY macroItemsChanged)
    Q_PROPERTY(int macroSize READ macroSize NOTIFY macroSizeChanged)

    Q_PROPERTY(int row READ row NOTIFY rowChanged)
    Q_PROPERTY(int col READ col NOTIFY colChanged)

    Q_PROPERTY(bool dpiEnable READ dpiEnable NOTIFY dpiEnableChanged)
    Q_PROPERTY(int dpiLimitDown READ dpiLimitDown NOTIFY dpiLimitDownChanged)
    Q_PROPERTY(int dpiLimitUp READ dpiLimitUp NOTIFY dpiLimitUpChanged)
    Q_PROPERTY(int dpiStep READ dpiStep NOTIFY dpiStepChanged)
    Q_PROPERTY(int dpiItems READ dpiItems NOTIFY dpiItemsChanged)

    Q_PROPERTY(bool snapShotEn READ snapShotEn NOTIFY snapShotEnChanged)
    Q_PROPERTY(int snapShotItems READ snapShotItems NOTIFY snapShotItemsChanged)
public:
    enum DeviceType
    {
        DeviceType_Keyboard,
        DeviceType_Mouse,
    };

    Q_ENUM(DeviceType)

    enum ConnectType
    {
        ConnectType_SetReport,
        ConnectType_IntEp,
    };

    Q_ENUM(ConnectType)

    enum ColorMode
    {
        ColorMode_None,
        ColorMode_Rgb,
        ColorMode_Hsv,
        ColorMode_Hsl,
    };
    Q_ENUM(ColorMode)

public:
    explicit ConfigModel(QObject *parent = nullptr);

    QUrl filePath() const;
    QString deviceName() const;
    DeviceType deviceType() const;
    bool updateEn() const;
    bool stdBtnEn() const;
    bool fnBtnEn() const;
    bool wheelEn() const;
    bool ledEn() const;
    bool ledMapEn() const;
    ColorMode colorMode() const;
    ushort colorModeParam0() const;
    ushort colorModeParam1() const;
    ushort colorModeParam2() const;
    int luminLimit() const;
    int speedLimit() const;
    int ledMapLimit() const;
    bool macroEn() const;
    bool usbRateEn() const;
    bool sleepEn() const;
    bool batteryEn() const;
    int batteryLimit() const;
    bool lockQuit() const;
    bool lockGui() const;
    bool shiftWASD() const;
    bool btnReponseEn() const;
    bool otaEn() const;

    bool dpiEnable() const;
    int dpiLimitDown() const;
    int dpiLimitUp() const;
    int dpiStep() const;
    int dpiItems() const;

    int macroItems() const;
    int macroSize() const;

    bool snapShotEn() const;
    int snapShotItems() const;

    int row() const;
    int col() const;
    ushort deviceVid() const;
    ushort devicePid() const;
    ushort deviceUsagePage() const;
    ushort deviceUsage() const;
    ConnectType deviceConnectType() const;
    ushort bootVid() const;
    ushort bootPid() const;
    QString otaUrl() const;
    QString otaToken() const;

    QList<QStringList> effectLanguageName() const;
    QList<QStringList> userFunctionLanguageName() const;

    void setFilePath(const QUrl& path);
    void setDeviceName(const QString& name);
    void setDeviceType(DeviceType type);
    void setUpdateEn(bool enable);
    void setStdBtnEn(bool enable);
    void setFnBtnEn(bool enable);
    void setWheelEn(bool enable);
    void setLedEn(bool enable);
    void setLedMapEn(bool enable);
    void setColorMode(ColorMode mode);
    void setColorModeParam0(ushort param);
    void setColorModeParam1(ushort param);
    void setColorModeParam2(ushort param);
    void setLuminLimit(int limit);
    void setSpeedLimit(int limit);
    void setLedMapLimit(int limit);
    void setMacroEn(bool enable);
    void setUsbRateEn(bool enable);
    void setSleepEn(bool enable);
    void setBatteryEn(bool enable);
    void setBatteryLimit(int limit);
    void setLockQuit(bool enable);
    void setLockGui(bool enable);
    void setShiftWASD(bool enable);
    void setBtnReponseEn(bool enable);
    void setOtaEn(bool enable);
    void setEffectName(const QStringList& name);

    void setRow(int);
    void setCol(int);
    void setDeviceVid(ushort);
    void setDevicePid(ushort);
    void setDeviceUsagePage(ushort);
    void setDeviceUsage(ushort);
    void setDeviceConnectType(ConnectType);
    void setBootVid(ushort);
    void setBootPid(ushort);
    void setMacroItems(int);
    void setMacroSize(int);
    void setOtaUrl(const QString& url);
    void setOtaToken(const QString& token);

    void setDpiEnable(bool);
    void setDpiLimitDown(int);
    void setDpiLimitUp(int);
    void setDpiStep(int);
    void setDpiItems(int);

    void setSnapShotEn(bool);
    void setSnapShotItems(int);
private:
    QUrl m_filePath;
    QString m_deviceName;
    DeviceType m_deviceType;
    bool m_updateEn = false;
    bool m_stdBtnEn = false;
    bool m_fnBtnEn = false;
    bool m_wheelEn = false;
    bool m_ledEn = false;
    bool m_ledMapEn = false;
    ColorMode m_colorMode = ColorMode_None;
    ushort m_colorModeParam0 = 0;
    ushort m_colorModeParam1 = 0;
    ushort m_colorModeParam2 = 0;
    int m_luminLimit = 0;
    int m_speedLimit = 0;
    int m_ledMapLimit = 0;
    bool m_macroEn = false;
    bool m_usbRateEn = false;
    bool m_sleepEn = false;
    bool m_batteryEn = false;
    int m_batteryLimit = false;
    bool m_lockQuit = false;
    bool m_lockGui = false;
    bool m_shiftWASD = false;
    bool m_btnReponseEn = false;
    bool m_otaEn = false;
    QString m_otaToken;

    bool m_dpiEnable = false;
    int m_dpiLimitDown = 0;
    int m_dpiLimitUp = 0;
    int m_dpiStep = 0;
    int m_dpiItems = 0;

    bool m_snapShotEn = false;
    int m_snapShotItems = 0;

    int m_row = 0;
    int m_col = 0;
    ushort m_deviceVid;
    ushort m_devicePid;
    ushort m_deviceUsagePage;
    ushort m_deviceUsage;
    ConnectType m_deviceConnectType;
    ushort m_bootVid;
    ushort m_bootPid;


    int m_macroItems = 0;
    int m_macroSize = 0;

    QString m_otaUrl;


signals:
    void filePathChanged();
    void deviceNameChanged();
    void deviceTypeChanged();
    void updateEnChanged();
    void stdBtnEnChanged();
    void fnBtnEnChanged();
    void ledEnChanged();
    void ledMapEnChanged();
    void colorModeChanged();
    void colorModeParam0Changed();
    void colorModeParam1Changed();
    void colorModeParam2Changed();
    void luminLimitChanged();
    void speedLimitChanged();
    void ledMapLimitChanged();
    void macroEnChanged();
    void usbRateEnChanged();
    void sleepEnChanged();
    void batteryEnChanged();
    void batteryLimitChanged();
    void lockQuitChanged();
    void lockGuiChanged();
    void shiftWASDChanged();
    void btnReponseEnChanged();
    void otaEnChanged();
    void effectNameChanged();
    void macroItemsChanged();
    void macroSizeChanged();
    void wheelEnChanged();

    void rowChanged();
    void colChanged();

    void otaUrlChanged();

    void dpiEnableChanged();
    void dpiLimitDownChanged();
    void dpiLimitUpChanged();
    void dpiStepChanged();
    void dpiItemsChanged();

    void snapShotEnChanged();
    void snapShotItemsChanged();
};

#endif // CONFIGMODEL_H

九、杂项功能

这个没有使用AbstractListModel，使用了Q_PROPERTY，主要是一些当前设备其它小功能的设置与读取：

#ifndef MISCMODEL_H
#define MISCMODEL_H

#include <QObject>

class MiscModel : public QObject
{
    Q_OBJECT
    Q_PROPERTY(uchar versionMajor READ versionMajor NOTIFY versionMajorChanged)
    Q_PROPERTY(uchar versionMinor READ versionMinor NOTIFY versionMinorChanged)
    Q_PROPERTY(int effectIndex READ effectIndex WRITE setEffectIndex NOTIFY effectIndexChanged)
    Q_PROPERTY(uchar usbRate READ usbRate WRITE setUsbRate NOTIFY usbRateChanged)
    Q_PROPERTY(uchar btnReponse READ btnReponse WRITE setBtnReponse NOTIFY btnReponseChanged)
    Q_PROPERTY(ushort sleepTime READ sleepTime WRITE setSleepTime NOTIFY sleepTimeChanged)
    Q_PROPERTY(bool lockGui READ lockGui WRITE setLockGui NOTIFY lockGuiChanged)
    Q_PROPERTY(bool shiftWASD READ shiftWASD WRITE setShiftWASD NOTIFY shiftWASDChanged)
    Q_PROPERTY(bool lockQuit READ lockQuit WRITE setLockQuit NOTIFY lockQuitChanged)
    Q_PROPERTY(int batteryState READ batteryState WRITE setBatteryState NOTIFY batteryStateChanged)
    Q_PROPERTY(uchar batteryPercent READ batteryPercent WRITE setBatteryPercent NOTIFY batteryPercentChanged)

    Q_PROPERTY(int dpiIndex READ dpiIndex WRITE setDpiIndex NOTIFY dpiIndexChanged)

    Q_PROPERTY(int snapShotIndex READ snapShotIndex WRITE setSnapShotIndex NOTIFY snapShotIndexChanged)

public:
    enum BatteryState
    {
        BatteryState_Discharge,
        BatteryState_Charging,
        BatteryState_ChargeDone,
    };
    Q_ENUM(BatteryState);

public:
    explicit MiscModel(QObject *parent = nullptr);

    uchar versionMajor() const;
    uchar versionMinor() const;
    int effectIndex() const;
    uchar usbRate() const;
    uchar btnReponse() const;
    bool lockGui() const;
    bool shiftWASD() const;
    bool lockQuit() const;
    int batteryState() const;
    uchar batteryPercent() const;
    ushort sleepTime() const;
    int dpiIndex() const;
    int snapShotIndex() const;

    void setVersionMajor(uchar);
    void setVersionMinor(uchar);
    void setEffectIndex(int);
    void setUsbRate(uchar);
    void setBtnReponse(uchar);
    void setLockGui(bool);
    void setShiftWASD(bool);
    void setLockQuit(bool);
    void setBatteryState(int);
    void setBatteryPercent(uchar);
    void setSleepTime(ushort);

    void setEffectIndexFromDevice(int);
    void setUsbRateFromDevice(uchar);
    void setBtnReponseFromDevice(uchar);
    void setLockGuiFromDevice(bool);
    void setShiftWASDFromDevice(bool);
    void setLockQuitFromDevice(bool);
    void setSleepTimeFromDevice(ushort);

    void setDpiIndex(int);

    void setSnapShotIndex(int);

private:
    uchar m_versionMajor = 0;
    uchar m_versionMinor = 0;
    int m_effectIndex = -1;
    uchar m_usbRate = 1;
    uchar m_btnReponse = 8;
    bool m_lockGui = false;
    bool m_shiftWASD = false;
    bool m_lockQuit = false;
    int m_batteryState = BatteryState_Discharge;
    uchar m_batteryPercent = 0;
    ushort m_sleepTime = 0;

    int m_dpiIndex = 0;

    int m_snapShotIndex = 0;

signals:
    void versionMajorChanged();
    void versionMinorChanged();
    void effectIndexChanged();
    void usbRateChanged();
    void btnReponseChanged();
    void lockGuiChanged();
    void shiftWASDChanged();
    void lockQuitChanged();
    void batteryStateChanged();
    void batteryPercentChanged();
    void sleepTimeChanged();

    void effectIndexWrited();
    void usbRateWrited();
    void btnReponseWrited();
    void lockGuiWrited();
    void shiftWASDWrited();
    void lockQuitWrited();
    void sleepTimeWrited();

    void dpiIndexChanged();

    void snapShotIndexChanged();

};

#endif // MISCMODEL_H

十、集合

除了设备信息，剩下的所有model放到一个类里：

1、.h

#ifndef PROFILEMODEL_H
#define PROFILEMODEL_H

#include <QObject>

#include "configmodel.h"
#include "btninfomodel.h"
#include "ledmodel.h"
#include "miscmodel.h"
#include "ledmapmodel.h"
#include "macromodel.h"
#include "wheelmodel.h"
#include "mousemodel.h"

class ProfileModel : public QObject
{
    Q_OBJECT
    Q_PROPERTY(ConfigModel* configModel READ configModel NOTIFY configModelChanged)
    Q_PROPERTY(BtnInfoModel* btnModel READ btnModel NOTIFY btnModelChanged)
    Q_PROPERTY(WheelModel* wheelModel READ wheelModel NOTIFY wheelModelChanged)
    Q_PROPERTY(LedModel* ledModel READ ledModel NOTIFY ledModelChanged)
    Q_PROPERTY(MiscModel* miscModel READ miscModel NOTIFY miscModelChanged)
    Q_PROPERTY(MouseModel* mouseModel READ mouseModel NOTIFY mouseModelChanged)
    Q_PROPERTY(QObjectList ledMapModelList READ ledMapModelList NOTIFY ledMapModelListChanged)
    Q_PROPERTY(QObjectList macroModelList READ macroModelList NOTIFY macroModelListChanged)

public:

public:
    explicit ProfileModel(QObject *parent = nullptr);
    ~ProfileModel();

    ConfigModel* configModel() const;
    BtnInfoModel* btnModel() const;
    WheelModel* wheelModel() const;
    LedModel* ledModel() const;
    MiscModel* miscModel() const;
    MouseModel* mouseModel() const;

    QObjectList ledMapModelList() const;
    void appendLedMapModel();
    void clearLedMapModelList();
    Q_INVOKABLE void setLedMap(int mapIndex);

    QObjectList macroModelList() const;
    void appendMacroModel();
    void clearMacroModelList();
    void setMacro(int index);

    bool resetDevice();

private:
    ConfigModel* m_configModel;
    BtnInfoModel* m_btnModel;
    WheelModel* m_wheelModel;
    LedModel* m_ledModel;
    MiscModel* m_miscModel;
    MouseModel* m_mouseModel;
    QObjectList m_ledMapModelList;
    QObjectList m_macroModelList;
signals:
    void configModelChanged();
    void btnModelChanged();
    void ledModelChanged();
    void miscModelChanged();
    void ledMapModelListChanged();
    void macroModelListChanged();
    void wheelModelChanged();
    void mouseModelChanged();

    void setLedMapAll(int index);
    void setMacroSlot(int index);
};

#endif // PROFILEMODEL_H

2.cpp

#include "profilemodel.h"
#include "ledmapmodel.h"

ProfileModel::ProfileModel(QObject *parent)
    : QObject{parent}
{
    m_configModel = new ConfigModel(this);
    m_btnModel = new BtnInfoModel(this);
    m_wheelModel = new WheelModel(this);
    m_ledModel = new LedModel(this);
    m_miscModel = new MiscModel(this);
    m_mouseModel = new MouseModel(this);

}

ProfileModel::~ProfileModel()
{
    delete m_configModel;
    delete m_btnModel;
    delete m_wheelModel;
    delete m_ledModel;
    delete m_miscModel;
    delete m_mouseModel;
    clearLedMapModelList();
    clearMacroModelList();
}

ConfigModel* ProfileModel::configModel() const
{
    return m_configModel;
}

BtnInfoModel* ProfileModel::btnModel() const
{
    return m_btnModel;
}
WheelModel* ProfileModel::wheelModel() const
{
    return m_wheelModel;
}
LedModel* ProfileModel::ledModel() const
{
    return m_ledModel;
}


MiscModel* ProfileModel::miscModel() const
{
    return m_miscModel;
}

MouseModel* ProfileModel::mouseModel() const
{
    return m_mouseModel;
}

QObjectList ProfileModel::ledMapModelList() const
{
    return m_ledMapModelList;
}

//添加ledmapmodel
void ProfileModel::appendLedMapModel()
{
    LedMapModel* model = new LedMapModel(this);
    m_ledMapModelList.append(model);
    emit ledMapModelListChanged();
}

//清空ledmapmodel
void ProfileModel::clearLedMapModelList()
{
    for(int i=0;i<m_ledMapModelList.size();i++)
    {
        delete m_ledMapModelList[i];
    }
    m_ledMapModelList.clear();
}

//设置ledmap
void ProfileModel::setLedMap(int mapIndex)
{
    emit setLedMapAll(mapIndex);
}


QObjectList ProfileModel::macroModelList() const
{
    return m_macroModelList;
}

//添加宏
void ProfileModel::appendMacroModel()
{
    MacroModel* model = new MacroModel(this);
    m_macroModelList.append(model);
    emit macroModelListChanged();
}

//清空宏
void ProfileModel::clearMacroModelList()
{
    for(int i=0;i<m_macroModelList.size();i++)
    {
        delete m_macroModelList[i];
    }
    m_macroModelList.clear();
}

void ProfileModel::setMacro(int index)
{
    emit setMacroSlot(index);
}

//重置设备
bool ProfileModel::resetDevice()
{
    for(int i=0;i<btnModel()->rowCount();i++)
    {
        if(configModel()->stdBtnEn())
        {
            QVariant var = btnModel()->data(i,BtnInfoModel::defaultStdUsage);
            btnModel()->setData(i,var,BtnInfoModel::stdUsage);
        }
        if(configModel()->fnBtnEn())
        {
            QVariant var = btnModel()->data(i,BtnInfoModel::defaultFnUsage);
            btnModel()->setData(i,var,BtnInfoModel::fnUsage);
        }
    }

    if(configModel()->wheelEn()) {
        for(int i=0;i<wheelModel()->rowCount();++i) {

            if(configModel()->stdBtnEn()){
                QVariant var = wheelModel()->data(i,WheelModel::defaultStdUsage);
                wheelModel()->setData(i,var,WheelModel::stdUsage);
            }
            if(configModel()->fnBtnEn())
            {
                QVariant var = wheelModel()->data(i,WheelModel::defaultFnUsage);
                wheelModel()->setData(i,var,WheelModel::fnUsage);
            }
        }
    }


    if(configModel()->ledEn())
    {
        for(int i=0;i<ledModel()->rowCount();i++)
        {
            if(configModel()->luminLimit() != 0)
                ledModel()->setData(i,configModel()->luminLimit() - 1,LedModel::lumin);
            if(configModel()->speedLimit() != 0)
                ledModel()->setData(i,configModel()->speedLimit() - 1,LedModel::speed);
            ledModel()->setData(i,int(0),LedModel::direction);
            ledModel()->setData(i,true,LedModel::multiColor);
            ledModel()->setData(i,false,LedModel::userColor);
            ledModel()->setData(i,int(0),LedModel::colorParam0);
            ledModel()->setData(i,int(0),LedModel::colorParam1);
            ledModel()->setData(i,int(0),LedModel::colorParam2);
        }

        if(configModel()->ledMapEn())
        {
            for(int i = 0;i<ledMapModelList().size();i++)
            {
                QByteArray temp;
                temp.append((char)0);
                temp.append((char)0);
                temp.append((char)0);
                LedMapModel* model = (LedMapModel*)ledMapModelList().at(i);
                QVariant var = model->byteArrayToVariant(temp);
                for(int j=0;j<model->rowCount();j++)
                {
                    model->setData(j,var,LedMapModel::color);
                }
            }
        }
    }

    if(configModel()->dpiEnable()) {
        for(int i=0;i<mouseModel()->rowCount();++i) {
            mouseModel()->setData(i,configModel()->dpiLimitDown() + i*configModel()->dpiStep(),MouseModel::dpiValue);
        }
    }

    miscModel()->setLockGuiFromDevice(false);
    miscModel()->setLockQuitFromDevice(false);
    miscModel()->setShiftWASDFromDevice(false);
    miscModel()->setUsbRateFromDevice(1);
    miscModel()->setBtnReponseFromDevice(8);
    miscModel()->setEffectIndexFromDevice(0);
    miscModel()->setSleepTimeFromDevice(0);
    miscModel()->setDpiIndex(0);
    return true;
}