• Skip to content
  • Skip to link menu
KDE 4.1 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

libsolidcontrol

networkmanager.cpp

Go to the documentation of this file.
00001 /*  This file is part of the KDE project
00002     Copyright (C) 2006 Will Stephenson <wstephenson@kde.org>
00003     Copyright (C) 2006-2007 Kevin Ottens <ervin@kde.org>
00004 
00005     This library is free software; you can redistribute it and/or
00006     modify it under the terms of the GNU Library General Public
00007     License version 2 as published by the Free Software Foundation.
00008 
00009     This library is distributed in the hope that it will be useful,
00010     but WITHOUT ANY WARRANTY; without even the implied warranty of
00011     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012     Library General Public License for more details.
00013 
00014     You should have received a copy of the GNU Library General Public License
00015     along with this library; see the file COPYING.LIB.  If not, write to
00016     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017     Boston, MA 02110-1301, USA.
00018 
00019 */
00020 
00021 #include "ifaces/networkmanager.h"
00022 #include "ifaces/networkinterface.h"
00023 #include "ifaces/wirednetworkinterface.h"
00024 #include "ifaces/wirelessnetworkinterface.h"
00025 
00026 #include "soliddefs_p.h"
00027 #include "networkmanager_p.h"
00028 #include "networkinterface.h"
00029 #include "wirednetworkinterface.h"
00030 #include "wirelessnetworkinterface.h"
00031 
00032 #include "networkmanager.h"
00033 
00034 #include <kglobal.h>
00035 
00036 K_GLOBAL_STATIC(Solid::Control::NetworkManagerPrivate, globalNetworkManager)
00037 
00038 Solid::Control::NetworkManagerPrivate::NetworkManagerPrivate() : m_invalidDevice(0)
00039 {
00040     loadBackend("Network Management",
00041                 "SolidNetworkManager",
00042                 "Solid::Control::Ifaces::NetworkManager");
00043 
00044     if (managerBackend()!=0) {
00045         connect(managerBackend(), SIGNAL(networkInterfaceAdded(const QString &)),
00046                 this, SLOT(_k_networkInterfaceAdded(const QString &)));
00047         connect(managerBackend(), SIGNAL(networkInterfaceRemoved(const QString &)),
00048                 this, SLOT(_k_networkInterfaceRemoved(const QString &)));
00049         connect(managerBackend(), SIGNAL(statusChanged(Solid::Networking::Status)),
00050                 this, SIGNAL(statusChanged(Solid::Networking::Status)));
00051         connect(managerBackend(), SIGNAL(wirelessEnabledChanged(bool)),
00052                 this, SIGNAL(wirelessEnabledChanged(bool)));
00053         connect(managerBackend(), SIGNAL(wirelessHardwareEnabledChanged(bool)),
00054                 this, SIGNAL(wirelessHardwareEnabledChanged(bool)));
00055     }
00056 }
00057 
00058 Solid::Control::NetworkManagerPrivate::~NetworkManagerPrivate()
00059 {
00060     // Delete all the devices, they are now outdated
00061     typedef QPair<NetworkInterface *, QObject *> NetworkInterfaceIfacePair;
00062 
00063     foreach (const NetworkInterfaceIfacePair &pair, m_networkInterfaceMap.values()) {
00064         delete pair.first;
00065         delete pair.second;
00066     }
00067 
00068     m_networkInterfaceMap.clear();
00069 }
00070 
00071 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManagerPrivate::buildDeviceList(const QStringList &uniList)
00072 {
00073     NetworkInterfaceList list;
00074     Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00075 
00076     if (backend == 0) return list;
00077 
00078     foreach (const QString &uni, uniList)
00079     {
00080         QPair<NetworkInterface *, QObject *> pair = findRegisteredNetworkInterface(uni);
00081 
00082         if (pair.first!= 0)
00083         {
00084             list.append(pair.first);
00085         }
00086     }
00087 
00088     return list;
00089 }
00090 
00091 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManagerPrivate::networkInterfaces()
00092 {
00093     Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00094 
00095     if (backend!= 0)
00096     {
00097         return buildDeviceList(backend->networkInterfaces());
00098     }
00099     else
00100     {
00101         return NetworkInterfaceList();
00102     }
00103 }
00104 
00105 Solid::Control::NetworkInterfaceList Solid::Control::NetworkManager::networkInterfaces()
00106 {
00107     return globalNetworkManager->networkInterfaces();
00108 }
00109 
00110 bool Solid::Control::NetworkManager::isNetworkingEnabled()
00111 {
00112     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isNetworkingEnabled());
00113 }
00114 
00115 bool Solid::Control::NetworkManager::isWirelessEnabled()
00116 {
00117     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isWirelessEnabled());
00118 }
00119 
00120 bool Solid::Control::NetworkManager::isWirelessHardwareEnabled()
00121 {
00122     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), false, isWirelessHardwareEnabled());
00123 }
00124 
00125 void Solid::Control::NetworkManager::setNetworkingEnabled(bool enabled)
00126 {
00127     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), setNetworkingEnabled(enabled));
00128 }
00129 
00130 void Solid::Control::NetworkManager::setWirelessEnabled(bool enabled)
00131 {
00132     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), setWirelessEnabled(enabled));
00133 }
00134 
00135 Solid::Networking::Status Solid::Control::NetworkManager::status()
00136 {
00137     return_SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), Solid::Networking::Unknown, status());
00138 }
00139 
00140 Solid::Control::NetworkInterface * Solid::Control::NetworkManagerPrivate::findNetworkInterface(const QString &uni)
00141 {
00142     Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00143 
00144     if (backend == 0) return 0;
00145 
00146     QPair<NetworkInterface *, QObject *> pair = findRegisteredNetworkInterface(uni);
00147 
00148     if (pair.first != 0)
00149     {
00150         return pair.first;
00151     }
00152     else
00153     {
00154         return 0;
00155     }
00156 }
00157 
00158 Solid::Control::NetworkInterface * Solid::Control::NetworkManager::findNetworkInterface(const QString &uni)
00159 {
00160     return globalNetworkManager->findNetworkInterface(uni);
00161 }
00162 
00163 Solid::Control::NetworkManager::Notifier * Solid::Control::NetworkManager::notifier()
00164 {
00165     return globalNetworkManager;
00166 }
00167 
00168 void Solid::Control::NetworkManagerPrivate::_k_networkInterfaceAdded(const QString &uni)
00169 {
00170     QPair<NetworkInterface *, QObject*> pair = m_networkInterfaceMap.take(uni);
00171 
00172     if (pair.first!= 0)
00173     {
00174         // Oops, I'm not sure it should happen...
00175         // But well in this case we'd better kill the old device we got, it's probably outdated
00176 
00177         delete pair.first;
00178         delete pair.second;
00179     }
00180 
00181     emit networkInterfaceAdded(uni);
00182 }
00183 
00184 void Solid::Control::NetworkManagerPrivate::_k_networkInterfaceRemoved(const QString &uni)
00185 {
00186     QPair<NetworkInterface *, QObject *> pair = m_networkInterfaceMap.take(uni);
00187 
00188     if (pair.first!= 0)
00189     {
00190         delete pair.first;
00191         delete pair.second;
00192     }
00193 
00194     emit networkInterfaceRemoved(uni);
00195 }
00196 
00197 void Solid::Control::NetworkManagerPrivate::_k_destroyed(QObject *object)
00198 {
00199     Ifaces::NetworkInterface *device = qobject_cast<Ifaces::NetworkInterface *>(object);
00200 
00201     if (device!=0)
00202     {
00203         QString uni = device->uni();
00204         QPair<NetworkInterface *, QObject *> pair = m_networkInterfaceMap.take(uni);
00205         delete pair.first;
00206     }
00207 }
00208 
00209 /***************************************************************************/
00210 
00211 QPair<Solid::Control::NetworkInterface *, QObject *>
00212 Solid::Control::NetworkManagerPrivate::findRegisteredNetworkInterface(const QString &uni)
00213 {
00214     if (m_networkInterfaceMap.contains(uni)) {
00215         return m_networkInterfaceMap[uni];
00216     } else {
00217         Ifaces::NetworkManager *backend = qobject_cast<Ifaces::NetworkManager *>(managerBackend());
00218 
00219         if (backend!=0)
00220         {
00221             QObject * iface = backend->createNetworkInterface(uni);
00222             NetworkInterface *device = 0;
00223             if (qobject_cast<Ifaces::WirelessNetworkInterface *>(iface) != 0) {
00224                 device = new WirelessNetworkInterface(iface);
00225             } else if (qobject_cast<Ifaces::WiredNetworkInterface *>(iface) != 0) {
00226                 device = new WiredNetworkInterface(iface);
00227             }
00228             if (device != 0) {
00229                 QPair<NetworkInterface *, QObject *> pair(device, iface);
00230                 connect(iface, SIGNAL(destroyed(QObject *)),
00231                         this, SLOT(_k_destroyed(QObject *)));
00232                 m_networkInterfaceMap[uni] = pair;
00233                 return pair;
00234             }
00235             else
00236             {
00237                 return QPair<NetworkInterface *, QObject *>(0, 0);
00238             }
00239         }
00240         else
00241         {
00242             return QPair<NetworkInterface *, QObject *>(0, 0);
00243         }
00244     }
00245 }
00246 
00247 void Solid::Control::NetworkManager::activateConnection(const QString & interfaceUni, const QString & connectionUni,
00248                 const QVariantMap & connectionParameters )
00249 {
00250     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), activateConnection(interfaceUni, connectionUni, connectionParameters));
00251 }
00252 
00253 void Solid::Control::NetworkManager::deactivateConnection(const QString & activeConnectionUni)
00254 {
00255     SOLID_CALL(Ifaces::NetworkManager *, globalNetworkManager->managerBackend(), deactivateConnection(activeConnectionUni));
00256 }
00257 
00258 #include "networkmanager_p.moc"
00259 #include "networkmanager.moc"

libsolidcontrol

Skip menu "libsolidcontrol"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

API Reference

Skip menu "API Reference"
  • KWin
  •   KWin Libraries
  • Libraries
  •   libkworkspace
  •   libplasma
  •   libsolidcontrol
  •   libtaskmanager
  • Plasma
  •   Animators
  •   Applets
  •   Engines
  • Solid Modules
Generated for API Reference by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal