honeymon/unknown18model.cpp at master · elvum/honeymon · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include "unknown18model.h"
#include "nodenames.h"

#include <QFont>

Unknown18Model::Unknown18Model(QObject *parent) : QAbstractTableModel(parent)
{
}

int Unknown18Model::rowCount(const QModelIndex &) const
{
    return unknown18Map.count();
}

int Unknown18Model::columnCount(const QModelIndex &) const
{
    return 3;
}

QVariant Unknown18Model::data(const QModelIndex &index, int role) const
{
    if (role == Qt::DisplayRole)
    {
        //get the value to display
        QMap<QString, record_t>::const_iterator i = unknown18Map.constBegin();
        int count=0;
        while (i != unknown18Map.constEnd()) {
            if(count==index.row()) {
                switch(index.column()) {
                case 0:
                {
                    quint32 id1=i.value().id1;
                    if(nn) return nn->idToName(id1);
                    return QString("%1") .arg(id1, 6, 16, QChar('0'));
                    break;
                }
                case 1:
                {
                    quint32 id2=i.value().id2;
                    if(nn) return nn->idToName(id2);
                    return QString("%1") .arg(id2, 6, 16, QChar('0'));
                    break;
                }
                case 2:
                {
                    QString s;
                    //print the hex data
                    for(int j=0; j<i.value().data.size(); j++)
                        s.append(QString("%1 ") .arg(i.value().data.at(j) & 0xFF, 2, 16, QChar('0')));
                    return s;
                    break;
                }
                default:
                    return QString("Unknown!");
                    break;
                }
            }

            ++i;
            ++count;
        }

    }
    if(role==Qt::FontRole)
    {
        if(index.column() == 2) {
            QFont f("Monospace");
            f.setPointSize(8);
            f.setStyleHint(QFont::TypeWriter);
            return f;
        } else {
            QFont f;
            f.setPointSize(8);
            return f;
        }
    }
    return QVariant();
}

QVariant Unknown18Model::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role == Qt::DisplayRole)
    {
        if (orientation == Qt::Horizontal) {
            switch (section)
            {
            case 0:
                return QString("ID1");
                break;
            case 1:
                return QString("ID2");
                break;
            case 2:
                return QString("Data");
                break;
            }
        }
    }
    if(role==Qt::FontRole)
    {
        QFont f;
        f.setPointSize(8);
        return f;
    }
    return QVariant();
}

void Unknown18Model::newData(quint32 id1, quint32 id2, QByteArray data)
{
    QString key = QString("%1:%2")
            .arg(id1, 6, 16, QChar('0'))
            .arg(id2, 6, 16, QChar('0'));

    record_t r;
    r.id1 = id1;
    r.id2 = id2;
    r.data = data;

    unknown18Map.insert(key, r);

    //for simplicity, request that the whole view is updated
    QModelIndex topLeft = createIndex(0,0);
    QModelIndex bottomRight = (createIndex(unknown18Map.size(), 3));

    emit layoutChanged();
    emit dataChanged(topLeft, bottomRight);

}

void Unknown18Model::setNodeNameHelper(NodeNames *n)
{
    nn=n;
}