4 files changed, 42 insertions, 20 deletions

diff --git a/noncore/settings/networksettings/mainwindowimp.cpp b/noncore/settings/networksettings/mainwindowimp.cpp
index 0ef1e68..5029525 100644
--- a/noncore/settings/networksettings/mainwindowimp.cpp
+++ b/noncore/settings/networksettings/mainwindowimp.cpp
@@ -409,258 +409,259 @@ void MainWindowImp::configureClicked(){
   if(!item){
     QMessageBox::information(this, tr("Sorry"),tr("Please select an interface first."), QMessageBox::Ok);
     return;
   }
 
   QString currentProfileText = currentProfileLabel->text();
   if(currentProfileText.upper() == "ALL");
     currentProfileText = "";
 
   Interface *i = interfaceItems[item];
 
   if(i->getModuleOwner()){
     QWidget *moduleConfigure = i->getModuleOwner()->configure(i);
     if(moduleConfigure != NULL){
       i->getModuleOwner()->setProfile(currentProfileText);
       moduleConfigure->showMaximized();
       return;
     }
   }
 
   InterfaceSetupImpDialog *configure = new InterfaceSetupImpDialog(this, "InterfaceSetupImp", i, true, Qt::WDestructiveClose );
   configure->setProfile(currentProfileText);
   configure->showMaximized();
 }
 
 /**
  * Pull up the information about the currently selected interface.
  * Report an error if no interface is selected.
  * If the interface has a module owner then request its configure.
  */
 void MainWindowImp::informationClicked(){
   QListViewItem *item = connectionList->currentItem();
   if(!item){
     QMessageBox::information(this, "Sorry","Please select an interface First.", QMessageBox::Ok);
     return;
   }
 
   Interface *i = interfaceItems[item];
 //   if(!i->isAttached()){
 //     QMessageBox::information(this, "Sorry","No information about\na disconnected interface.", QMessageBox::Ok);
 //     return;
 //   }
 
   if(i->getModuleOwner()){
     QWidget *moduleInformation = i->getModuleOwner()->information(i);
     if(moduleInformation != NULL){
       moduleInformation->showMaximized();
 #ifdef DEBUG
       qDebug("MainWindowImp::informationClicked:: Module owner has created, we showed.");
 #endif
       return;
     }
   }
   InterfaceInformationImp *information = new InterfaceInformationImp(this, "InterfaceSetupImp", i, Qt::WType_Modal | Qt::WDestructiveClose | Qt::WStyle_Dialog);
   information->showMaximized();
 }
 
 /**
  * Update this interface.  If no QListViewItem exists create one.
  * @param Interface* pointer to the interface that needs to be updated.
  */
 void MainWindowImp::updateInterface(Interface *i){
   if(!advancedUserMode){
     if(i->getInterfaceName() == "lo")
       return;
   }
 
   QListViewItem *item = NULL;
 
   // Find the interface, making it if needed.
   if(items.find(i) == items.end()){
     item = new QListViewItem(connectionList, "", "", "");
     // See if you can't find a module owner for this interface
     QMap<Module*, QLibrary*>::Iterator it;
     for( it = libraries.begin(); it != libraries.end(); ++it ){
       if(it.key()->isOwner(i))
         i->setModuleOwner(it.key());
     }
     items.insert(i, item);
     interfaceItems.insert(item, i);
   }
   else
     item = items[i];
 
   // Update the icons and information
 #ifdef QWS
   item->setPixmap(0, (Resource::loadPixmap(i->getStatus() ? "up": "down")));
 #else
   item->setPixmap(0, (SmallIcon(i->getStatus() ? "up": "down")));
 #endif
 
   QString typeName = "lan";
   if(i->getInterfaceName() == "lo")
     typeName = "lo";
   if(i->getInterfaceName().contains("irda"))
     typeName = "irda";
   if(i->getInterfaceName().contains("wlan"))
     typeName = "wlan";
   if(i->getInterfaceName().contains("usb"))
     typeName = "usb";
 
   if(!i->isAttached())
     typeName = "connect_no";
   // Actually try to use the Module
   if(i->getModuleOwner() != NULL)
     typeName = i->getModuleOwner()->getPixmapName(i);
 
 #ifdef QWS
   item->setPixmap(1, (Resource::loadPixmap(QString("networksettings/") + typeName)));
 #else
   item->setPixmap(1, (SmallIcon(typeName)));
 #endif
   item->setText(2, i->getHardwareName());
   item->setText(3, QString("(%1)").arg(i->getInterfaceName()));
   item->setText(4, (i->getStatus()) ? i->getIp() : QString(""));
 }
 
 void MainWindowImp::newProfileChanged(const QString& newText){
   if(newText.length() > 0)
    newProfileButton->setEnabled(true);
   else
     newProfileButton->setEnabled(false);
 }
 
 /**
  * Adds a new profile to the list of profiles.
  * Don't add profiles that already exists.
  * Appends to the list and QStringList
  */
 void MainWindowImp::addProfile(){
   QString newProfileName = newProfile->text();
   if(profiles.grep(newProfileName).count() > 0){
     QMessageBox::information(this, "Can't Add","Profile already exists.", QMessageBox::Ok);
     return;
   }
   profiles.append(newProfileName);
   profilesList->insertItem(newProfileName);
 }
 
 /**
  * Removes the currently selected profile in the combo.
  * Doesn't delete if there are less then 2 profiles.
  */
 void MainWindowImp::removeProfile(){
   if(profilesList->count() <= 1){
     QMessageBox::information(this, "Can't remove.","At least one profile\nis needed.", QMessageBox::Ok);
     return;
   }
   QString profileToRemove = profilesList->currentText();
   if(profileToRemove == "All"){
     QMessageBox::information(this, "Can't remove.","Can't remove default.", QMessageBox::Ok);
     return;
   }
   // Can't remove the curent profile
   if(profileToRemove == currentProfileLabel->text()){
     QMessageBox::information(this, "Can't remove.",QString("%1 is the current profile.").arg(profileToRemove), QMessageBox::Ok);
     return;
 
   }
 
   if(QMessageBox::information(this, "Question",QString("Remove profile: %1").arg(profileToRemove), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok){
     profiles = QStringList::split(" ", profiles.join(" ").replace(QRegExp(profileToRemove), ""));
     profilesList->clear();
     for ( QStringList::Iterator it = profiles.begin(); it != profiles.end(); ++it)
       profilesList->insertItem((*it));
 
     // Remove any interface settings and mappings.
     Interfaces interfaces;
     // Go through them one by one
     QMap<Interface*, QListViewItem*>::Iterator it;
     for( it = items.begin(); it != items.end(); ++it ){
       QString interfaceName = it.key()->getInterfaceName();
       qDebug(interfaceName.latin1());
       if(interfaces.setInterface(interfaceName + "_" + profileToRemove)){
        interfaces.removeInterface();
        if(interfaces.setMapping(interfaceName)){
          if(profilesList->count() == 1)
             interfaces.removeMapping();
           else{
             interfaces.removeMap("map", interfaceName + "_" + profileToRemove);
           }
         }
         interfaces.write();
         break;
       }
     }
   }
 }
 
 /**
  * A new profile has been selected, change.
  * @param newProfile the new profile.
  */
 void MainWindowImp::changeProfile(){
   if(profilesList->currentItem() == -1){
     QMessageBox::information(this, "Can't Change.","Please select a profile.", QMessageBox::Ok);
     return;
   }
   QString newProfile = profilesList->text(profilesList->currentItem());
   if(newProfile != currentProfileLabel->text()){
     currentProfileLabel->setText(newProfile);
     QFile::remove(scheme);
     QFile file(scheme);
     if ( file.open(IO_ReadWrite) ) {
       QTextStream stream( &file );
       stream << QString("SCHEME=%1").arg(newProfile);
       file.close();
     }
     // restart all up devices?
     if(QMessageBox::information(this, "Question","Restart all running interfaces?", QMessageBox::Ok, QMessageBox::No) == QMessageBox::Ok){
       // Go through them one by one
       QMap<Interface*, QListViewItem*>::Iterator it;
       for( it = items.begin(); it != items.end(); ++it ){
         if(it.key()->getStatus() == true)
           it.key()->restart();
       }
     }
   }
   // TODO change the profile in the modules
 }
 
 
 void MainWindowImp::makeChannel()
 {
          channel = new QCopChannel( "QPE/Application/networksettings", this );
          connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
                 this, SLOT(receive(const QCString&, const QByteArray&)) );
 }
 
 void MainWindowImp::receive(const QCString &msg, const QByteArray &arg)
 {
     bool found = false;
     qDebug("MainWindowImp::receive QCop msg >"+msg+"<");
 
     QString dest = msg.left(msg.find("("));
     QCString param = msg.right(msg.length() - msg.find("(") - 1);
     param = param.left( param.length() - 1 );
     qDebug("dest >%s< param >"+param+"<",dest.latin1());
 
 //     if (param.contains("QString,QString,QString")) {
 //         QDataStream stream(arg,IO_ReadOnly);
 //         QString arg1, arg2, arg3;
 //         stream >> arg1 >> arg2 >> arg3 ;
 //         qDebug("args: >%s< >%s< >%s<",arg1.latin1(),arg2.latin1(),arg3.latin1());
 //     }
 
      QMap<Module*, QLibrary*>::Iterator it;
      for( it = libraries.begin(); it != libraries.end(); ++it ){
          qDebug("plugin >%s<", it.key()->type().latin1() );
          if(it.key()->type() == dest){
              it.key()->receive( param, arg );
              found = true;
          }
      }
 
 
-    if (!found) qDebug("Huh what do ya want");
+     if (found) QPEApplication::setKeepRunning();
+     else qDebug("Huh what do ya want");
 }
