← Back to branch summary

~ubuntu-branches/ubuntu/saucy/plasma-nm/saucy-proposed

« back to all changes in this revision

Viewing changes to kcm/AvailableConnectionsModel.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-08-16 19:07:09 UTC
  • Revision ID: package-import@ubuntu.com-20130816190709-ef9ydm9skigmg15l
Tags: upstream-0.0~git20130816
Import upstream version 0.0~git20130816

Show diffs side-by-side

added added

removed removed

Lines of Context:
kcm/AvailableConnectionsModel.cpp
 
1
/***************************************************************************
 
2
 *   Copyright (C) 2013 by Daniel Nicoletti <dantti12@gmail.com>           *
 
3
 *                                                                         *
 
4
 *   This program is free software; you can redistribute it and/or modify  *
 
5
 *   it under the terms of the GNU General Public License as published by  *
 
6
 *   the Free Software Foundation; either version 2 of the License, or     *
 
7
 *   (at your option) any later version.                                   *
 
8
 *                                                                         *
 
9
 *   This program is distributed in the hope that it will be useful,       *
 
10
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 
11
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 
12
 *   GNU General Public License for more details.                          *
 
13
 *                                                                         *
 
14
 *   You should have received a copy of the GNU General Public License     *
 
15
 *   along with this program; see the file COPYING. If not, write to       *
 
16
 *   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,  *
 
17
 *   Boston, MA 02110-1301, USA.                                           *
 
18
 ***************************************************************************/
 
19
 
 
20
#include "AvailableConnectionsModel.h"
 
21
 
 
22
#include <NetworkManagerQt/ConnectionSettings>
 
23
#include <NetworkManagerQt/ActiveConnection>
 
24
#include <NetworkManagerQt/Device>
 
25
#include <NetworkManagerQt/Settings>
 
26
#include <NetworkManagerQt/WirelessSetting>
 
27
#include <NetworkManagerQt/WirelessDevice>
 
28
#include <NetworkManagerQt/WimaxDevice>
 
29
#include <NetworkManagerQt/WimaxNsp>
 
30
 
 
31
#include <KDebug>
 
32
 
 
33
using namespace NetworkManager;
 
34
 
 
35
AvailableConnectionsModel::AvailableConnectionsModel(QObject *parent) :
 
36
    QStandardItemModel(parent)
 
37
{
 
38
}
 
39
 
 
40
void AvailableConnectionsModel::setDevice(const NetworkManager::Device::Ptr &device)
 
41
{
 
42
    if (m_device && m_device->uni() == device->uni()) {
 
43
        return;
 
44
    } else if (m_device) {
 
45
        m_device->disconnect(this);
 
46
    }
 
47
    m_device = device;
 
48
    removeRows(0, rowCount());
 
49
 
 
50
    if (device->type() == NetworkManager::Device::Wifi) {
 
51
        NetworkManager::WirelessDevice::Ptr wifi = device.dynamicCast<NetworkManager::WirelessDevice>();
 
52
        wifi->requestScan();
 
53
        connect(device.data(), SIGNAL(availableConnectionChanged()), SLOT(availableConnectionChanged()));
 
54
        foreach (const Connection::Ptr &connection, device->availableConnections()) {
 
55
            addConnection(connection);
 
56
        }
 
57
 
 
58
        connect(wifi.data(), SIGNAL(networkAppeared(QString)), SLOT(networkAppeared(QString)));
 
59
        connect(wifi.data(), SIGNAL(networkDisappeared(QString)), SLOT(networkDisappeared(QString)));
 
60
        foreach (const WirelessNetwork::Ptr &network, wifi->networks()) {
 
61
            addNetwork(network);
 
62
        }
 
63
    } else if (device->type() == NetworkManager::Device::Wimax) {
 
64
        NetworkManager::WimaxDevice::Ptr wiMax = device.dynamicCast<NetworkManager::WimaxDevice>();
 
65
        connect(device.data(), SIGNAL(availableConnectionChanged()), SLOT(availableConnectionChanged()));
 
66
        foreach (const Connection::Ptr &connection, device->availableConnections()) {
 
67
            addConnection(connection);
 
68
        }
 
69
 
 
70
        connect(wiMax.data(), SIGNAL(nspAppeared(QString)), SLOT(nspAppeared(QString)));
 
71
        connect(wiMax.data(), SIGNAL(nspDisappeared(QString)), SLOT(nspDisappeared(QString)));
 
72
        foreach (const QString &nsp, wiMax->nsps()) {
 
73
            NetworkManager::WimaxNsp::Ptr nspPtr = wiMax->findNsp(nsp);
 
74
            if (nspPtr) {
 
75
                addNspNetwork(nspPtr);
 
76
            }
 
77
        }
 
78
    } else {
 
79
        connect(device.data(), SIGNAL(availableConnectionChanged()), SLOT(availableConnectionChanged()));
 
80
        foreach (const Connection::Ptr &connection, device->availableConnections()) {
 
81
            addConnection(connection);
 
82
        }
 
83
    }
 
84
}
 
85
 
 
86
void AvailableConnectionsModel::availableConnectionChanged()
 
87
{
 
88
    Device *device = qobject_cast<NetworkManager::Device*>(sender());
 
89
    if (device) {
 
90
        Connection::List connections = device->availableConnections();
 
91
        foreach (const Connection::Ptr &connection, connections) {
 
92
            qWarning() << "Connection" << connection->name();
 
93
            if (!findConnectionItem(connection->path())) {
 
94
                qWarning() << "New connection" << connection->name();
 
95
                addConnection(connection);
 
96
            }
 
97
        }
 
98
 
 
99
        int i = 0;
 
100
        while (i < rowCount()) {
 
101
            Kinds kind = static_cast<Kind>(item(i)->data(RoleKinds).toUInt());
 
102
            if (kind == Connection) {
 
103
                bool found = false;
 
104
                QString path = item(i)->data(RoleConectionPath).toString();
 
105
                foreach (const Connection::Ptr &connection, connections) {
 
106
                    if (connection->path() == path) {
 
107
                        found = true;
 
108
                        break;
 
109
                    }
 
110
                }
 
111
 
 
112
                if (!found) {
 
113
                    qWarning() << "Remove connection" << path;
 
114
                    removeRow(i);
 
115
                    continue;
 
116
                }
 
117
            }
 
118
            ++i;
 
119
        }
 
120
    }
 
121
}
 
122
 
 
123
void AvailableConnectionsModel::connectionAdded(const QString &path)
 
124
{
 
125
    Connection::Ptr connection = findConnection(path);
 
126
    if (connection) {
 
127
        addConnection(connection);
 
128
    }
 
129
}
 
130
 
 
131
void AvailableConnectionsModel::connectionRemoved(const QString &path)
 
132
{
 
133
    QStandardItem *stdItem = findConnectionItem(path);
 
134
    if (stdItem) {
 
135
        removeRow(stdItem->row());
 
136
    }
 
137
}
 
138
 
 
139
void AvailableConnectionsModel::addConnection(const NetworkManager::Connection::Ptr &connection)
 
140
{
 
141
    QStandardItem *stdItem = findConnectionItem(connection->path());
 
142
    if (stdItem) {
 
143
        return;
 
144
    }
 
145
 
 
146
    stdItem = new QStandardItem;
 
147
    stdItem->setData(Connection, RoleKinds);
 
148
    stdItem->setData(connection->path(), RoleConectionPath);
 
149
 
 
150
    ConnectionSettings::Ptr settings = connection->settings();
 
151
    if (settings->connectionType() == ConnectionSettings::Wireless) {
 
152
        WirelessSetting::Ptr wirelessSetting;
 
153
        wirelessSetting = settings->setting(Setting::Wireless).dynamicCast<WirelessSetting>();
 
154
        stdItem->setData(wirelessSetting->ssid(), RoleNetworkID);
 
155
        stdItem->setData(wirelessSetting->macAddress(), RoleMacAddress);
 
156
        stdItem->setText(wirelessSetting->ssid());
 
157
    } else {
 
158
        stdItem->setText(connection->name());
 
159
    }
 
160
 
 
161
    appendRow(stdItem);
 
162
}
 
163
 
 
164
void AvailableConnectionsModel::networkAppeared(const QString &ssid)
 
165
{
 
166
    NetworkManager::WirelessDevice::Ptr wifi = m_device.dynamicCast<NetworkManager::WirelessDevice>();
 
167
    if (wifi) {
 
168
        WirelessNetwork::Ptr network = wifi->findNetwork(ssid);
 
169
        addNetwork(network);
 
170
    }
 
171
}
 
172
 
 
173
void AvailableConnectionsModel::networkDisappeared(const QString &ssid)
 
174
{
 
175
    QStandardItem *stdItem = findNetworkItem(ssid);
 
176
    if (stdItem) {
 
177
        removeRow(stdItem->row());
 
178
    }
 
179
}
 
180
 
 
181
void AvailableConnectionsModel::addNetwork(const WirelessNetwork::Ptr &network)
 
