LVChat/accessPointModel.cpp at master · foruok/LVChat · 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
#include "accessPointModel.h"
#include <QVector>
#include "scanner.h"
#include "messengerConnection.h"
#include <QDebug>
#include "messengerManager.h"

typedef QVector<QString> VideoData;
class AccessPointModelPrivate
{
public:
    AccessPointModelPrivate()
        : m_current(0)
    {
        int role = Qt::UserRole;
        m_roleNames.insert(role++, "nickName");
        m_roleNames.insert(role++, "portraitIndex");
        m_roleNames.insert(role++, "address");
    }

    ~AccessPointModelPrivate()
    {
        clear();
    }

    void clear()
    {
        int count = m_accessPoints.size();
        if(count > 0)
        {
            for(int i = 0; i < count; i++)
            {
                delete m_accessPoints.at(i);
            }
            m_accessPoints.clear();
        }
    }

    QHash<int, QByteArray> m_roleNames;
    QVector<AccessPoint*> m_accessPoints;
    AccessPointScanner m_scanner;
    int m_current;
};

AccessPointModel::AccessPointModel(QObject *parent)
    : QAbstractListModel(parent)
    , m_dptr(new AccessPointModelPrivate)
{
    connect(&(m_dptr->m_scanner), SIGNAL(scanFinished()),
            this, SIGNAL(scanFinished()));
    connect(&(m_dptr->m_scanner), SIGNAL(newAccessPoint(AccessPoint*)),
            this, SLOT(onNewAccessPoint(AccessPoint*)));
}

AccessPointModel::~AccessPointModel()
{
    delete m_dptr;
}

int AccessPointModel::rowCount(const QModelIndex &parent) const
{
    return m_dptr->m_accessPoints.size();
}

QVariant AccessPointModel::data(const QModelIndex &index, int role) const
{
    AccessPoint *d = m_dptr->m_accessPoints[index.row()];
    switch(role - Qt::UserRole)
    {
    case 0:
        return d->m_nickName;
    case 1:
        return d->m_portraitIndex;
    case 2:
        return d->m_address.toString();
    default:
        return QVariant();
    }
}

QHash<int, QByteArray> AccessPointModel::roleNames() const
{
    return m_dptr->m_roleNames;
}

void AccessPointModel::scan()
{
    beginResetModel();

    m_dptr->clear();
    m_dptr->m_scanner.startScan();

    endResetModel();
}

void AccessPointModel::talkTo(int index)
{
    m_dptr->m_current = index;
    MessengerManager::instance()->talkTo(m_dptr->m_accessPoints.at(index));
}

QString AccessPointModel::currentNick()
{
    AccessPoint *ap = m_dptr->m_accessPoints.at(m_dptr->m_current);
    return ap->m_nickName;
}

int AccessPointModel::currentPortraitIndex()
{
    AccessPoint *ap = m_dptr->m_accessPoints.at(m_dptr->m_current);
    return ap->m_portraitIndex;
}

void AccessPointModel::onNewAccessPoint(AccessPoint *ap)
{
    int count = m_dptr->m_accessPoints.size();
    beginInsertRows(QModelIndex(), count, count);
    m_dptr->m_accessPoints.append(ap);
    endInsertRows();
}