diff --git a/noncore/settings/networksettings/wlan/wlanimp2.cpp b/noncore/settings/networksettings/wlan/wlanimp2.cpp
index b988822..cdafb4d 100644
--- a/noncore/settings/networksettings/wlan/wlanimp2.cpp
+++ b/noncore/settings/networksettings/wlan/wlanimp2.cpp
@@ -1,269 +1,269 @@
 #include "wlanimp2.h"
 #include "keyedit.h"
 #include "interfacesetupimp.h"
 
 #include <qfile.h>
 #include <qdir.h>
 #include <qtextstream.h>
 #include <qmessagebox.h>
 #include <qlineedit.h>
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qradiobutton.h>
 #include <qcheckbox.h>
 #include <qtabwidget.h>
 #include <qcombobox.h>
 
 #ifdef QWS
  #include <opie/oprocess.h>
 #else
  #define OProcess KProcess
  #include <kprocess.h>
 #endif
 
 #define WIRELESS_OPTS "/etc/pcmcia/wireless.opts"
 #define PREUP "/etc/netwrok/if-pre-up.d/wireless-tools"
 
 /**
  * Constructor, read in the wireless.opts file for parsing later.
  */
 WLANImp::WLANImp( QWidget* parent, const char* name, Interface *i, bool modal, WFlags fl) : WLAN(parent, name, modal, fl), currentProfile("*"), interface(i) {
-  interfaces = new Interfaces;
+  interfaces = new Interfaces();
   interfaceSetup = new InterfaceSetupImp(tabWidget, "InterfaceSetupImp", i, interfaces);
   tabWidget->insertTab(interfaceSetup, "TCP/IP");
 
   // Check sanity - the existance of the wireless-tools if-pre-up script
   QFile file(QString(PREUP));
   if (file.exists()) {
     qWarning(QString("WLANImp: Unable to open /etc/network/if-pre-up.d/wireless-tools"));
   }
 }
 
 WLANImp::~WLANImp() {
 //FIXME:  delete interfaces;
 }
 
 /**
  * Change the profile for both wireless settings and network settings.
  */
 void WLANImp::setProfile(const QString &profile){
   interfaceSetup->setProfile(profile);
   parseOpts();
 }
 
 void WLANImp::parseOpts() {
   bool error;
   QString opt;
 
   if (! interfaces->isInterfaceSet())
     return;
 
 
   opt = interfaces->getInterfaceOption("wireless_essid", error);
   if(opt == "any" || opt == "off" || opt.isNull()){
     essid->setEditText("any");
   } else {
     essid->setEditText(opt);
   }
 
   opt = interfaces->getInterfaceOption("wireless_mode", error).simplifyWhiteSpace();
   if (opt == "Auto") {
     mode->setCurrentItem(0);
   } else if (opt == "Ad-Hoc") {
     mode->setCurrentItem(2);
   } else {
     // Managed/Infrastructure mode
     mode->setCurrentItem(1);
   }
 
   opt = interfaces->getInterfaceOption("wireless_ap", error).simplifyWhiteSpace();
   if (! opt.isNull()) {
     specifyAp->setChecked(true);
     macEdit->setText(opt);
   }
 
   opt = interfaces->getInterfaceOption("wireless_channel", error).simplifyWhiteSpace();
   if (! opt.isNull()) {
     specifyChan->setChecked(true);
     networkChannel->setValue(opt.toInt());
   }
 
   opt = interfaces->getInterfaceOption("wireless_key", error).simplifyWhiteSpace();
   if (opt.isNull())
     opt = interfaces->getInterfaceOption("wireless_enc", error).simplifyWhiteSpace();
   parseKeyStr(opt);
 }
 
 void WLANImp::parseKeyStr(QString keystr) {
   int loc = 0;
   int index = 1;
   QString key;
   QStringList keys = QStringList::split(QRegExp("\\s+"), keystr);
   int enc = -1; // encryption state
 
   for (QStringList::Iterator it = keys.begin(); it != keys.end(); ++it) {
     if ((*it).left(3) == "off") {
       // encryption disabled
       enc = 0;
     } else if ((*it).left(2) == "on") {
       // encryption enabled
       enc = 1;
     } else if ((*it).left(4) == "open") {
       // open mode, accept non encrypted packets
       acceptNonEnc->setChecked(true);
     } else if ((*it).left(10) == "restricted") {
       // restricted mode, only accept encrypted packets
       rejectNonEnc->setChecked(true);
     } else if ((*it).left(3) == "key") {
       // new set of options
     } else if ((*it).left(1) == "[") {
       index = (*it).mid(1, 1).toInt();
       // switch current key to index
       switch (index) {
         case 1:
           keyRadio0->setChecked(true);
           break;
         case 2:
           keyRadio1->setChecked(true);
           break;
         case 3:
           keyRadio2->setChecked(true);
           break;
         case 4:
           keyRadio3->setChecked(true);
           break;
       }
     } else {
       // key
       key = (*it);
     }
     if (! key.isNull()) {
       if (enc == -1)
         enc = 1;
       QStringList::Iterator next = ++it;
       if (it == keys.end()) {
         break;
       }
       if ((*(next)).left(1) == "[") {
         // set key at index
         index = (*(next)).mid(1, 1).toInt();
       } else {
         index = 1;
       }
       switch (index) {
           case 1:
             keyLineEdit0->setText(key);
             break;
           case 2:
             keyLineEdit1->setText(key);
             break;
           case 3:
             keyLineEdit2->setText(key);
             break;
           case 4:
             keyLineEdit3->setText(key);
             break;
       }
       key = QString::null;
     }
   }
   if (enc == 1) {
     wepEnabled->setChecked(true);
   } else {
     wepEnabled->setChecked(false);
   }
 }
 
 /**
  * Check to see if the current config is valid
  * Save interfaces
  */
 void WLANImp::accept() {
   if (wepEnabled->isChecked()) {
     if ((keyRadio0->isChecked() && keyLineEdit0->text().isEmpty()) ||
         (keyRadio1->isChecked() && keyLineEdit1->text().isEmpty()) ||
         (keyRadio2->isChecked() && keyLineEdit2->text().isEmpty()) ||
         (keyRadio3->isChecked() && keyLineEdit3->text().isEmpty())) {
       QMessageBox::information(this, "Error", "Please enter a WEP key.", QMessageBox::Ok);
       return;
     }
   }
 
   if (essid->currentText().isEmpty()) {
     QMessageBox::information(this, "Error", "Please select/enter an ESSID.", QMessageBox::Ok);
     return;
   }
 
   if (specifyAp->isChecked() && macEdit->text().isEmpty()) {
     QMessageBox::information(this, "Error", "Please enter the MAC address of the Access Point.", QMessageBox::Ok);
     return;
   }
 
   // Try to save the interfaces settings.
   writeOpts();
 
   // Close out the dialog
   QDialog::accept();
 }
 
 void WLANImp::writeOpts() {
   bool error = false;
 
   interfaces->setInterfaceOption(QString("wireless_mode"), mode->currentText());
   interfaces->setInterfaceOption(QString("wireless_essid"), essid->currentText());
 
   if (specifyAp->isChecked()) {
     interfaces->setInterfaceOption(QString("wireless_ap"), macEdit->text());
   } else {
     interfaces->removeInterfaceOption(QString("wireless_ap"));
   }
 
   if (specifyChan->isChecked()) {
     interfaces->setInterfaceOption(QString("wireless_channel"), networkChannel->text());
   } else {
     interfaces->removeInterfaceOption(QString("wireless_channel"));
   }
 
   if (wepEnabled->isChecked()) {
     QStringList keyList;
 
     if (! keyLineEdit0->text().isNull()) {
       keyList += keyLineEdit0->text();
       keyList += "[1]";
     } else if (! keyLineEdit1->text().isNull()) {
       keyList += keyLineEdit1->text();
       keyList += "[2]";
     } else if (! keyLineEdit2->text().isNull()) {
       keyList += keyLineEdit2->text();
       keyList += "[3]";
     } else if (! keyLineEdit3->text().isNull()) {
       keyList += keyLineEdit3->text();
       keyList += "[4]";
     }
     if (acceptNonEnc->isChecked()) {
       keyList += "open";
     } else {
       keyList += "restricted";
     }
 
     keyList += "key";
     if (keyRadio0->isChecked()) {
       keyList += "[1]";
     } else if (keyRadio1->isChecked()) {
       keyList += "[2]";
     } else if (keyRadio2->isChecked()) {
       keyList += "[3]";
     } else if (keyRadio3->isChecked()) {
       keyList += "[4]";
     }
     interfaces->setInterfaceOption(QString("wireless_key"), keyList.join(QString(" ")));
   } else {
     interfaces->removeInterfaceOption(QString("wireless_key"));
   }
   interfaces->removeInterfaceOption(QString("wireless_enc"));
 
   if(!interfaceSetup->saveChanges())
     return;
 
   QDialog::accept();
 }