182
{
 
183
    QStandardItem *stdItem = findNetworkItem(network->ssid());
 
184
    connect(network.data(), SIGNAL(signalStrengthChanged(int)), SLOT(signalStrengthChanged(int)), Qt::UniqueConnection);
 
185
    if (!stdItem) {
 
186
        stdItem = new QStandardItem;
 
187
        stdItem->setData(network->ssid(), RoleNetworkID);
 
188
        stdItem->setData(Network | NetworkWireless, RoleKinds);
 
189
        stdItem->setText(network->ssid());
 
190
        appendRow(stdItem);
 
191
    } else {
 
192
        stdItem->setData(Network | Connection, RoleKinds);
 
193
    }
 
194
    bool isSecure = network->referenceAccessPoint()->capabilities() & AccessPoint::Privacy;
 
195
    stdItem->setData(isSecure, RoleSecurity);
 
196
    stdItem->setData(network->signalStrength(), RoleSignalStrength);
 
197
}
 
198
 
 
199
void AvailableConnectionsModel::signalStrengthChanged(int strength)
 
200
{
 
201
    WirelessNetwork *network = qobject_cast<WirelessNetwork*>(sender());
 
202
    QStandardItem *stdItem = findNetworkItem(network->ssid());
 
203
    if (stdItem) {
 
204
        stdItem->setData(strength, RoleSignalStrength);
 
205
    }
 
206
}
 
207
 
 
208
void AvailableConnectionsModel::nspAppeared(const QString &uni)
 
209
{
 
210
    NetworkManager::WimaxDevice::Ptr wimax = m_device.dynamicCast<NetworkManager::WimaxDevice>();
 
211
    if (wimax) {
 
212
        WimaxNsp::Ptr nsp = wimax->findNsp(uni);
 
213
        addNspNetwork(nsp);
 
214
    }
 
215
}
 
216
 
 
217
void AvailableConnectionsModel::nspDisappeared(const QString &name)
 
218
{
 
219
    QStandardItem *stdItem = findNetworkItem(name);
 
220
    if (stdItem) {
 
221
        removeRow(stdItem->row());
 
222
    }
 
223
}
 
224
 
 
225
void AvailableConnectionsModel::addNspNetwork(const WimaxNsp::Ptr &nsp)
 
226
{
 
227
    QStandardItem *stdItem = findNetworkItem(nsp->name());
 
228
    connect(nsp.data(), SIGNAL(signalQualityChanged(uint)), SLOT(signalQualityChanged(int)), Qt::UniqueConnection);
 
229
    if (!stdItem) {
 
230
        stdItem = new QStandardItem;
 
231
        stdItem->setData(nsp->uni(), RoleNetworkID);
 
232
        stdItem->setData(Network | NetworkNsp, RoleKinds);
 
233
        stdItem->setText(nsp->name());
 
234
        appendRow(stdItem);
 
235
    } else {
 
236
        stdItem->setData(Network | Connection, RoleKinds);
 
237
    }
 
238
    stdItem->setData(true, RoleSecurity);
 
239
    stdItem->setData(nsp->signalQuality(), RoleSignalStrength);
 
240
}
 
241
 
 
242
void AvailableConnectionsModel::signalQualityChanged(uint quality)
 
243
{
 
244
    WimaxNsp *nsp = qobject_cast<WimaxNsp*>(sender());
 
245
    QStandardItem *stdItem = findNetworkItem(nsp->name());
 
246
    if (stdItem) {
 
247
        stdItem->setData(quality, RoleSignalStrength);
 
248
    }
 
249
}
 
250
 
 
251
QStandardItem *AvailableConnectionsModel::findConnectionItem(const QString &path)
 
252
{
 
253
    for (int i = 0; i < rowCount(); ++i) {
 
254
        QStandardItem *stdItem = item(i);
 
255
        if (stdItem->data(RoleKinds).toUInt() & Connection &&
 
256
                stdItem->data(RoleConectionPath).toString() == path) {
 
257
            return stdItem;
 
258
        }
 
259
    }
 
260
 
 
261
    return 0;
 
262
}
 
263
 
 
264
QStandardItem *AvailableConnectionsModel::findNetworkItem(const QString &id)
 
265
{
 
266
    for (int i = 0; i < rowCount(); ++i) {
 
267
        QStandardItem *stdItem = item(i);
 
268
        if (stdItem->data(RoleNetworkID).toString() == id) {
 
269
            return stdItem;
 
270
        }
 
271
    }
 
272
 
 
273
    return 0;
 
274
}