← Back to branch summary

~ubuntu-branches/ubuntu/lucid/knetworkmanager/lucid

« back to all changes in this revision

Viewing changes to knetworkmanager-0.7/src/knetworkmanager-tray.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2008-09-26 12:40:26 UTC
  • mfrom: (1.2.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20080926124026-t5fr920l4lf2l6hz
Tags: 1:0.7svn864988-0ubuntu1
https://launchpad.net/bugs/259278
New upstream snapshot, now works with current NM API, 
closes LP: #259278

Show diffs side-by-side

added added

removed removed

Lines of Context:
knetworkmanager-0.7/src/knetworkmanager-tray.cpp
 
1
/***************************************************************************
 
2
 *
 
3
 * knetworkmanager-tray.cpp - A NetworkManager frontend for KDE
 
4
 *
 
5
 * Copyright (C) 2005, 2006 Novell, Inc.
 
6
 *
 
7
 * Author: Timo Hoenig        <thoenig@suse.de>, <thoenig@nouse.net>
 
8
 *         Will Stephenson    <wstephenson@suse.de>, <wstephenson@kde.org>
 
9
 *         Valentine Sinitsyn <e_val@inbox.ru>
 
10
 *         Helmut Schaa       <hschaa@suse.de>, <helmut.schaa@gmx.de>
 
11
 *
 
12
 * This program is free software; you can redistribute it and/or modify
 
13
 * it under the terms of the GNU General Public License as published by
 
14
 * the Free Software Foundation; either version 2 of the License, or
 
15
 * (at your option) any later version.
 
16
 *
 
17
 * This program is distributed in the hope that it will be useful,
 
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
20
 * GNU General Public License for more details.
 
21
 *
 
22
 * You should have received a copy of the GNU General Public License
 
23
 * along with this program; if not, write to the Free Software
 
24
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
25
 *
 
26
 **************************************************************************/
 
27
 
 
28
class WirelessDialog;
 
29
 
 
30
#include <qsignalmapper.h>
 
31
#include <qevent.h>
 
32
#include <qvbox.h>
 
33
#include <qlayout.h>
 
34
#include <qpushbutton.h>
 
35
#include <qpixmap.h>
 
36
#include <qpixmapcache.h>
 
37
#include <qpainter.h>
 
38
#include <qstyle.h>
 
39
#include <qvaluelist.h>
 
40
#include <dcopclient.h>
 
41
#include <dbus/qdbusobjectpath.h>
 
42
#include <kdebug.h>
 
43
#include <kdialogbase.h>
 
44
#include <knotifyclient.h>
 
45
#include <knotifydialog.h>
 
46
#include <klocale.h>
 
47
#include <kstdguiitem.h>
 
48
#include <khelpmenu.h>
 
49
#include <kprocess.h>
 
50
#include <kiconloader.h>
 
51
#include <kconfig.h>
 
52
#include <kmessagebox.h>
 
53
 
 
54
#include <NetworkManager.h>
 
55
 
 
56
#include <dbus/qdbuserror.h>
 
57
 
 
58
#include "vpn_tray_component.h"
 
59
#include "devicetraycomponent.h"
 
60
#include "knetworkmanager-cellular_device_tray.h"
 
61
#include "knetworkmanager-cellular_device.h"
 
62
#include "knetworkmanager-device.h"
 
63
#include "knetworkmanager-devicestore.h"
 
64
#include "knetworkmanager-tray.h"
 
65
#include "knetworkmanager-menu_subhead.h"
 
66
#include "knetworkmanager-nm_proxy.h"
 
67
#include "knetworkmanager-connection_setting_info.h"
 
68
#include "knetworkmanager-connection_settings_dialog.h"
 
69
#include "knetworkmanager-connection_store.h"
 
70
#include "knetworkmanager-vpn_connection.h"
 
71
#include "knetworkmanager-connection.h"
 
72
#include "knetworkmanager-storage.h"
 
73
#include "knetworkmanager-connection_editor.h"
 
74
#include "knetworkmanager-vpnauthenticationdialog.h"
 
75
#include "knetworkmanager-wired_device.h"
 
76
#include "knetworkmanager-wired_device_tray.h"
 
77
#include "knetworkmanager-wireless_device_tray.h"
 
78
#include "knetworkmanager-wireless_device.h"
 
79
 
 
80
#define KDED_NETWORK_NAME "NMNetwork"
 
81
 
 
82
class TrayPrivate
 
83
{
 
84
        public:
 
85
                TrayPrivate(QObject* parent)
 
86
                        : foregroundTrayComponent(0)
 
87
                  , signalMapper(parent, "signal_mapper")
 
88
                  , current_idx(0)
 
89
                {}
 
90
                ~TrayPrivate() {}
 
91
 
 
92
                static Tray* tray;
 
93
                QValueList<TrayComponent*> trayComponents;
 
94
                DeviceTrayComponent * foregroundTrayComponent;
 
95
                QSignalMapper signalMapper;
 
96
                QMap<int, QPair<ConnectionSettings::Connection*, Device*> > act_conn_map;
 
97
                int current_idx;
 
98
};
 
99
 
 
100
Tray* TrayPrivate::tray = NULL;
 
101
 
 
102
Tray* Tray::getInstance()
 
103
{
 
104
        if (TrayPrivate::tray)
 
105
                return TrayPrivate::tray;
 
106
        else return (TrayPrivate::tray = new Tray());
 
107
}
 
108
 
 
109
void Tray::slotEditConnections()
 
110
{
 
111
        ConnectionEditorImpl* dlg = new ConnectionEditorImpl(this);
 
112
        dlg->show();
 
113
}
 
114
 
 
115
void Tray::slotEnableWireless()
 
116
{
 
117
        NMProxy* nm = NMProxy::getInstance();
 
118
        QDBusError err;
 
119
        if (!nm) return;
 
120
 
 
121
        nm->setWirelessEnabled(true, err);
 
122
}
 
123
 
 
124
void Tray::slotDisableWireless()
 
125
{
 
126
        NMProxy* nm = NMProxy::getInstance();
 
127
        QDBusError err;
 
128
        if (!nm) return;
 
129
 
 
130
        nm->setWirelessEnabled(false, err);
 
131
}
 
132
 
 
133
void Tray::slotOfflineMode()
 
134
{
 
135
        NMProxy* nm = NMProxy::getInstance();
 
136
        QDBusError err;
 
137
        if (!nm) return;
 
138
 
 
139
        nm->Sleep(true, err);
 
140
}
 
141
 
 
142
void Tray::slotOnlineMode()
 
143
{
 
144
        NMProxy* nm = NMProxy::getInstance();
 
145
        QDBusError err;
 
146
        if (!nm) return;
 
147
 
 
148
        nm->Sleep(false, err);
 
149
}
 
150
 
 
151
void Tray::contextMenuAboutToShow (KPopupMenu* menu)
 
152
{
 
153
        QDBusError err;
 
154
        NMProxy* nm = NMProxy::getInstance();
 
155
 
 
156
        // clear menu
 
157
        menu->clear();
 
158
 
 
159
        if (nm->isNMRunning())
 
160
        {
 
161
 
 
162
    // actions for each Device
 
163
                for (QValueList<TrayComponent*>::Iterator it = d->trayComponents.begin();
 
164
                  it != d->trayComponents.end();
 
165
                ++it)
 
166
          {
 
167
              (*it)->addMenuItems(menu);
 
168
          }
 
169
 
 
170
                // New connection
 
171
                KAction * newConnAction = 0;
 
172
                int devices =  d->trayComponents.count();
 
173
                if ( devices > 1 ) {
 
174
                        newConnAction = actionCollection ()->action ("new_connection_menu");
 
175
                        KActionMenu* newConnActionMenu = static_cast<KActionMenu*>(newConnAction);
 
176
                        newConnActionMenu->popupMenu()->clear();
 
177
                        for (QValueList<TrayComponent*>::Iterator it = d->trayComponents.begin();
 
178
                                        it != d->trayComponents.end();
 
179
                                        ++it)
 
180
                        {
 
181
                                DeviceTrayComponent* dev_comp = dynamic_cast<DeviceTrayComponent*> (*it);
 
182
                                KAction * deviceNewConnAction = 0;
 
183
                                if (dev_comp)
 
184
                                {
 
185
                                        QString actionName = QString("new_connection_%1").arg(dev_comp->device()->getInterface());
 
186
                                        deviceNewConnAction = actionCollection ()->action (actionName);
 
187
                                        if (!deviceNewConnAction) {
 
188
                                                deviceNewConnAction = new KAction (dev_comp->device()->getInterface(), 0, (*it), SLOT(newConnection()), actionCollection(), actionName);
 
189
                                        }
 
190
                                        newConnActionMenu->insert(deviceNewConnAction);
 
191
                                }
 
192
                        }
 
193
                } else if ( devices == 1 ) {
 
194
                        newConnAction = actionCollection ()->action ("new_connection");
 
195
                        QObject::disconnect( newConnAction, SIGNAL(activated()) );
 
196
                        QObject::connect( newConnAction, SIGNAL(activated()), d->trayComponents[0], SLOT(newConnection()));
 
197
                }
 
198
                if (newConnAction) {
 
199
                        newConnAction->plug(menu);
 
200
                }
 
201
        
 
202
          // turn things off
 
203
                if (nm)
 
204
                {
 
205
                        KActionMenu* disableStuffActionMenu = static_cast<KActionMenu*>(actionCollection ()->action ("deactivate_menu") );
 
206
                        disableStuffActionMenu->popupMenu()->clear();
 
207
                        QValueList<QPair<ConnectionSettings::Connection*, Device*> > map = nm->getActiveConnectionsMap();
 
208
                        d->act_conn_map.clear();
 
209
        
 
210
                        for (QValueList<QPair<ConnectionSettings::Connection*, Device*> >::Iterator it = map.begin(); it != map.end(); ++it)
 
211
                        {
 
212
                                ConnectionSettings::GenericConnection* conn = dynamic_cast<ConnectionSettings::GenericConnection*>((*it).first);
 
213
                                Device* dev = (*it).second;
 
214
 
 
215
                                if (!conn)
 
216
                                        continue;
 
217
 
 
218
                                QString actionName = QString("disable_connection_%1_%2").arg(conn->getID()).arg(dev ? dev->getInterface() : "");
 
219
                                KAction * deviceNewConnAction = actionCollection ()->action (actionName);
 
220
                                QString actionText = conn->getInfoSetting()->getName();
 
221
                                if (dev)
 
222
                                        actionText += QString(" (%1)").arg(dev->getInterface());
 
223
 
 
224
                                if (!deviceNewConnAction) {
 
225
                                        deviceNewConnAction = new KAction (actionText, 0, &d->signalMapper, SLOT(map()), actionCollection(), actionName);
 
226
                                }
 
227
                                d->signalMapper.setMapping(deviceNewConnAction, d->current_idx);
 
228
                                d->act_conn_map.insert(d->current_idx, QPair<ConnectionSettings::Connection*, Device*> (conn, dev));
 
229
                                d->current_idx++;
 
230
                                disableStuffActionMenu->insert(deviceNewConnAction);    
 
231
                        }
 
232
 
 
233
                        // disable wireless
 
234
                        if (nm->getWirelessHardwareEnabled(err))
 
235
                        {
 
236
                                KAction* wireless = NULL;
 
237
                                if (nm->getWirelessEnabled(err)) {
 
238
                                        wireless = actionCollection ()->action ("disable_wireless");
 
239
                                } else {
 
240
                                        wireless = actionCollection ()->action ("enable_wireless");
 
241
                                }
 
242
                                disableStuffActionMenu->insert(wireless);
 
243
                        }
 
244
 
 
245
                        // offline vs. online mode
 
246
                        KAction* switch_mode = NULL;
 
247
                        if (nm->getState(err) != NM_STATE_ASLEEP) {
 
248
                                switch_mode = actionCollection ()->action ("offline_mode");
 
249
                        }
 
250
                        else {
 
251
                                switch_mode = actionCollection ()->action ("online_mode");
 
252
                        }
 
253
                        disableStuffActionMenu->insert(switch_mode);
 
254
 
 
255
                        disableStuffActionMenu->plug(menu);
 
256
                }
 
257
        }
 
258
        else
 
259
        {
 
260
                Subhead* subhead = new Subhead (menu, "subhead", i18n("NetworkManager is not running"), SmallIcon("stop", QIconSet::Automatic));
 
261
                menu->insertItem (subhead, -1, -1);
 
262
        }
 
263
 
 
264
        // Notifications
 
265
        KAction* notif = actionCollection()->action("configure_notifications");
 
266
        notif->plug(menu);
 
267
 
 
268
        // Connection Editor
 
269
        KAction* edit = actionCollection ()->action ("edit_connections");
 
270
        edit->plug(menu);
 
271
 
 
272
        // quit
 
273
        menu->insertSeparator ();
 
274
        KAction* quitAction = actionCollection ()->action (KStdAction::name (KStdAction::Quit));
 
275
        if (quitAction)
 
276
                quitAction->plug (menu);
 
277
}
 
278
 
 
279
void
 
280
Tray::slotStateChanged(Q_UINT32 state)
 
281
{
 
282
        NMState nm_state = (NMState) state;
 
283
        // change tray icon according to NM's state
 
284
        switch(nm_state)
 
285
        {
 
286
                case NM_STATE_UNKNOWN:
 
287
                case NM_STATE_ASLEEP:
 
288
                case NM_STATE_CONNECTING:
 
289
                case NM_STATE_DISCONNECTED:
 
290
                        setPixmap (loadIcon ("knetworkmanager_disabled"));
 
291
                        break;
 
292
                case NM_STATE_CONNECTED:
 
293
                        setPixmap (loadIcon ("knetworkmanager"));
 
294
                        break;
 
295
        }
 
296
}
 
297
 
 
298
void
 
299
Tray::enterEvent (QEvent* /*e*/)
 
300
{
 
301
        // show tooltip
 
302
        QToolTip::remove (this);
 
303
        QString tooltip = "";
 
304
 
 
305
        // build up the tooltip from all tray components
 
306
        for (QValueList<TrayComponent*>::Iterator it = d->trayComponents.begin(); it != d->trayComponents.end(); ++it)
 
307
        {
 
308
                TrayComponent* comp = *it;
 
309
                if (comp->getToolTipText().isEmpty())
 
310
                        continue;
 
311
                if (!tooltip.isEmpty())
 
312
                        tooltip += "\n\n";
 
313
                tooltip += comp->getToolTipText().join("\n");
 
314
        }
 
315
        if (!tooltip.isEmpty())
 
316
                QToolTip::add (this, tooltip);
 
317
}
 
318
 
 
319
void 
 
320
Tray::slotVPNSecretsNeeded(ConnectionSettings::Connection* connection, ConnectionSettings::ConnectionSetting* setting, const QStringList& hints, bool request_new)
 
321
{
 
322
#warning Implement Tray::slotVPNSecretsNeeded to handle parms properly
 
323
        Q_UNUSED(setting);
 
324
        Q_UNUSED(hints);
 
325
        Q_UNUSED(request_new);
 
326
 
 
327
        printf("Tray::slotVPNSecretsNeeded\n");
 
328
        ConnectionSettings::VPNConnection* conn = dynamic_cast<ConnectionSettings::VPNConnection*>(connection);
 
329
        VPNAuthenticationDialog* auth = new VPNAuthenticationDialog(conn, this, "vpnauth");
 
330
        auth->show();
 
331
}
 
332
 
 
333
void 
 
334
Tray::slotSecretsNeeded(ConnectionSettings::Connection* connection, ConnectionSettings::ConnectionSetting* setting, const QStringList& hints, bool request_new)
 
335
{
 
336
        Storage* storage = Storage::getInstance();
 
337
        bool hasSecretsStored = storage->hasSecretsStored(connection, setting);
 
338
 
 
339
        // FIXME ugly secrets handling for VPN
 
340
        if (connection->getType() == NM_SETTING_VPN_SETTING_NAME)
 
341
        {
 
342
                slotVPNSecretsNeeded(connection, setting, hints, request_new);
 
343
                return;
 
344
        }
 
345
 
 
346
        // default secrets handling for all other connection types
 
347
        // 1) if we have secrets stored, restore them and send them back to NM
 
348
        // 2) if NM requests new secrets we should allow the user to retry the
 
349
        //    connection or to edit it
 
350
 
 
351
        if (hasSecretsStored && !request_new)
 
352
        {
 
353
                // We have secrets stored, restore them
 
354
                if (storage->restoreSecrets(connection, setting))
 
355
                {
 
356
                        connection->slotSecretsProvided(setting);
 
357
                }
 
358
        }
 
359
        else
 
360
        {
 
361
                // NM wants completely new secrets
 
362
                // FIXME: not implemented yet
 
363
                connection->slotSecretsError();
 
364
 
 
365
                //ConnectionSettingsDialogImpl* dlg = new ConnectionSettingsDialogImpl(NULL, connection, setting, this, "connect_something", false, Qt::WDestructiveClose);
 
366
                //dlg->show();
 
367
        }
 
368
}
 
369
 
 
370
void Tray::slotAddDeviceTrayComponent(Device* dev)
 
371
{
 
372
        if (dev)
 
373
                createDeviceTrayComponent(dev);
 
374
}
 
375
 
 
376
void Tray::slotRemoveDeviceTrayComponent(Device* dev)
 
377
{
 
378
        for (QValueList<TrayComponent*>::Iterator it = d->trayComponents.begin(); it != d->trayComponents.end(); ++it)
 
379
        {
 
380
                DeviceTrayComponent* dev_comp = dynamic_cast<DeviceTrayComponent*>(*it);
 
381
                if (!dev_comp)
 
382
                        continue;
 
383
 
 
384
                if (dev_comp->device() == dev)
 
385
                {
 
386
                        if (d->foregroundTrayComponent && dev_comp->device() == d->foregroundTrayComponent->device() ) {
 
387
                                d->foregroundTrayComponent = 0;
 
388
                        }
 
389
 
 
390
                        // remove the appropriate action
 
391
                        QString actionName = QString("new_connection_%1").arg(dev_comp->device()->getInterface());
 
392
                        KAction * deviceNewConnAction = actionCollection ()->action (actionName);
 
393
                        
 
394
                        if (!deviceNewConnAction)
 
395
                        {
 
396
                                delete deviceNewConnAction;
 
397
                                deviceNewConnAction = NULL;
 
398
                        }
 
399
                        // remove device_tray and delete it
 
400
                        d->trayComponents.remove(it);
 
401
                        delete dev_comp;
 
402
 
 
403
                        if (contextMenu()->isVisible()) {
 
404
                                contextMenu()->hide();
 
405
                        }
 
406
 
 
407
                        break;
 
408
                }
 
409
        }
 
410
}
 
411
 
 
412
void Tray::createDeviceTrayComponent(Device* dev)
 
413
{
 
414
        bool trayExists = false;
 
415
 
 
416
        if (!dev) return;
 
417
 
 
418
        // check if we have already a trayicon for this device
 
419
        for (QValueList<TrayComponent*>::Iterator it = d->trayComponents.begin(); it != d->trayComponents.end(); ++it)
 
420
        {       
 
421
                DeviceTrayComponent* dev_comp = dynamic_cast<DeviceTrayComponent*> (*it);
 
422
                if (dev_comp)
 
423
                        if (dev_comp->device() == dev)
 
424
                        {
 
425
                                trayExists = true;
 
426
                                break;
 
427
                        }
 
428
        }
 
429
 
 
430
        // create the appropriate device tray icon
 
431
        if (!trayExists)
 
432
        {
 
433
                DeviceTrayComponent* devTray = 0;
 
434
                // different tray icons for different device types!
 
435
                switch (dev->getDeviceType())
 
436
                {
 
437
                        case DEVICE_TYPE_802_3_ETHERNET:
 
438
                devTray = new WiredDeviceTray(dynamic_cast<WiredDevice*>(dev), this, "wired_device_tray");
 
439
                                break;
 
440
                        case DEVICE_TYPE_802_11_WIRELESS:
 
441
                devTray = new WirelessDeviceTray(static_cast<WirelessDevice*>(dev), this, "wireless_device_tray");
 
442
                                break;
 
443
                        case DEVICE_TYPE_GSM:
 
444
                        case DEVICE_TYPE_CDMA:
 
445
                devTray = new CellularDeviceTray(static_cast<CellularDevice*>(dev), this, "cellular_device_tray");
 
446
                                break;
 
447
                        default:
 
448
                                kdWarning() << k_funcinfo << "UDI: " << dev->getUdi() << " has unknown devicetype: " << dev->getDeviceType() << endl;
 
449
                }
 
450
                if(devTray)
 
451
                {
 
452
                        connect( devTray, SIGNAL(needsCenterStage(TrayComponent*,bool)),
 
453
                                        SLOT(trayComponentNeedsCenterStage(TrayComponent*,bool)));
 
454
                        connect( devTray, SIGNAL(uiUpdated()), SLOT(trayUiChanged()));
 
455
                        d->trayComponents.append(devTray);
 
456
            //WILLTODO: sort
 
457
                }
 
458
        }
 
459
}
 
460
 
 
461
void Tray::createVPNTrayComponent()
 
462
{
 
463
        bool trayExists = false;
 
464
 
 
465
        // check if we have already a trayicon for this device
 
466
        for (QValueList<TrayComponent*>::Iterator it = d->trayComponents.begin(); it != d->trayComponents.end(); ++it)
 
467
        {       
 
468
                VPNTrayComponent* vpn_comp = dynamic_cast<VPNTrayComponent*> (*it);
 
469
                if (vpn_comp)
 
470
                {
 
471
                        trayExists = true;
 
472
                        break;
 
473
                }
 
474
        }
 
475
 
 
476
        // create the appropriate device tray icon
 
477
        if (!trayExists)
 
478
        {
 
479
                TrayComponent* devTray = new VPNTrayComponent(this, "vpn_device_tray");
 
480
                if(devTray)
 
481
                {
 
482
                        d->trayComponents.append(devTray);
 
483
            //WILLTODO: sort
 
484
                }
 
485
        }
 
486
}
 
487
 
 
488
void Tray::updateDeviceTrays()
 
489
{
 
490
        // create one tray-icon for each device
 
491
        DeviceStore* store = DeviceStore::getInstance();        
 
492
        QValueList<Device*> devices = store->getDevices();
 
493
 
 
494
        // check for newly added devices
 
495
        for (QValueList<Device*>::iterator it = devices.begin(); it != devices.end(); ++it)
 
496
        {
 
497
                Device* dev = (*it);
 
498
                if (dev)
 
499
                        createDeviceTrayComponent(dev);
 
500
                else
 
501
                        kdWarning() << k_funcinfo << "got a NULL-Device" << endl;
 
502
        }
 
503
 
 
504
        // add the VPN componenet as it is not associated with a device
 
505
        createVPNTrayComponent();
 
506
}
 
507
 
 
508
void Tray::mousePressEvent( QMouseEvent *e )
 
509
{
 
510
    if ( !rect().contains( e->pos() ) ) {
 
511
        return;
 
512
    }
 
513
    switch ( e->button() ) {
 
514
        case LeftButton:
 
515
            contextMenuAboutToShow(contextMenu());
 
516
            contextMenu()->popup(e->globalPos());
 
517
            break;
 
518
        default:
 
519
            KSystemTray::mousePressEvent( e );
 
520
            break;
 
521
    }
 
522
}
 
523
 
 
524
void Tray::slotDeactivateConnection(int index)
 
525
{
 
526
        ConnectionSettings::Connection* conn = d->act_conn_map[index].first;
 
527
        Device* dev = d->act_conn_map[index].second;
 
528
        NMProxy* nm = NMProxy::getInstance();
 
529
 
 
530
        if (conn)
 
531
                nm->deactivateConnection(conn, dev);
 
532
}
 
533
 
 
534
void Tray::trayComponentNeedsCenterStage(TrayComponent *component, bool needsIt)
 
535
{
 
536
        DeviceTrayComponent * dtc = dynamic_cast<DeviceTrayComponent*>(component);
 
537
        if (dtc) {
 
538
                kdDebug() << k_funcinfo << dtc->device()->getInterface() << " : " << needsIt << endl;
 
539
                Device * device = dtc->device();
 
540
                if (needsIt) {
 
541
                        if (d->foregroundTrayComponent) {
 
542
                                disconnect(d->foregroundTrayComponent->device(), SIGNAL(StateChanged(NMDeviceState)), this, 0 );
 
543
                        }
 
544
                        d->foregroundTrayComponent = dtc;
 
545
                        connect(device, SIGNAL(StateChanged(NMDeviceState)),
 
546
                                        SLOT(slotUpdateDeviceState(NMDeviceState)));
 
547
                } else {
 
548
                        disconnect(device, SIGNAL(StateChanged(NMDeviceState)), this, 0 );
 
549
                        //use active default
 
550
                        NMProxy* nm = NMProxy::getInstance();
 
551
                        device = nm->getDefaultDevice();
 
552
                        if ( device ) {
 
553
                                // identify the new foreground
 
554
                                for (QValueList<TrayComponent*>::Iterator it = d->trayComponents.begin(); it != d->trayComponents.end(); ++it)
 
555
                                {       
 
556
                                        DeviceTrayComponent* newDtc = dynamic_cast<DeviceTrayComponent*> (*it);
 
557
                                        if ( newDtc && newDtc->device() == device ) {
 
558
                                                d->foregroundTrayComponent = newDtc;
 
559
                                                break;
 
560
                                        }
 
561
                                }
 
562
                                kdDebug() << "  Device " << dtc->device()->getInterface() << " background, new foreground device: " << device->getInterface() << endl;
 
563
                                connect(device, SIGNAL(StateChanged(NMDeviceState)),
 
564
                                                SLOT(slotUpdateDeviceState(NMDeviceState)));
 
565
                                slotUpdateDeviceState(device->getState());
 
566
                        }
 
567
                }
 
568
        }
 
569
}
 
570
 
 
571
void Tray::slotUpdateDeviceState(NMDeviceState state)
 
572
{
 
573
        updateTrayIcon(state);
 
574
        updateActiveConnection(state);
 
575
}
 
576
 
 
577
void Tray::trayUiChanged()
 
578
{
 
579
        DeviceTrayComponent * dtc = d->foregroundTrayComponent;
 
580
        if (dtc) {
 
581
                updateTrayIcon(dtc->device()->getState());
 
582
        }
 
583
}
 
584
void Tray::updateTrayIcon(NMDeviceState state)
 
585
{
 
586
        // stop the old movie to avoid unnecessary wakups
 
587
        DeviceTrayComponent * dtc = d->foregroundTrayComponent;
 
588
 
 
589
        if (movie())
 
590
                movie()->pause();
 
591
 
 
592
        if (dtc) {
 
593
 
 
594
                if (!dtc->movieForState(state).isNull())
 
595
                {
 
596
                        // animation desired
 
597
                        int frame = -1;
 
598
                        if (movie())
 
599
                                frame = movie()->frameNumber();
 
600
 
 
601
                        // set the movie
 
602
                        setMovie(dtc->movieForState(state));
 
603
 
 
604
                        // start at the same frame as the movie before
 
605
                        if (frame > 0)
 
606
                                movie()->step(frame);
 
607
 
 
608
                        // start the animation
 
609
                        movie()->unpause();
 
610
                }
 
611
                else if (!dtc->pixmapForState(state).isNull())
 
612
                        setPixmap(dtc->pixmapForState(state));
 
613
                else
 
614
                        setPixmap(loadIcon("knetworkmanager"));
 
615
        }
 
616
        else
 
617
                setPixmap(loadIcon("knetworkmanager"));
 
618
}
 
619
 
 
620
void Tray::updateActiveConnection(NMDeviceState state)
 
621
{
 
622
        if (state != NM_DEVICE_STATE_ACTIVATED)
 
623
                return;
 
624
 
 
625
        NMProxy* nm = NMProxy::getInstance();
 
626
        if (d->foregroundTrayComponent) {
 
627
                Connection* active_conn = nm->getActiveConnection(d->foregroundTrayComponent->device());
 
628
                if (active_conn)
 
629
                {
 
630
                        Info* info = dynamic_cast<Info*>(active_conn->getSetting(NM_SETTING_CONNECTION_SETTING_NAME));
 
631
                        if (info)
 
632
                                info->setTimestamp(QDateTime::currentDateTime());
 
633
                }
 
634
        }
 
635
}
 
636
 
 
637
void Tray::slotDeviceAddedNotify(Device* dev)
 
638
{
 
639
        printf("Tray::slotDeviceAddedNotify\n");
 
640
        KNotifyClient::event( winId(), "knm-nm-device-added", i18n("New network device %1 found").arg(dev->getInterface()) );
 
641
}
 
642
 
 
643
void Tray::slotDeviceRemovedNotify(Device* dev)
 
644
{
 
645
        printf("Tray::slotDeviceRemovedNotify\n");
 
646
        KNotifyClient::event( winId(), "knm-nm-device-removed", i18n("Network device %1 removed").arg(dev->getInterface()) );
 
647
}
 
648
 
 
649
void Tray::slotStateChangedNotify(Q_UINT32 state)
 
650
{
 
651
        NMState nm_state = (NMState) state;
 
652
        // change tray icon according to NM's state
 
653
        switch(nm_state)
 
654
        {
 
655
                case NM_STATE_CONNECTING:
 
656
                        KNotifyClient::event( winId(), "knm-nm-connecting", i18n("NetworkManager is connecting") );
 
657
                        break;
 
658
                case NM_STATE_DISCONNECTED:
 
659
                        KNotifyClient::event( winId(), "knm-nm-disconnected", i18n("NetworkManager is now disconnected") );
 
660
                        break;
 
661
                case NM_STATE_CONNECTED:
 
662
                        KNotifyClient::event( winId(), "knm-nm-connected", i18n("NetworkManager is now connected") );
 
663
                        break;
 
664
                case NM_STATE_ASLEEP:
 
665
                        KNotifyClient::event( winId(), "knm-nm-sleeping", i18n("KNetworkManager Offline") );
 
666
                        break;
 
667
                case NM_STATE_UNKNOWN:
 
668
 
 
669
                default:
 
670
                        break;
 
671
        }
 
672
}
 
673
 
 
674
void Tray::slotEditNotifications()
 
675
{
 
676
        KNotifyDialog::configure(this);
 
677
}
 
678
 
 
679
Tray::Tray () : KSystemTray ()
 
680
{
 
681
        d = new TrayPrivate(this);
 
682
 
 
683
        connect(&d->signalMapper, SIGNAL(mapped(int)), this, SLOT(slotDeactivateConnection(int)));
 
684
 
 
685
        setPixmap (loadIcon ("knetworkmanager"));
 
686
        setMouseTracking (true);
 
687
 
 
688
        // Actions used for plugging into the menu
 
689
        new KAction (i18n ("Switch to offline mode"),
 
690
                                             SmallIcon ("no",  QIconSet::Automatic), 0,
 
691
                                             this, SLOT (slotOfflineMode()), actionCollection (), "offline_mode");
 
692
 
 
693
        new KAction (i18n ("Switch to online mode"),
 
694
                                             SmallIcon ("ok",  QIconSet::Automatic), 0,
 
695
                                             this, SLOT (slotOnlineMode()), actionCollection (), "online_mode");
 
696
 
 
697
        new KAction (i18n ("Disable Wireless"),
 
698
                                             SmallIcon ("wireless_off",  QIconSet::Automatic), 0,
 
699
                                             this, SLOT (slotDisableWireless()), actionCollection (), "disable_wireless");
 
700
 
 
701
        new KAction (i18n ("Enable Wireless"),
 
702
                                             SmallIcon ("wireless",  QIconSet::Automatic), 0,
 
703
                                             this, SLOT (slotEnableWireless()), actionCollection (), "enable_wireless");
 
704
 
 
705
        new KAction (i18n ("Edit Connections"),
 
706
                                             SmallIcon ("edit",  QIconSet::Automatic), 0,
 
707
                                             this, SLOT (slotEditConnections()), actionCollection (), "edit_connections");
 
708
 
 
709
        new KAction (i18n ("Configure Notifications"),
 
710
                                             SmallIcon ("knotify",  QIconSet::Automatic), 0,
 
711
                                             this, SLOT (slotEditNotifications()), actionCollection (), "configure_notifications");
 
712
 
 
713
        // this action is only connected when the menu is shown, hence the 0 receiver
 
714
        new KAction (i18n ("New connection ..."),
 
715
                                             SmallIcon ("filenew",  QIconSet::Automatic), 0,
 
716
                                             this, 0, actionCollection (), "new_connection");
 
717
 
 
718
        new KActionMenu (i18n ("New connection ..."),
 
719
                                             SmallIcon ("filenew",  QIconSet::Automatic),
 
720
                                             actionCollection(), "new_connection_menu");
 
721
 
 
722
        new KActionMenu (i18n ("Deactivate connection..."),
 
723
                        SmallIcon ("no",  QIconSet::Automatic),
 
724
                        actionCollection (), "deactivate_menu");
 
725
 
 
726
        // get notified when NM's state changes
 
727
        NMProxy* nm = NMProxy::getInstance();
 
728
        connect(nm, SIGNAL(StateChange(Q_UINT32)), this, SLOT(slotStateChanged(Q_UINT32)));
 
729
 
 
730
        // get notifier when NM requests new secrets
 
731
        ConnectionStore* cstore = ConnectionStore::getInstance();
 
732
        connect(cstore, SIGNAL(SecretsNeeded(ConnectionSettings::Connection*, ConnectionSettings::ConnectionSetting*, const QStringList&, bool)), this, SLOT(slotSecretsNeeded(ConnectionSettings::Connection*, ConnectionSettings::ConnectionSetting*, const QStringList&, bool)));
 
733
 
 
734
        // get notified about new/removed devices
 
735
        DeviceStore* store = DeviceStore::getInstance();
 
736
        connect(store, SIGNAL(DeviceStoreChanged()), this, SLOT(updateDeviceTrays()));  
 
737
        connect(store, SIGNAL(DeviceAdded(Device*)), this, SLOT(slotAddDeviceTrayComponent(Device*)));  
 
738
        connect(store, SIGNAL(DeviceRemoved(Device*)), this, SLOT(slotRemoveDeviceTrayComponent(Device*)));     
 
739
 
 
740
        // Notifications
 
741
        connect(store, SIGNAL(DeviceAdded(Device*)), this, SLOT(slotDeviceAddedNotify(Device*)));       
 
742
        connect(store, SIGNAL(DeviceRemoved(Device*)), this, SLOT(slotDeviceRemovedNotify(Device*)));   
 
743
        connect(nm, SIGNAL(StateChange(Q_UINT32)), this, SLOT(slotStateChangedNotify(Q_UINT32)));
 
744
 
 
745
 
 
746
        // initial setup of the device-trays
 
747
        updateDeviceTrays();
 
748
 
 
749
        QDBusError err;
 
750
        slotStateChanged(nm->getState(err));
 
751
}
 
752
 
 
753
Tray::~Tray ()
 
754
{
 
755
        delete d;
 
756
}
 
757
 
 
758
#include "knetworkmanager-tray.moc"
 
759