diff --git a/noncore/settings/networksettings/wlan/wlanmodule.cpp b/noncore/settings/networksettings/wlan/wlanmodule.cpp
index e6f082c..bc467bb 100644
--- a/noncore/settings/networksettings/wlan/wlanmodule.cpp
+++ b/noncore/settings/networksettings/wlan/wlanmodule.cpp
@@ -1,187 +1,209 @@
 #include "wlanmodule.h"
 #include "wlanimp.h"
 #include "infoimp.h"
 #include "wextensions.h"
 #include "interfaceinformationimp.h"
 
+#include <qcheckbox.h>
+#include <qcombobox.h>
 #include <qlabel.h>
 #include <qprogressbar.h>
+#include <qspinbox.h>
 #include <qtabwidget.h>
 
 
 
 
 /**
  * Constructor, find all of the possible interfaces
  */
-WLANModule::WLANModule() : Module() {
+WLANModule::WLANModule()
+    : Module(),
+      wlanconfigWiget(0)
+{
 }
 
 /**
  * Delete any interfaces that we own.
  */
 WLANModule::~WLANModule(){
   Interface *i;
   for ( i=list.first(); i != 0; i=list.next() )
     delete i;
 
 }
 
 /**
  * Change the current profile
  */
 void WLANModule::setProfile(const QString &newProfile){
   profile = newProfile;
 }
 
 /**
  * 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)
  */
 QString WLANModule::getPixmapName(Interface* ){
   return "wlan";
 }
 
 /**
  * Check to see if the interface i is owned by this module.
  * @param Interface* interface to check against
  * @return bool true if i is owned by this module, false otherwise.
  */
 bool WLANModule::isOwner(Interface *i){
   WExtensions we(i->getInterfaceName());
   if(!we.doesHaveWirelessExtensions())
     return false;
 
   i->setHardwareName("802.11b");
   list.append(i);
   return true;
 }
 
 /**
  * Create, and return the WLANConfigure Module
  * @return QWidget* pointer to this modules configure.
  */
 QWidget *WLANModule::configure(Interface *i){
   WLANImp *wlanconfig = new WLANImp(0, "WlanConfig", i, false,  Qt::WDestructiveClose);
   wlanconfig->setProfile(profile);
   return wlanconfig;
 }
 
 /**
  * Create, and return the Information Module
  * @return QWidget* pointer to this modules info.
  */
 QWidget *WLANModule::information(Interface *i){
   WExtensions we(i->getInterfaceName());
   if(!we.doesHaveWirelessExtensions())
     return NULL;
 
   return getInfo( i );
 }
 
 /**
  * Get all active (up or down) interfaces
  * @return QList<Interface> A list of interfaces that exsist that havn't
  * been called by isOwner()
  */
 QList<Interface> WLANModule::getInterfaces(){
   return list;
 }
 
 /**
  * Attempt to add a new interface as defined by name
  * @param name the name of the type of interface that should be created given
  *  by possibleNewInterfaces();
  * @return Interface* NULL if it was unable to be created.
  */
 Interface *WLANModule::addNewInterface(const QString &){
   // We can't add a 802.11 interface, either the hardware will be there
   // or it wont.
   return NULL;
 }
 
 /**
  * Attempts to remove the interface, doesn't delete i
  * @return bool true if successfull, false otherwise.
  */
 bool WLANModule::remove(Interface*){
   // Can't remove a hardware device, you can stop it though.
   return false;
 }
 
 void WLANModule::receive(const QCString &param, const QByteArray &arg)
 {
     qDebug("WLANModule::receive "+param);
     QStringList params = QStringList::split(",",param);
     int count = params.count();
-    qDebug("got %i params", count );
+    qDebug("WLANModule got %i params", count );
     if (count < 2){
         qDebug("Erorr less than 2 parameter");
         qDebug("RETURNING");
         return;
     }
 
     QDataStream stream(arg,IO_ReadOnly);
     QString interface;
     QString action;
 
     stream >> interface;
     stream >> action;
-    qDebug("got interface %s and acion %s", interface.latin1(), action.latin1());
+    qDebug("WLANModule got interface %s and acion %s", interface.latin1(), action.latin1());
     // find interfaces
     Interface *ifa=0;
     for ( Interface *i=list.first(); i != 0; i=list.next() ){
         if (i->getInterfaceName() == interface){
-            qDebug("found interface %s",interface.latin1());
+            qDebug("WLANModule found interface %s",interface.latin1());
             ifa = i;
         }
     }
 
     if (ifa == 0){
-        qFatal("Did not find %s",interface.latin1());
+        qFatal("WLANModule Did not find %s",interface.latin1());
     }
 
     if (count == 2){
         // those should call the interface directly
         QWidget *info = getInfo( ifa );
         info->showMaximized();
 
         if ( action.contains("start" ) ){
             ifa->start();
         } else if ( action.contains("restart" ) ){
             ifa->restart();
         } else if ( action.contains("stop" ) ){
             ifa->stop();
         }else if ( action.contains("refresh" ) ){
             ifa->refresh();
         }
     }else if (count == 3){
         QString value;
+        if (!wlanconfigWiget){
+            //FIXME: what if it got closed meanwhile?
+            wlanconfigWiget = (WLANImp*) configure(ifa);
+        }
+        wlanconfigWiget->showMaximized();
         stream >> value;
-        qDebug("setting %s of %s to %s", action.latin1(), interface.latin1(), value.latin1() );
+        qDebug("WLANModule is setting %s of %s to %s", action.latin1(), interface.latin1(), value.latin1() );
         if ( action.contains("ESSID") ){
-            qDebug("Setting ESSID not yet impl");
+            QComboBox *combo = wlanconfigWiget->essid;
+            bool found = false;
+            for ( int i = 0; i < combo->count(); i++)
+                if ( combo->text( i ) == value ){
+                    combo->setCurrentItem( i );
+                    found = true;
+                }
+            if (!found) combo->insertItem( value, 0 );
+        }else if ( action.contains("Mode") ){
+            QComboBox *combo = wlanconfigWiget->mode;
+            for ( int i = 0; i < combo->count(); i++)
+                if ( combo->text( i ) == value ){
+                    combo->setCurrentItem( i );
+                }
+
         }else if (action.contains("Channel")){
-            qDebug("Setting Channel not yet impl");
+            wlanconfigWiget->specifyChan->setChecked( true );
+            wlanconfigWiget->networkChannel->setValue( value.toInt() );
         }else
             qDebug("wlan plugin has no clue");
     }
-    // if (param.contains("QString,QString,QString")) {
-//         QDataStream stream(arg,IO_ReadOnly);
-//         QString arg1, arg2, arg3;
-//         stream >> arg1 >> arg2 >> arg3 ;
-//         qDebug("interface >%s< setting >%s< value >%s<",arg1.latin1(),arg2.latin1(),arg3.latin1());
-//     }
+
 }
 
 QWidget *WLANModule::getInfo( Interface *i)
 {
     qDebug("WLANModule::getInfo start");
     WlanInfoImp *info = new WlanInfoImp(0, i->getInterfaceName(), Qt::WDestructiveClose);
     InterfaceInformationImp *information = new InterfaceInformationImp(info->tabWidget, "InterfaceSetupImp", i);
     info->tabWidget->insertTab(information, "TCP/IP", 0);
 
     qDebug("WLANModule::getInfo return");
     return info;
 }
+
diff --git a/noncore/settings/networksettings/wlan/wlanmodule.h b/noncore/settings/networksettings/wlan/wlanmodule.h
index 0963137..027ecec 100644
--- a/noncore/settings/networksettings/wlan/wlanmodule.h
+++ b/noncore/settings/networksettings/wlan/wlanmodule.h
@@ -1,49 +1,48 @@
 #ifndef WLAN_MODULE_H
 #define WLAN_MODULE_H
 
 #include "module.h"
 
-//class WlanInfoImp;
+class WLANImp;
 
 class WLANModule : Module{
 
 signals:
   void updateInterface(Interface *i);
         
 public:
   WLANModule();
   ~WLANModule();
 
 
   virtual const QString type() {return "wlan";};
   void setProfile(const QString &newProfile);
   bool isOwner(Interface *);
   QWidget *configure(Interface *i);
   QWidget *information(Interface *i);
   QList<Interface> getInterfaces();
   void possibleNewInterfaces(QMap<QString, QString> &){};
   Interface *addNewInterface(const QString &name);
   bool remove(Interface* i);
   QString getPixmapName(Interface* i);
   virtual void receive(const QCString&, const QByteArray&);
 
 private:
   QWidget *getInfo(Interface*);
-
+  WLANImp *wlanconfigWiget;
   QList<Interface> list;
   QString profile;
-  //  WlanInfoImp *info;
-  //  Interface *iface;
+
 };
 
 extern "C"
 {
   void* create_plugin() {
     return new WLANModule();
   }
 };
 
 #endif
 
 // wlanmodule.h