summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/settings/networksettings/interfaces/interface.h7
-rw-r--r--noncore/settings/networksettings/module.h12
2 files changed, 19 insertions, 0 deletions
diff --git a/noncore/settings/networksettings/interfaces/interface.h b/noncore/settings/networksettings/interfaces/interface.h
index ec82851..83ab088 100644
--- a/noncore/settings/networksettings/interfaces/interface.h
+++ b/noncore/settings/networksettings/interfaces/interface.h
@@ -1,73 +1,80 @@
#ifndef INTERFACE_H
#define INTERFACE_H
#include <qstring.h>
#include <qobject.h>
class Module;
+/**
+ * A Interface represents a physical device. You can
+ * inherit it and create also virtual devices. Like saved
+ * ppp dial ups or vpn. Interface is used for representing
+ * your interface to the User and its actions.
+ *
+ */
class Interface : public QObject{
Q_OBJECT
signals:
void updateInterface(Interface *i);
void updateMessage(const QString &message);
public:
Interface(QObject * parent=0, const char * name= "unknown", bool status = false);
QString getInterfaceName() const { QString n(this->name()); return n; };
void setInterfaceName( const QString &n ) { this->setName(n); };
bool getStatus() const { return status; };
void setStatus(bool newStatus);
bool isAttached() const { return attached; };
void setAttached(bool isAttached=false);
QString getHardwareName() const { return hardwareName; };
void setHardwareName(const QString &name="Unknown");
Module* getModuleOwner() const { return moduleOwner; };
void setModuleOwner(Module *owner=NULL);
// inet information.
QString getMacAddress() const { return macAddress; };
QString getIp() const { return ip; };
QString getSubnetMask() const { return subnetMask; };
QString getBroadcast() const { return broadcast; };
bool isDhcp() const { return dhcp; };
QString getDhcpServerIp() const { return dhcpServerIp; };
QString getLeaseObtained() const { return leaseObtained; };
QString getLeaseExpires() const { return leaseExpires; };
public slots:
virtual bool refresh();
virtual void start();
virtual void stop();
virtual void restart();
protected:
// Interface information
QString hardwareName;
Module *moduleOwner;
bool status;
bool attached;
// Network information
bool dhcp;
QString dhcpServerIp;
QString leaseObtained;
QString leaseExpires;
QString macAddress;
QString ip;
QString broadcast;
QString subnetMask;
};
#endif
// interface.h
diff --git a/noncore/settings/networksettings/module.h b/noncore/settings/networksettings/module.h
index 3ef823c..9dc913e 100644
--- a/noncore/settings/networksettings/module.h
+++ b/noncore/settings/networksettings/module.h
@@ -1,176 +1,188 @@
#ifndef NETCONF_MODULE_H
#define NETCONF_MODULE_H
#include <qobject.h>
#if QT_VERSION < 300
#include <qlist.h>
#else
#include <qptrlist.h>
#endif
#include <qmap.h>
#include "interface.h"
class QWidget;
class QTabWidget;
/**
* \brief The basis of all plugins
*
* This is the way to extend networksettings with
* extra functionality.
*
*
* Networksettings in the 1.0 release does not use QCOM
* for activation. You need to provide the following function yourself.
*
* A module needs to provide Name, Images, and methods for
* claiming interfaces. For example you can claim physicla
* interfaces like wlan0, ppp0 or virtual like a VPN
* connection and hide the real ppp device or ethernet device
* behind your VPN plugin.
*
* During start up. The main application searches for network devices
* and then looks for an owner under the plugins for them.
* For example the WLAN Plugin looks if there is a WLAN Extension
* on that interface and then claims it by returning true from isOwner()
*
* \code
* extern "C"
* {
* void* create_plugin() {
* return new WLANModule();
* }
* };
* \endcode
* @see isOwner(Interface*)
*/
class Module : private QObject{
signals:
/**
* Emit this Signal once you change the Interface
* you're operating on
*
* @param i The Interface
*/
void updateInterface(Interface *i);
public:
Module(){};
/**
* The type of the plugin
* and the name of the qcop call
*/
virtual const QString type() = 0;
/**
* The current profile has been changed and the module should do any
* neccesary changes also.
* As of Opie1.0 profiles are disabled.
*
* @param newProfile what the profile should be changed to.
*/
virtual void setProfile(const QString &newProfile) = 0;
/**
* get the icon name for this device.
* @param Interface* can be used in determining the icon.
* @return QString the icon name (minus .png, .gif etc)
*/
virtual QString getPixmapName(Interface *) = 0;
/**
* Check to see if the interface i is owned by this module.
* See if you can handle it. And if you can claim ownership
* by returning true.
+ * For physical devices you will be asked if you want to own the
+ * device. But you can also create new \sa Interface Implementations.
+ *
+ * If you want to own the Interface add it to your internal interface
+ * list
+ *
* @param Interface* interface to check against
* @return bool true if i is owned by this module, false otherwise.
+ *
+ * @see getInterfaces
*/
virtual bool isOwner(Interface *){ return false; };
/**
* Create and return the Configure Module
* @param Interface *i the interface to configure.
* @return QWidget* pointer to this modules configure.
*
* @see InterfaceSetupImp
*/
virtual QWidget *configure(Interface *){ return NULL; } ;
/**
* Create, and return the Information Module.
*
* An default Implementation is InterfaceInformationImp
*
* @param Interface *i the interface to get info on.
* @return QWidget* pointer to this modules info.
*
* @see InterfaceInformationImp
*
*/
virtual QWidget *information(Interface *){ return NULL; };
/**
* Get all active (up or down) interfaces managed by this
* module.
+ * At the end of initialisation you will be asked to return your interfaces
+ * Return all of your interfaces even the ones you claimed by isOnwer.
+ * Here you can also return your 'virtual' Interface Objects
+ *
* @return QList<Interface> A list of interfaces that exsist that havn't
* been called by isOwner()
*/
virtual QList<Interface> getInterfaces() = 0;
/**
* Adds possible new interfaces to the list (Example: usb(ppp), ir(ppp),
* modem ppp)
* Both strings need to be translated. The first string is a Shortcut
* like PPP and the second argument is a description.
*
* <code>
* list.insert(
*
* </code>
*
* @param list A reference to the list of supported additionns.
*/
virtual void possibleNewInterfaces(QMap<QString, QString> &list) = 0;
/**
* Attempts to create a new interface from name you gave
* possibleNewInterfaces()
* @return Interface* NULL if it was unable to be created.
* @param name the type of interface to create
*
* @see possibleNewInterfaces
*/
virtual Interface *addNewInterface(const QString &name) = 0;
/**
* Attempts to remove the interface, doesn't delete i
* @return bool true if successful, false otherwise.
*/
virtual bool remove(Interface* i) = 0;
/**
* get dcop calls
*/
virtual void receive(const QCString &msg, const QByteArray &arg) = 0;
QStringList handledInterfaceNames()const { return m_inter; }
protected:
/**
* set which interfaceNames should not be shown cause they're handled
* internally of this module.. An already running ppp link or
* a tunnel... VPN an such
*/
void setHandledInterfaceNames( const QStringList& in) { m_inter = in; }
private:
QStringList m_inter;
};
#endif
// module.h