Merge branch 'bug_203_fix_wrong_networkstate'

[enigma2.git] / lib / python / Screens / NetworkSetup.py
diff --git a/lib/python/Screens/NetworkSetup.py b/lib/python/Screens/NetworkSetup.py

old mode 100644 (file)

new mode 100755 (executable)

index be2a763..3e9354e
--- a/lib/python/Screens/NetworkSetup.py
+++ b/lib/python/Screens/NetworkSetup.py
@@ -1,106 +1,257 @@
  from Screen import Screen
  from Screen import Screen
-from Components.ActionMap import ActionMap,NumberActionMap
  from Screens.MessageBox import MessageBox
  from Screens.MessageBox import MessageBox
+from Screens.InputBox import InputBox
  from Screens.Standby import *
  from Screens.Standby import *
-from Components.ConfigList import ConfigListScreen
-from Components.config import config, getConfigListEntry
+from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Screens.HelpMenu import HelpableScreen
  from Components.Network import iNetwork
  from Components.Network import iNetwork
-from Tools.Directories import resolveFilename
+from Components.Sources.StaticText import StaticText
+from Components.Sources.Boolean import Boolean
  from Components.Label import Label,MultiColorLabel
  from Components.Pixmap import Pixmap,MultiPixmap
  from Components.MenuList import MenuList
  from Components.Label import Label,MultiColorLabel
  from Components.Pixmap import Pixmap,MultiPixmap
  from Components.MenuList import MenuList
-from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigSelection, getConfigListEntry
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing
+from Components.ConfigList import ConfigListScreen
  from Components.PluginComponent import plugins
  from Components.PluginComponent import plugins
+from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
+from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap
+from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_CURRENT_SKIN
+from Tools.LoadPixmap import LoadPixmap
  from Plugins.Plugin import PluginDescriptor
  from Plugins.Plugin import PluginDescriptor
-from enigma import eTimer
-from os import path as os_path
+from enigma import eTimer, ePoint, eSize, RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont
+from os import path as os_path, system as os_system, unlink
  from re import compile as re_compile, search as re_search
  from re import compile as re_compile, search as re_search
-from Tools.Directories import resolveFilename, SCOPE_PLUGINS
  
  
-class NetworkAdapterSelection(Screen):
+
+class InterfaceList(MenuList):
+       def __init__(self, list, enableWrapAround=False):
+               MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent)
+               self.l.setFont(0, gFont("Regular", 20))
+               self.l.setItemHeight(30)
+
+def InterfaceEntryComponent(index,name,default,active ):
+       res = [
+               (index),
+               MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name)
+       ]
+       num_configured_if = len(iNetwork.getConfiguredAdapters())
+       if num_configured_if >= 2:
+               if default is True:
+                       png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
+               if default is False:
+                       png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
+               res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png))
+       if active is True:
+               png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
+       if active is False:
+               png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
+       res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2))
+       return res
+
+
+class NetworkAdapterSelection(Screen,HelpableScreen):
         def __init__(self, session):
                 Screen.__init__(self, session)
         def __init__(self, session):
                 Screen.__init__(self, session)
-               iNetwork.getInterfaces()
-               self.wlan_errortext = _("No working wireless networkadapter found.\nPlease verify that you have attached a compatible WLAN USB Stick and your Network is configured correctly.")
-               self.lan_errortext = _("No working local networkadapter found.\nPlease verify that you have attached a network cable and your Network is configured correctly.")
+               HelpableScreen.__init__(self)
+               
+               self.wlan_errortext = _("No working wireless network adapter found.\nPlease verify that you have attached a compatible WLAN device and your network is configured correctly.")
+               self.lan_errortext = _("No working local network adapter found.\nPlease verify that you have attached a network cable and your network is configured correctly.")
+               self.oktext = _("Press OK on your remote control to continue.")
+               self.edittext = _("Press OK to edit the settings.")
+               self.defaulttext = _("Press yellow to set this interface as default interface.")
+               self.restartLanRef = None
+               
+               self["key_red"] = StaticText(_("Close"))
+               self["key_green"] = StaticText(_("Select"))
+               self["key_yellow"] = StaticText("")
+               self["introduction"] = StaticText(self.edittext)
+               
                 self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
                 self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
-               if len(self.adapters) == 0:
+               
+               if not self.adapters:
                         self.onFirstExecBegin.append(self.NetworkFallback)
                         
                         self.onFirstExecBegin.append(self.NetworkFallback)
                         
-               self["adapterlist"] = MenuList(self.adapters)
-               self["actions"] = ActionMap(["OkCancelActions"],
-               {
-                       "ok": self.okbuttonClick,
-                       "cancel": self.close
-               })
+               self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+                       {
+                       "cancel": (self.close, _("exit network interface list")),
+                       "ok": (self.okbuttonClick, _("select interface")),
+                       })
+
+               self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "red": (self.close, _("exit network interface list")),
+                       "green": (self.okbuttonClick, _("select interface")),
+                       })
+               
+               self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),
+                       })
+
+               self.list = []
+               self["list"] = InterfaceList(self.list)
+               self.updateList()
  
                 if len(self.adapters) == 1:
                         self.onFirstExecBegin.append(self.okbuttonClick)
  
                 if len(self.adapters) == 1:
                         self.onFirstExecBegin.append(self.okbuttonClick)
+               self.onClose.append(self.cleanup)
+
+
+       def updateList(self):
+               self.list = []
+               default_gw = None
+               num_configured_if = len(iNetwork.getConfiguredAdapters())
+               if num_configured_if >= 2:
+                       self["key_yellow"].setText(_("Default"))
+                       self["introduction"].setText(self.defaulttext)
+                       self["DefaultInterfaceAction"].setEnabled(True)
+               else:
+                       self["key_yellow"].setText("")
+                       self["introduction"].setText(self.edittext)
+                       self["DefaultInterfaceAction"].setEnabled(False)
+
+               if num_configured_if < 2 and os_path.exists("/etc/default_gw"):
+                       unlink("/etc/default_gw")
+                       
+               if os_path.exists("/etc/default_gw"):
+                       fp = file('/etc/default_gw', 'r')
+                       result = fp.read()
+                       fp.close()
+                       default_gw = result
+                                       
+               if len(self.adapters) == 0: # no interface available => display only eth0
+                       self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
+               else:
+                       for x in self.adapters:
+                               if x[1] == default_gw:
+                                       default_int = True
+                               else:
+                                       default_int = False
+                               if iNetwork.getAdapterAttribute(x[1], 'up') is True:
+                                       active_int = True
+                               else:
+                                       active_int = False
+                               self.list.append(InterfaceEntryComponent(index = x[1],name = _(x[0]),default=default_int,active=active_int ))
+
+               self["list"].l.setList(self.list)
+
+       def setDefaultInterface(self):
+               selection = self["list"].getCurrent()
+               num_if = len(self.list)
+               old_default_gw = None
+               num_configured_if = len(iNetwork.getConfiguredAdapters())
+               if os_path.exists("/etc/default_gw"):
+                       fp = open('/etc/default_gw', 'r')
+                       old_default_gw = fp.read()
+                       fp.close()
+               if num_configured_if > 1 and (not old_default_gw or old_default_gw != selection[0]):
+                       fp = open('/etc/default_gw', 'w+')
+                       fp.write(selection[0])
+                       fp.close()
+                       self.restartLan()
+               elif old_default_gw and num_configured_if < 2:
+                       unlink("/etc/default_gw")
+                       self.restartLan()
  
         def okbuttonClick(self):
  
         def okbuttonClick(self):
-               selection = self["adapterlist"].getCurrent()
+               selection = self["list"].getCurrent()
                 if selection is not None:
                 if selection is not None:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[1])
+                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0])
  
         def AdapterSetupClosed(self, *ret):
                 if len(self.adapters) == 1:
                         self.close()
  
         def AdapterSetupClosed(self, *ret):
                 if len(self.adapters) == 1:
                         self.close()
+               else:
+                       self.updateList()
  
         def NetworkFallback(self):
  
         def NetworkFallback(self):
-               if iNetwork.configuredInterfaces.has_key('wlan0') is True:
+               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               if iNetwork.configuredInterfaces.has_key('ath0') is True:
+               if iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
                 else:
                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
  
         def ErrorMessageClosed(self, *ret):
                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
                 else:
                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
  
         def ErrorMessageClosed(self, *ret):
-               if iNetwork.configuredInterfaces.has_key('wlan0') is True:
+               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
-               elif iNetwork.configuredInterfaces.has_key('ath0') is True:
+               elif iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
                 else:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
  
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
                 else:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
  
-class NameserverSetup(Screen, ConfigListScreen):
+       def cleanup(self):
+               iNetwork.stopLinkStateConsole()
+               iNetwork.stopRestartConsole()
+               iNetwork.stopGetInterfacesConsole()
+
+       def restartLan(self):
+               iNetwork.restartNetwork(self.restartLanDataAvail)
+               self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while we configure your network..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       
+       def restartLanDataAvail(self, data):
+               if data is True:
+                       iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+       def getInterfacesDataAvail(self, data):
+               if data is True:
+                       self.restartLanRef.close(True)
+
+       def restartfinishedCB(self,data):
+               if data is True:
+                       self.updateList()
+                       self.session.open(MessageBox, _("Finished configuring your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
+
+
+
+class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
         def __init__(self, session):
                 Screen.__init__(self, session)
         def __init__(self, session):
                 Screen.__init__(self, session)
-               iNetwork.getInterfaces()
+               HelpableScreen.__init__(self)
                 self.backupNameserverList = iNetwork.getNameserverList()[:]
                 print "backup-list:", self.backupNameserverList
                 
                 self.backupNameserverList = iNetwork.getNameserverList()[:]
                 print "backup-list:", self.backupNameserverList
                 
-               self["ButtonGreentext"] = Label(_("Add"))
-               self["ButtonYellowtext"] = Label(_("Delete"))
-               self["ButtonRedtext"] = Label(_("Close"))
-               self["introduction"] = Label(_("Press OK to activate the settings."))
+               self["key_red"] = StaticText(_("Cancel"))
+               self["key_green"] = StaticText(_("Add"))
+               self["key_yellow"] = StaticText(_("Delete"))
+
+               self["introduction"] = StaticText(_("Press OK to activate the settings."))
                 self.createConfig()
                 self.createConfig()
-               
-               self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
+
+               self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+                       {
+                       "cancel": (self.cancel, _("exit nameserver configuration")),
+                       "ok": (self.ok, _("activate current configuration")),
+                       })
+
+               self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "red": (self.cancel, _("exit nameserver configuration")),
+                       "green": (self.add, _("add a nameserver entry")),
+                       "yellow": (self.remove, _("remove a nameserver entry")),
+                       })
+
+               self["actions"] = NumberActionMap(["SetupActions"],
                 {
                         "ok": self.ok,
                 {
                         "ok": self.ok,
-                       "cancel": self.cancel,
-                       "red": self.cancel,
-                       "green": self.add,
-                       "yellow": self.remove
                 }, -2)
                 }, -2)
-               
+
                 self.list = []
                 ConfigListScreen.__init__(self, self.list)
                 self.createSetup()
  
         def createConfig(self):
                 self.nameservers = iNetwork.getNameserverList()
                 self.list = []
                 ConfigListScreen.__init__(self, self.list)
                 self.createSetup()
  
         def createConfig(self):
                 self.nameservers = iNetwork.getNameserverList()
-               self.nameserverEntries = []
-               
-               for nameserver in self.nameservers:
-                       self.nameserverEntries.append(NoSave(ConfigIP(default=nameserver)))
+               self.nameserverEntries = [ NoSave(ConfigIP(default=nameserver)) for nameserver in self.nameservers]
  
         def createSetup(self):
                 self.list = []
  
         def createSetup(self):
                 self.list = []
-               
-               for i in range(len(self.nameserverEntries)):
-                       self.list.append(getConfigListEntry(_("Nameserver %d") % (i + 1), self.nameserverEntries[i]))
-               
+
+               i = 1
+               for x in self.nameserverEntries:
+                       self.list.append(getConfigListEntry(_("Nameserver %d") % (i), x))
+                       i += 1
+
                 self["config"].list = self.list
                 self["config"].l.setList(self.list)
  
                 self["config"].list = self.list
                 self["config"].l.setList(self.list)
  
@@ -128,61 +279,173 @@ class NameserverSetup(Screen, ConfigListScreen):
  
         def remove(self):
                 print "currentIndex:", self["config"].getCurrentIndex()
  
         def remove(self):
                 print "currentIndex:", self["config"].getCurrentIndex()
-               
                 index = self["config"].getCurrentIndex()
                 if index < len(self.nameservers):
                         iNetwork.removeNameserver(self.nameservers[index])
                         self.createConfig()
                         self.createSetup()
                 index = self["config"].getCurrentIndex()
                 if index < len(self.nameservers):
                         iNetwork.removeNameserver(self.nameservers[index])
                         self.createConfig()
                         self.createSetup()
-       
-class AdapterSetup(Screen, ConfigListScreen):
-       def __init__(self, session, iface,essid=None, aplist=None):
+
+
+class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
+       def __init__(self, session, networkinfo, essid=None, aplist=None):
                 Screen.__init__(self, session)
                 Screen.__init__(self, session)
+               HelpableScreen.__init__(self)
                 self.session = session
                 self.session = session
-               self.iface = iface
-               self.essid = essid
-               self.aplist = aplist
+               if isinstance(networkinfo, (list, tuple)):
+                       self.iface = networkinfo[0]
+                       self.essid = networkinfo[1]
+                       self.aplist = networkinfo[2]
+               else:
+                       self.iface = networkinfo
+                       self.essid = essid
+                       self.aplist = aplist
                 self.extended = None
                 self.extended = None
-               iNetwork.getInterfaces()
+               self.applyConfigRef = None
+               self.finished_cb = None
+               self.oktext = _("Press OK on your remote control to continue.")
+               self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
+
+               self.createConfig()
+
+               self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+                       {
+                       "cancel": (self.keyCancel, _("exit network adapter configuration")),
+                       "ok": (self.keySave, _("activate network adapter configuration")),
+                       })
+
+               self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "red": (self.keyCancel, _("exit network adapter configuration")),
+                       "blue": (self.KeyBlue, _("open nameserver configuration")),
+                       })
+
+               self["actions"] = NumberActionMap(["SetupActions"],
+               {
+                       "ok": self.keySave,
+               }, -2)
+
+               self.list = []
+               ConfigListScreen.__init__(self, self.list,session = self.session)
+               self.createSetup()
+               self.onLayoutFinish.append(self.layoutFinished)
+               self.onClose.append(self.cleanup)
+
+               self["DNS1text"] = StaticText(_("Primary DNS"))
+               self["DNS2text"] = StaticText(_("Secondary DNS"))
+               self["DNS1"] = StaticText()
+               self["DNS2"] = StaticText()
+               self["introduction"] = StaticText(_("Current settings:"))
+
+               self["IPtext"] = StaticText(_("IP Address"))
+               self["Netmasktext"] = StaticText(_("Netmask"))
+               self["Gatewaytext"] = StaticText(_("Gateway"))
+
+               self["IP"] = StaticText()
+               self["Mask"] = StaticText()
+               self["Gateway"] = StaticText()
+
+               self["Adaptertext"] = StaticText(_("Network:"))
+               self["Adapter"] = StaticText()
+               self["introduction2"] = StaticText(_("Press OK to activate the settings."))
+               self["key_red"] = StaticText(_("Cancel"))
+               self["key_blue"] = StaticText(_("Edit DNS"))
+
+               self["VKeyIcon"] = Boolean(False)
+               self["HelpWindow"] = Pixmap()
+               self["HelpWindow"].hide()
+               
+       def layoutFinished(self):
+               self["DNS1"].setText(self.primaryDNS.getText())
+               self["DNS2"].setText(self.secondaryDNS.getText())
+               if self.ipConfigEntry.getText() is not None:
+                       if self.ipConfigEntry.getText() == "0.0.0.0":
+                               self["IP"].setText(_("N/A"))
+                       else:   
+                               self["IP"].setText(self.ipConfigEntry.getText())
+               else:
+                       self["IP"].setText(_("N/A"))
+               if self.netmaskConfigEntry.getText() is not None:
+                       if self.netmaskConfigEntry.getText() == "0.0.0.0":
+                                       self["Mask"].setText(_("N/A"))
+                       else:   
+                               self["Mask"].setText(self.netmaskConfigEntry.getText())
+               else:
+                       self["IP"].setText(_("N/A"))                    
+               if iNetwork.getAdapterAttribute(self.iface, "gateway"):
+                       if self.gatewayConfigEntry.getText() == "0.0.0.0":
+                               self["Gatewaytext"].setText(_("Gateway"))
+                               self["Gateway"].setText(_("N/A"))
+                       else:
+                               self["Gatewaytext"].setText(_("Gateway"))
+                               self["Gateway"].setText(self.gatewayConfigEntry.getText())
+               else:
+                       self["Gateway"].setText("")
+                       self["Gatewaytext"].setText("")
+               self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
+
+       def createConfig(self):
+               self.InterfaceEntry = None
+               self.dhcpEntry = None
+               self.gatewayEntry = None
+               self.hiddenSSID = None
+               self.wlanSSID = None
+               self.encryptionEnabled = None
+               self.encryptionKey = None
+               self.encryptionType = None
+               self.nwlist = None
+               self.encryptionlist = None
+               self.weplist = None
+               self.wsconfig = None
+               self.default = None
  
                 if self.iface == "wlan0" or self.iface == "ath0" :
                         from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
  
                 if self.iface == "wlan0" or self.iface == "ath0" :
                         from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
+                       self.w = Wlan(self.iface)
                         self.ws = wpaSupplicant()
                         self.ws = wpaSupplicant()
-                       list = []
-                       list.append(_("WEP"))
-                       list.append(_("WPA"))
-                       list.append(_("WPA2"))
+                       self.encryptionlist = []
+                       self.encryptionlist.append(("WEP", _("WEP")))
+                       self.encryptionlist.append(("WPA", _("WPA")))
+                       self.encryptionlist.append(("WPA2", _("WPA2")))
+                       self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+                       self.weplist = []
+                       self.weplist.append("ASCII")
+                       self.weplist.append("HEX")
                         if self.aplist is not None:
                                 self.nwlist = self.aplist
                                 self.nwlist.sort(key = lambda x: x[0])
                         else:
                                 self.nwlist = []
                         if self.aplist is not None:
                                 self.nwlist = self.aplist
                                 self.nwlist.sort(key = lambda x: x[0])
                         else:
                                 self.nwlist = []
-                               self.w = None
                                 self.aps = None
                                 try:
                                 self.aps = None
                                 try:
-                                       self.w = Wlan(self.iface)
                                         self.aps = self.w.getNetworkList()
                                         if self.aps is not None:
                                         self.aps = self.w.getNetworkList()
                                         if self.aps is not None:
-                                               print "[Wlan.py] got Accespoints!"
-                                               for ap in aps:
-                                                       a = aps[ap]
+                                               for ap in self.aps:
+                                                       a = self.aps[ap]
                                                         if a['active']:
                                                         if a['active']:
-                                                               if a['essid'] == "":
-                                                                       a['essid'] = a['bssid']
-                                                               self.nwlist.append( a['essid'])
+                                                               if a['essid'] != '':
+                                                                       self.nwlist.append((a['essid'],a['essid']))
                                         self.nwlist.sort(key = lambda x: x[0])
                                 except:
                                         self.nwlist.sort(key = lambda x: x[0])
                                 except:
-                                       self.nwlist.append("No Networks found")
-
-                       wsconfig = self.ws.loadConfig()
-                       default = self.essid or wsconfig['ssid']
-                       if default not in self.nwlist:
-                               self.nwlist.append(default)
-                       config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = default ))
-                       config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = wsconfig['encryption'] ))
-                       config.plugins.wlan.encryption.type = NoSave(ConfigSelection(list, default = wsconfig['encryption_type'] ))
-                       config.plugins.wlan.encryption.psk = NoSave(ConfigText(default = wsconfig['key'], fixed_size = False,visible_width = 30))
-               
+                                       self.nwlist.append(("No Networks found",_("No Networks found")))
+
+                       self.wsconfig = self.ws.loadConfig()
+                       if self.essid is not None: # ssid from wlan scan
+                               self.default = self.essid
+                       else:
+                               self.default = self.wsconfig['ssid']
+
+                       if "hidden..." not in self.nwlist:
+                               self.nwlist.append(("hidden...",_("enter hidden network SSID")))
+                       if self.default not in self.nwlist:
+                               self.nwlist.append((self.default,self.default))
+                       config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
+                       config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
+
+                       config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
+                       config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
+                       config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
+                       config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
+
                 self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                 self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
                 self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])
                 self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                 self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
                 self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])
@@ -196,63 +459,11 @@ class AdapterSetup(Screen, ConfigListScreen):
                 nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
                 self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
                 self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
                 nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
                 self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
                 self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
-               
-               self["actions"] = ActionMap(["SetupActions","ShortcutActions"],
-               {
-                       "ok": self.ok,
-                       "cancel": self.cancel,
-                       "red": self.cancel,
-                       "blue": self.KeyBlue,
-               }, -2)
-               
-               self.list = []
-               ConfigListScreen.__init__(self, self.list)
-               self.createSetup()
-               self.onLayoutFinish.append(self.layoutFinished)
-               
-               self["DNS1text"] = Label(_("Primary DNS"))
-               self["DNS2text"] = Label(_("Secondary DNS"))
-               self["DNS1"] = Label()
-               self["DNS2"] = Label()
-               
-               self["introduction"] = Label(_("Current settings:"))
-               
-               self["IPtext"] = Label(_("IP Address"))
-               self["Netmasktext"] = Label(_("Netmask"))
-               self["Gatewaytext"] = Label(_("Gateway"))
-               
-               self["IP"] = Label()
-               self["Mask"] = Label()
-               self["Gateway"] = Label()
-               
-               self["BottomBG"] = Pixmap()
-               self["Adaptertext"] = Label(_("Network:"))
-               self["Adapter"] = Label()
-               self["introduction2"] = Label(_("Press OK to activate the settings."))
-               self["ButtonRed"] = Pixmap()
-               self["ButtonRedtext"] = Label(_("Close"))
-               self["ButtonBlue"] = Pixmap()
-               self["ButtonBluetext"] = Label(_("Edit DNS"))
-
-       def layoutFinished(self):
-               self["DNS1"].setText(self.primaryDNS.getText())
-               self["DNS2"].setText(self.secondaryDNS.getText())
-               if self.ipConfigEntry.getText() is not None:
-                       self["IP"].setText(self.ipConfigEntry.getText())
-               else:
-                       self["IP"].setText([0,0,0,0])
-               self["Mask"].setText(self.netmaskConfigEntry.getText())
-               if iNetwork.getAdapterAttribute(self.iface, "gateway"):
-                       self["Gateway"].setText(self.gatewayConfigEntry.getText())
-               else:
-                       self["Gateway"].hide()
-                       self["Gatewaytext"].hide()
-               self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
-
  
         def createSetup(self):
                 self.list = []
                 self.InterfaceEntry = getConfigListEntry(_("Use Interface"), self.activateInterfaceEntry)
  
         def createSetup(self):
                 self.list = []
                 self.InterfaceEntry = getConfigListEntry(_("Use Interface"), self.activateInterfaceEntry)
+
                 self.list.append(self.InterfaceEntry)
                 if self.activateInterfaceEntry.value:
                         self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
                 self.list.append(self.InterfaceEntry)
                 if self.activateInterfaceEntry.value:
                         self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
@@ -260,27 +471,43 @@ class AdapterSetup(Screen, ConfigListScreen):
                         if not self.dhcpConfigEntry.value:
                                 self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
                                 self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
                         if not self.dhcpConfigEntry.value:
                                 self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
                                 self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
-                               self.list.append(getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry))
+                               self.gatewayEntry = getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry)
+                               self.list.append(self.gatewayEntry)
                                 if self.hasGatewayConfigEntry.value:
                                         self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
                                 if self.hasGatewayConfigEntry.value:
                                         self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
-                                       
+
+                       self.extended = None
                         for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                 callFnc = p.__call__["ifaceSupported"](self.iface)
                                 if callFnc is not None:
                         for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                 callFnc = p.__call__["ifaceSupported"](self.iface)
                                 if callFnc is not None:
-                                       self.extended = callFnc
-                                       if p.__call__.has_key("configStrings"):
-                                               self.configStrings = p.__call__["configStrings"]
-                                       else:
-                                               self.configStrings = None
+                                       if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
+                                               self.extended = callFnc
+                                               if p.__call__.has_key("configStrings"):
+                                                       self.configStrings = p.__call__["configStrings"]
+                                               else:
+                                                       self.configStrings = None
+                                               if config.plugins.wlan.essid.value == 'hidden...':
+                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
+                                                       self.list.append(self.wlanSSID)
+                                                       self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid)
+                                                       self.list.append(self.hiddenSSID)
+                                               else:
+                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
+                                                       self.list.append(self.wlanSSID)
+                                               self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
+                                               self.list.append(self.encryptionEnabled)
                                                 
                                                 
-                                       self.list.append(getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid))
-                                       self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
-                                       self.list.append(self.encryptionEnabled)
-                                       
-                                       if config.plugins.wlan.encryption.enabled.value:
-                                               self.list.append(getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type))
-                                               self.list.append(getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk))
-               
+                                               if config.plugins.wlan.encryption.enabled.value:
+                                                       self.encryptionType = getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type)
+                                                       self.list.append(self.encryptionType)
+                                                       if config.plugins.wlan.encryption.type.value == 'WEP':
+                                                               self.list.append(getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.encryption.wepkeytype))
+                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
+                                                               self.list.append(self.encryptionKey)
+                                                       else:
+                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
+                                                               self.list.append(self.encryptionKey)
+
                 self["config"].list = self.list
                 self["config"].l.setList(self.list)
  
                 self["config"].list = self.list
                 self["config"].l.setList(self.list)
  
@@ -288,21 +515,66 @@ class AdapterSetup(Screen, ConfigListScreen):
                 self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
  
         def newConfig(self):
                 self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
  
         def newConfig(self):
-               print self["config"].getCurrent()
+               if self["config"].getCurrent() == self.InterfaceEntry:
+                       self.createSetup()
                 if self["config"].getCurrent() == self.dhcpEntry:
                         self.createSetup()
                 if self["config"].getCurrent() == self.dhcpEntry:
                         self.createSetup()
+               if self["config"].getCurrent() == self.gatewayEntry:
+                       self.createSetup()
+               if self.iface == "wlan0" or self.iface == "ath0" :
+                       if self["config"].getCurrent() == self.wlanSSID:
+                               self.createSetup()
+                       if self["config"].getCurrent() == self.encryptionEnabled:
+                               self.createSetup()
+                       if self["config"].getCurrent() == self.encryptionType:
+                               self.createSetup()
  
         def keyLeft(self):
                 ConfigListScreen.keyLeft(self)
  
         def keyLeft(self):
                 ConfigListScreen.keyLeft(self)
-               self.createSetup()
+               self.newConfig()
  
         def keyRight(self):
                 ConfigListScreen.keyRight(self)
  
         def keyRight(self):
                 ConfigListScreen.keyRight(self)
-               self.createSetup()
+               self.newConfig()
+       
+       def keySave(self):
+               self.hideInputHelp()
+               if self["config"].isChanged():
+                       self.session.openWithCallback(self.keySaveConfirm, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) )
+               else:
+                       if self.finished_cb:
+                               self.finished_cb()
+                       else:
+                               self.close('cancel')
+
+       def keySaveConfirm(self, ret = False):
+               if (ret == True):               
+                       num_configured_if = len(iNetwork.getConfiguredAdapters())
+                       if num_configured_if >= 1:
+                               if num_configured_if == 1 and self.iface in iNetwork.getConfiguredAdapters():
+                                       self.applyConfig(True)
+                               else:
+                                       self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True)
+                       else:
+                               self.applyConfig(True)
+               else:
+                       self.keyCancel()                
  
  
-       def ok(self):
-               iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
-               if self.activateInterfaceEntry.value is True:
+       def secondIfaceFoundCB(self,data):
+               if data is False:
+                       self.applyConfig(True)
+               else:
+                       configuredInterfaces = iNetwork.getConfiguredAdapters()
+                       for interface in configuredInterfaces:
+                               if interface == self.iface:
+                                       continue
+                               iNetwork.setAdapterAttribute(interface, "up", False)
+                               iNetwork.deactivateInterface(interface)
+                               self.applyConfig(True)
+
+       def applyConfig(self, ret = False):
+               if (ret == True):
+                       iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
                         iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
                         iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
                         iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
                         iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
                         iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
                         iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
@@ -310,29 +582,60 @@ class AdapterSetup(Screen, ConfigListScreen):
                                 iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
                         else:
                                 iNetwork.removeAdapterAttribute(self.iface, "gateway")
                                 iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
                         else:
                                 iNetwork.removeAdapterAttribute(self.iface, "gateway")
-                               
                         if self.extended is not None and self.configStrings is not None:
                                 iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
                                 self.ws.writeConfig()
                         if self.extended is not None and self.configStrings is not None:
                                 iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
                                 self.ws.writeConfig()
+                       if self.activateInterfaceEntry.value is False:
+                               iNetwork.deactivateInterface(self.iface)
+                       iNetwork.writeNetworkConfig()
+                       iNetwork.restartNetwork(self.applyConfigDataAvail)
+                       self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
                 else:
                 else:
-                       iNetwork.removeAdapterAttribute(self.iface, "ip")
-                       iNetwork.removeAdapterAttribute(self.iface, "netmask")
-                       iNetwork.removeAdapterAttribute(self.iface, "gateway")
-                       iNetwork.deactivateInterface(self.iface)
+                       self.keyCancel()
  
  
-               iNetwork.deactivateNetworkConfig()
-               iNetwork.writeNetworkConfig()
-               iNetwork.activateNetworkConfig()
-               self.close()
+       def applyConfigDataAvail(self, data):
+               if data is True:
+                       iNetwork.getInterfaces(self.getInterfacesDataAvail)
  
  
-       def cancel(self):
-               if self.activateInterfaceEntry.value is False:
-                       iNetwork.deactivateInterface(self.iface)
-               iNetwork.getInterfaces()
-               self.close()
+       def getInterfacesDataAvail(self, data):
+               if data is True:
+                       self.applyConfigRef.close(True)
  
  
-       def run(self):
-               self.ok()
+       def applyConfigfinishedCB(self,data):
+               if data is True:
+                       if self.finished_cb:
+                               self.session.openWithCallback(lambda x : self.finished_cb(), MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+                       else:
+                               self.session.openWithCallback(self.ConfigfinishedCB, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+
+       def ConfigfinishedCB(self,data):
+               if data is not None:
+                       if data is True:
+                               self.close('ok')
+
+       def keyCancelConfirm(self, result):
+               if not result:
+                       return
+               if self.oldInterfaceState is False:
+                       iNetwork.deactivateInterface(self.iface,self.keyCancelCB)
+               else:
+                       self.close('cancel')
+
+       def keyCancel(self):
+               self.hideInputHelp()
+               if self["config"].isChanged():
+                       self.session.openWithCallback(self.keyCancelConfirm, MessageBox, _("Really close without saving settings?"))
+               else:
+                       self.close('cancel')
+
+       def keyCancelCB(self,data):
+               if data is not None:
+                       if data is True:
+                               self.close('cancel')
+
+       def runAsync(self, finished_cb):
+               self.finished_cb = finished_cb
+               self.keySave()
  
         def NameserverSetupClosed(self, *ret):
                 iNetwork.loadNameserverConfig()
  
         def NameserverSetupClosed(self, *ret):
                 iNetwork.loadNameserverConfig()
@@ -341,30 +644,61 @@ class AdapterSetup(Screen, ConfigListScreen):
                 self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
                 self.createSetup()
                 self.layoutFinished()
                 self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
                 self.createSetup()
                 self.layoutFinished()
-       
  
  
-class AdapterSetupConfiguration(Screen):
+       def cleanup(self):
+               iNetwork.stopLinkStateConsole()
+               
+       def hideInputHelp(self):
+               current = self["config"].getCurrent()
+               if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+               elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+
+
+class AdapterSetupConfiguration(Screen, HelpableScreen):
         def __init__(self, session,iface):
                 Screen.__init__(self, session)
         def __init__(self, session,iface):
                 Screen.__init__(self, session)
+               HelpableScreen.__init__(self)
                 self.session = session
                 self.iface = iface
                 self.session = session
                 self.iface = iface
+               self.restartLanRef = None
+               self.LinkState = None
                 self.mainmenu = self.genMainMenu()
                 self["menulist"] = MenuList(self.mainmenu)
                 self.mainmenu = self.genMainMenu()
                 self["menulist"] = MenuList(self.mainmenu)
-               self["description"] = Label()
-               self["IFtext"] = Label()
-               self["IF"] = Label()
-               self["BottomBG"] = Label()
-               self["Statustext"] = Label()
+               self["key_red"] = StaticText(_("Close"))
+               self["description"] = StaticText()
+               self["IFtext"] = StaticText()
+               self["IF"] = StaticText()
+               self["Statustext"] = StaticText()
                 self["statuspic"] = MultiPixmap()
                 self["statuspic"].hide()
                 self["statuspic"] = MultiPixmap()
                 self["statuspic"].hide()
-               self["BottomBG"] = Pixmap()
-               self["ButtonRed"] = Pixmap()
-               self["ButtonRedtext"] = Label(_("Close"))
                 
                 self.oktext = _("Press OK on your remote control to continue.")
                 self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
                 
                 self.oktext = _("Press OK on your remote control to continue.")
                 self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
-               self.errortext = _("No working wireless interface found.\n Please verify that you have attached a compatible WLAN device or enable you local network interface.")       
+               self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")      
                 
                 
+               self["WizardActions"] = HelpableActionMap(self, "WizardActions",
+                       {
+                       "up": (self.up, _("move up to previous entry")),
+                       "down": (self.down, _("move down to next entry")),
+                       "left": (self.left, _("move up to first entry")),
+                       "right": (self.right, _("move down to last entry")),
+                       })
+               
+               self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+                       {
+                       "cancel": (self.close, _("exit networkadapter setup menu")),
+                       "ok": (self.ok, _("select menu entry")),
+                       })
+
+               self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "red": (self.close, _("exit networkadapter setup menu")),       
+                       })
+
                 self["actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
                 {
                         "ok": self.ok,
                 self["actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
                 {
                         "ok": self.ok,
@@ -376,13 +710,12 @@ class AdapterSetupConfiguration(Screen):
                         "right": self.right,
                 }, -2)
                 
                         "right": self.right,
                 }, -2)
                 
-               iNetwork.getInterfaces()
-               self.onLayoutFinish.append(self.layoutFinished)
                 self.updateStatusbar()
                 self.updateStatusbar()
+               self.onLayoutFinish.append(self.layoutFinished)
+               self.onClose.append(self.cleanup)
  
         def ok(self):
  
         def ok(self):
-               print "SELF.iFACE im OK Klick",self.iface
-               print "self.menulist.getCurrent()[1]",self["menulist"].getCurrent()[1]
+               self.cleanup()
                 if self["menulist"].getCurrent()[1] == 'edit':
                         if self.iface == 'wlan0' or self.iface == 'ath0':
                                 try:
                 if self["menulist"].getCurrent()[1] == 'edit':
                         if self.iface == 'wlan0' or self.iface == 'ath0':
                                 try:
@@ -428,7 +761,7 @@ class AdapterSetupConfiguration(Screen):
                                 ifobj = Wireless(self.iface) # a Wireless NIC Object
                                 self.wlanresponse = ifobj.getStatistics()
                                 if self.wlanresponse[0] != 19:
                                 ifobj = Wireless(self.iface) # a Wireless NIC Object
                                 self.wlanresponse = ifobj.getStatistics()
                                 if self.wlanresponse[0] != 19:
-                                       self.session.open(WlanStatus,self.iface)
+                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                 else:
                                         # Display Wlan not available Message
                                         self.showErrorMessage()
                                 else:
                                         # Display Wlan not available Message
                                         self.showErrorMessage()
@@ -437,6 +770,9 @@ class AdapterSetupConfiguration(Screen):
                 if self["menulist"].getCurrent()[1] == 'openwizard':
                         from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
                         self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard)
                 if self["menulist"].getCurrent()[1] == 'openwizard':
                         from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
                         self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard)
+               if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
+                       self.extended = self["menulist"].getCurrent()[1][2]
+                       self.extended(self.session, self.iface)
         
         def up(self):
                 self["menulist"].up()
         
         def up(self):
                 self["menulist"].up()
@@ -467,34 +803,33 @@ class AdapterSetupConfiguration(Screen):
                 if self["menulist"].getCurrent()[1] == 'dns':
                         self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'scanwlan':
                 if self["menulist"].getCurrent()[1] == 'dns':
                         self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'scanwlan':
-                       self["description"].setText(_("Scan your network for wireless Access Points and connect to them using your WLAN USB Stick\n" ) + self.oktext )
+                       self["description"].setText(_("Scan your network for wireless Access Points and connect to them using your selected wireless device.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
                         self["description"].setText(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'lanrestart':
                         self["description"].setText(_("Restart your network connection and interfaces.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'openwizard':
                         self["description"].setText(_("Use the Networkwizard to configure your Network\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
                         self["description"].setText(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'lanrestart':
                         self["description"].setText(_("Restart your network connection and interfaces.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'openwizard':
                         self["description"].setText(_("Use the Networkwizard to configure your Network\n" ) + self.oktext )
-
-       def updateStatusbar(self):
+               if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
+                       self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
+               
+       def updateStatusbar(self, data = None):
+               self.mainmenu = self.genMainMenu()
+               self["menulist"].l.setList(self.mainmenu)
                 self["IFtext"].setText(_("Network:"))
                 self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                 self["Statustext"].setText(_("Link:"))
                 
                 if self.iface == 'wlan0' or self.iface == 'ath0':
                         try:
                 self["IFtext"].setText(_("Network:"))
                 self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                 self["Statustext"].setText(_("Link:"))
                 
                 if self.iface == 'wlan0' or self.iface == 'ath0':
                         try:
-                               from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
-                               w = Wlan(self.iface)
-                               stats = w.getStatus()
-                               if stats['BSSID'] == "00:00:00:00:00:00":
-                                       self["statuspic"].setPixmapNum(1)
-                               else:
-                                       self["statuspic"].setPixmapNum(0)
-                               self["statuspic"].show()
+                               from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                         except:
                         except:
-                                       self["statuspic"].setPixmapNum(1)
-                                       self["statuspic"].show()
+                               self["statuspic"].setPixmapNum(1)
+                               self["statuspic"].show()
+                       else:
+                               iStatus.getDataForInterface(self.iface,self.getInfoCB)
                 else:
                 else:
-                       self.getLinkState(self.iface)
+                       iNetwork.getLinkState(self.iface,self.dataAvail)
  
         def doNothing(self):
                 pass
  
         def doNothing(self):
                 pass
@@ -505,59 +840,153 @@ class AdapterSetupConfiguration(Screen):
                 menu.append((_("Nameserver settings"), "dns"))
                 menu.append((_("Network test"), "test"))
                 menu.append((_("Restart network"), "lanrestart"))
                 menu.append((_("Nameserver settings"), "dns"))
                 menu.append((_("Network test"), "test"))
                 menu.append((_("Restart network"), "lanrestart"))
-               
+
+               self.extended = None
+               self.extendedSetup = None               
                 for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                         callFnc = p.__call__["ifaceSupported"](self.iface)
                         if callFnc is not None:
                 for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                         callFnc = p.__call__["ifaceSupported"](self.iface)
                         if callFnc is not None:
-                               menu.append((_("Scan Wireless Networks"), "scanwlan"))
-                               if iNetwork.getAdapterAttribute(self.iface, "up"):
-                                       menu.append((_("Show WLAN Status"), "wlanstatus"))
-                               
+                               self.extended = callFnc
+                               if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
+                                       menu.append((_("Scan Wireless Networks"), "scanwlan"))
+                                       if iNetwork.getAdapterAttribute(self.iface, "up"):
+                                               menu.append((_("Show WLAN Status"), "wlanstatus"))
+                               else:
+                                       if p.__call__.has_key("menuEntryName"):
+                                               menuEntryName = p.__call__["menuEntryName"](self.iface)
+                                       else:
+                                               menuEntryName = _('Extended Setup...')
+                                       if p.__call__.has_key("menuEntryDescription"):
+                                               menuEntryDescription = p.__call__["menuEntryDescription"](self.iface)
+                                       else:
+                                               menuEntryDescription = _('Extended Networksetup Plugin...')
+                                       self.extendedSetup = ('extendedSetup',menuEntryDescription, self.extended)
+                                       menu.append((menuEntryName,self.extendedSetup))                                 
+                       
                 if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
                 if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
-                       menu.append((_("NetworkWizard"), "openwizard"));
+                       menu.append((_("NetworkWizard"), "openwizard"))
+
                 return menu
  
         def AdapterSetupClosed(self, *ret):
                 return menu
  
         def AdapterSetupClosed(self, *ret):
-               self.mainmenu = self.genMainMenu()
-               self["menulist"].l.setList(self.mainmenu)
-               iNetwork.getInterfaces()
-               self.updateStatusbar()
+               if ret is not None and len(ret):
+                       if ret[0] == 'ok' and (self.iface == 'wlan0' or self.iface == 'ath0') and iNetwork.getAdapterAttribute(self.iface, "up") is True:
+                               try:
+                                       from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
+                                       from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+                               except ImportError:
+                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                               else:   
+                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
+                                       self.wlanresponse = ifobj.getStatistics()
+                                       if self.wlanresponse[0] != 19:
+                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+                                       else:
+                                               # Display Wlan not available Message
+                                               self.showErrorMessage()
+                       else:
+                               self.updateStatusbar()
+               else:
+                       self.updateStatusbar()
+
+       def WlanStatusClosed(self, *ret):
+               if ret is not None and len(ret):
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+                       iStatus.stopWlanConsole()
+                       self.updateStatusbar()
  
         def WlanScanClosed(self,*ret):
                 if ret[0] is not None:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
                 else:
  
         def WlanScanClosed(self,*ret):
                 if ret[0] is not None:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
                 else:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,None,ret[0])
-
-
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+                       iStatus.stopWlanConsole()
+                       self.updateStatusbar()
+                       
         def restartLan(self, ret = False):
                 if (ret == True):
         def restartLan(self, ret = False):
                 if (ret == True):
-                       iNetwork.restartNetwork()
+                       iNetwork.restartNetwork(self.restartLanDataAvail)
+                       self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while your network is restarting..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       
+       def restartLanDataAvail(self, data):
+               if data is True:
+                       iNetwork.getInterfaces(self.getInterfacesDataAvail)
  
  
-       def getLinkState(self,iface):
-               iNetwork.getLinkState(iface,self.dataAvail)
+       def getInterfacesDataAvail(self, data):
+               if data is True:
+                       self.restartLanRef.close(True)
+
+       def restartfinishedCB(self,data):
+               if data is True:
+                       self.updateStatusbar()
+                       self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
  
         def dataAvail(self,data):
  
         def dataAvail(self,data):
-               self.output = data.strip()
-               result = self.output.split('\n')
-               pattern = re_compile("Link detected: yes")
-               for item in result:
-                       if re_search(pattern, item):
-                               self["statuspic"].setPixmapNum(0)
-                       else:
-                               self["statuspic"].setPixmapNum(1)
-               self["statuspic"].show()
+               self.LinkState = None
+               for line in data.splitlines():
+                       line = line.strip()
+                       if 'Link detected:' in line:
+                               if "yes" in line:
+                                       self.LinkState = True
+                               else:
+                                       self.LinkState = False
+               if self.LinkState == True:
+                       iNetwork.checkNetworkState(self.checkNetworkCB)
+               else:
+                       self["statuspic"].setPixmapNum(1)
+                       self["statuspic"].show()                        
  
         def showErrorMessage(self):
                 self.session.open(MessageBox, self.errortext, type = MessageBox.TYPE_INFO,timeout = 10 )
  
         def showErrorMessage(self):
                 self.session.open(MessageBox, self.errortext, type = MessageBox.TYPE_INFO,timeout = 10 )
+               
+       def cleanup(self):
+               iNetwork.stopLinkStateConsole()
+               iNetwork.stopDeactivateInterfaceConsole()
+               iNetwork.stopPingConsole()
+               try:
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+               except ImportError:
+                       pass
+               else:
+                       iStatus.stopWlanConsole()
+
+       def getInfoCB(self,data,status):
+               self.LinkState = None
+               if data is not None:
+                       if data is True:
+                               if status is not None:
+                                       if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+                                               self.LinkState = False
+                                               self["statuspic"].setPixmapNum(1)
+                                               self["statuspic"].show()
+                                       else:
+                                               self.LinkState = True
+                                               iNetwork.checkNetworkState(self.checkNetworkCB)
+
+       def checkNetworkCB(self,data):
+               if iNetwork.getAdapterAttribute(self.iface, "up") is True:
+                       if self.LinkState is True:
+                               if data <= 2:
+                                       self["statuspic"].setPixmapNum(0)
+                               else:
+                                       self["statuspic"].setPixmapNum(1)
+                               self["statuspic"].show()        
+                       else:
+                               self["statuspic"].setPixmapNum(1)
+                               self["statuspic"].show()
+               else:
+                       self["statuspic"].setPixmapNum(1)
+                       self["statuspic"].show()
  
  
  class NetworkAdapterTest(Screen):      
         def __init__(self, session,iface):
                 Screen.__init__(self, session)
                 self.iface = iface
  
  
  class NetworkAdapterTest(Screen):      
         def __init__(self, session,iface):
                 Screen.__init__(self, session)
                 self.iface = iface
-               iNetwork.getInterfaces()
+               self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
                 self.setLabels()
                 self.setLabels()
+               self.onClose.append(self.cleanup)
+               self.onHide.append(self.cleanup)
                 
                 self["updown_actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
                 {
                 
                 self["updown_actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
                 {
@@ -570,8 +999,8 @@ class NetworkAdapterTest(Screen):
                 
                 self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
                 {
                 
                 self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
                 {
-                       "red": self.close,
-                       "back": self.close,
+                       "red": self.cancel,
+                       "back": self.cancel,
                 }, -2)
                 self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
                 {
                 }, -2)
                 self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
                 {
@@ -602,12 +1031,18 @@ class NetworkAdapterTest(Screen):
                 self.nextStepTimer = eTimer()
                 self.nextStepTimer.callback.append(self.nextStepTimerFire)
  
                 self.nextStepTimer = eTimer()
                 self.nextStepTimer.callback.append(self.nextStepTimerFire)
  
+       def cancel(self):
+               if self.oldInterfaceState is False:
+                       iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
+                       iNetwork.deactivateInterface(self.iface)
+               self.close()
+
         def closeInfo(self):
                 self["shortcuts"].setEnabled(True)              
                 self["infoshortcuts"].setEnabled(False)
                 self["InfoText"].hide()
                 self["InfoTextBorder"].hide()
         def closeInfo(self):
                 self["shortcuts"].setEnabled(True)              
                 self["infoshortcuts"].setEnabled(False)
                 self["InfoText"].hide()
                 self["InfoTextBorder"].hide()
-               self["ButtonRedtext"].setText(_("Close"))
+               self["key_red"].setText(_("Close"))
  
         def delTimer(self):
                 del self.steptimer
  
         def delTimer(self):
                 del self.steptimer
@@ -695,6 +1130,7 @@ class NetworkAdapterTest(Screen):
         def doStep1(self):
                 self.steptimer = True
                 self.nextStepTimer.start(3000)
         def doStep1(self):
                 self.steptimer = True
                 self.nextStepTimer.start(3000)
+               self["key_yellow"].setText(_("Stop test"))
  
         def doStep2(self):
                 self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
  
         def doStep2(self):
                 self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
@@ -707,6 +1143,7 @@ class NetworkAdapterTest(Screen):
  
         def doStep3(self):
                 self["Networktext"].setForegroundColorNum(1)
  
         def doStep3(self):
                 self["Networktext"].setForegroundColorNum(1)
+               self["Network"].setText(_("Please wait..."))
                 self.getLinkState(self.iface)
                 self["NetworkInfo_Text"].setForegroundColorNum(1)
                 self.steptimer = True
                 self.getLinkState(self.iface)
                 self["NetworkInfo_Text"].setForegroundColorNum(1)
                 self.steptimer = True
@@ -729,55 +1166,22 @@ class NetworkAdapterTest(Screen):
  
         def doStep5(self):
                 self["IPtext"].setForegroundColorNum(1)
  
         def doStep5(self):
                 self["IPtext"].setForegroundColorNum(1)
-               ret = iNetwork.checkNetworkState()
-               if ret == True:
-                       self["IP"].setForegroundColorNum(2)
-                       self["IP"].setText(_("confirmed"))
-                       self["IPInfo_Check"].setPixmapNum(0)
-               else:
-                       self["IP"].setForegroundColorNum(1)
-                       self["IP"].setText(_("unconfirmed"))
-                       self["IPInfo_Check"].setPixmapNum(1)
-               self["IPInfo_Check"].show()
-               self["IPInfo_Text"].setForegroundColorNum(1)
-               self.steptimer = True
-               self.nextStepTimer.start(3000)
+               self["IP"].setText(_("Please wait..."))
+               iNetwork.checkNetworkState(self.NetworkStatedataAvail)
  
         def doStep6(self):
                 self.steptimer = False
                 self.nextStepTimer.stop()
                 self["DNStext"].setForegroundColorNum(1)
  
         def doStep6(self):
                 self.steptimer = False
                 self.nextStepTimer.stop()
                 self["DNStext"].setForegroundColorNum(1)
-               ret = iNetwork.checkDNSLookup()
-               if ret == True:
-                       self["DNS"].setForegroundColorNum(2)
-                       self["DNS"].setText(_("confirmed"))
-                       self["DNSInfo_Check"].setPixmapNum(0)
-               else:
-                       self["DNS"].setForegroundColorNum(1)
-                       self["DNS"].setText(_("unconfirmed"))
-                       self["DNSInfo_Check"].setPixmapNum(1)
-               self["DNSInfo_Check"].show()
-               self["DNSInfo_Text"].setForegroundColorNum(1)
-               
-               self["EditSettings_Text"].show()
-               self["EditSettingsButton"].setPixmapNum(1)
-               self["EditSettings_Text"].setForegroundColorNum(2) # active
-               self["EditSettingsButton"].show()
-               self["ButtonYellow_Check"].setPixmapNum(1)
-               self["ButtonGreentext"].setText(_("Restart test"))
-               self["ButtonGreen_Check"].setPixmapNum(0)
-               self["shortcutsgreen"].setEnabled(False)
-               self["shortcutsgreen_restart"].setEnabled(True)
-               self["shortcutsyellow"].setEnabled(False)
-               self["updown_actions"].setEnabled(True)
-               self.activebutton = 6
+               self["DNS"].setText(_("Please wait..."))
+               iNetwork.checkDNSLookup(self.DNSLookupdataAvail)
  
         def KeyGreen(self):
                 self["shortcutsgreen"].setEnabled(False)
                 self["shortcutsyellow"].setEnabled(True)
                 self["updown_actions"].setEnabled(False)
  
         def KeyGreen(self):
                 self["shortcutsgreen"].setEnabled(False)
                 self["shortcutsyellow"].setEnabled(True)
                 self["updown_actions"].setEnabled(False)
-               self["ButtonYellow_Check"].setPixmapNum(0)
-               self["ButtonGreen_Check"].setPixmapNum(1)
+               self["key_yellow"].setText("")
+               self["key_green"].setText("")
                 self.steptimer = True
                 self.nextStepTimer.start(1000)
  
                 self.steptimer = True
                 self.nextStepTimer.start(1000)
  
@@ -798,8 +1202,8 @@ class NetworkAdapterTest(Screen):
                 self["shortcutsgreen"].setEnabled(False)
                 self["shortcutsyellow"].setEnabled(True)
                 self["updown_actions"].setEnabled(False)
                 self["shortcutsgreen"].setEnabled(False)
                 self["shortcutsyellow"].setEnabled(True)
                 self["updown_actions"].setEnabled(False)
-               self["ButtonYellow_Check"].setPixmapNum(0)
-               self["ButtonGreen_Check"].setPixmapNum(1)
+               self["key_yellow"].setText("")
+               self["key_green"].setText("")
                 self.steptimer = True
                 self.nextStepTimer.start(1000)
  
                 self.steptimer = True
                 self.nextStepTimer.start(1000)
  
@@ -810,27 +1214,27 @@ class NetworkAdapterTest(Screen):
                         self["InfoText"].setText(_("This test detects your configured LAN-Adapter."))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
                         self["InfoText"].setText(_("This test detects your configured LAN-Adapter."))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
-                       self["ButtonRedtext"].setText(_("Back"))
+                       self["key_red"].setText(_("Back"))
                 if self.activebutton == 2: #LAN Check
                         self["InfoText"].setText(_("This test checks whether a network cable is connected to your LAN-Adapter.\nIf you get a \"disconnected\" message:\n- verify that a network cable is attached\n- verify that the cable is not broken"))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
                 if self.activebutton == 2: #LAN Check
                         self["InfoText"].setText(_("This test checks whether a network cable is connected to your LAN-Adapter.\nIf you get a \"disconnected\" message:\n- verify that a network cable is attached\n- verify that the cable is not broken"))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
-                       self["ButtonRedtext"].setText(_("Back"))
+                       self["key_red"].setText(_("Back"))
                 if self.activebutton == 3: #DHCP Check
                         self["InfoText"].setText(_("This test checks whether your LAN Adapter is set up for automatic IP Address configuration with DHCP.\nIf you get a \"disabled\" message:\n - then your LAN Adapter is configured for manual IP Setup\n- verify thay you have entered correct IP informations in the AdapterSetup dialog.\nIf you get an \"enabeld\" message:\n-verify that you have a configured and working DHCP Server in your network."))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
                 if self.activebutton == 3: #DHCP Check
                         self["InfoText"].setText(_("This test checks whether your LAN Adapter is set up for automatic IP Address configuration with DHCP.\nIf you get a \"disabled\" message:\n - then your LAN Adapter is configured for manual IP Setup\n- verify thay you have entered correct IP informations in the AdapterSetup dialog.\nIf you get an \"enabeld\" message:\n-verify that you have a configured and working DHCP Server in your network."))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
-                       self["ButtonRedtext"].setText(_("Back"))
+                       self["key_red"].setText(_("Back"))
                 if self.activebutton == 4: # IP Check
                         self["InfoText"].setText(_("This test checks whether a valid IP Address is found for your LAN Adapter.\nIf you get a \"unconfirmed\" message:\n- no valid IP Address was found\n- please check your DHCP, cabling and adapter setup"))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
                 if self.activebutton == 4: # IP Check
                         self["InfoText"].setText(_("This test checks whether a valid IP Address is found for your LAN Adapter.\nIf you get a \"unconfirmed\" message:\n- no valid IP Address was found\n- please check your DHCP, cabling and adapter setup"))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
-                       self["ButtonRedtext"].setText(_("Back"))
+                       self["key_red"].setText(_("Back"))
                 if self.activebutton == 5: # DNS Check
                         self["InfoText"].setText(_("This test checks for configured Nameservers.\nIf you get a \"unconfirmed\" message:\n- please check your DHCP, cabling and Adapter setup\n- if you configured your Nameservers manually please verify your entries in the \"Nameserver\" Configuration"))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
                 if self.activebutton == 5: # DNS Check
                         self["InfoText"].setText(_("This test checks for configured Nameservers.\nIf you get a \"unconfirmed\" message:\n- please check your DHCP, cabling and Adapter setup\n- if you configured your Nameservers manually please verify your entries in the \"Nameserver\" Configuration"))
                         self["InfoTextBorder"].show()
                         self["InfoText"].show()
-                       self["ButtonRedtext"].setText(_("Back"))
+                       self["key_red"].setText(_("Back"))
                 if self.activebutton == 6: # Edit Settings
                         self.session.open(AdapterSetup,self.iface)
  
                 if self.activebutton == 6: # Edit Settings
                         self.session.open(AdapterSetup,self.iface)
  
@@ -839,9 +1243,8 @@ class NetworkAdapterTest(Screen):
                 self["shortcutsgreen_restart"].setEnabled(True)
                 self["shortcutsgreen"].setEnabled(False)
                 self["shortcutsyellow"].setEnabled(False)
                 self["shortcutsgreen_restart"].setEnabled(True)
                 self["shortcutsgreen"].setEnabled(False)
                 self["shortcutsyellow"].setEnabled(False)
-               self["ButtonGreentext"].setText(_("Restart test"))
-               self["ButtonYellow_Check"].setPixmapNum(1)
-               self["ButtonGreen_Check"].setPixmapNum(0)
+               self["key_green"].setText(_("Restart test"))
+               self["key_yellow"].setText("")
                 self.steptimer = False
                 self.nextStepTimer.stop()
  
                 self.steptimer = False
                 self.nextStepTimer.stop()
  
@@ -856,6 +1259,7 @@ class NetworkAdapterTest(Screen):
                 self["EditSettingsButton"].hide()
                 self["InfoText"].hide()
                 self["InfoTextBorder"].hide()
                 self["EditSettingsButton"].hide()
                 self["InfoText"].hide()
                 self["InfoTextBorder"].hide()
+               self["key_yellow"].setText("")
  
         def setLabels(self):
                 self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))
  
         def setLabels(self):
                 self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))
@@ -895,14 +1299,9 @@ class NetworkAdapterTest(Screen):
                 self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
                 self["EditSettingsButton"] = MultiPixmap()
                 
                 self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
                 self["EditSettingsButton"] = MultiPixmap()
                 
-               self["ButtonRedtext"] = Label(_("Close"))
-               self["ButtonRed"] = Pixmap()
-
-               self["ButtonGreentext"] = Label(_("Start test"))
-               self["ButtonGreen_Check"] = MultiPixmap()
-               
-               self["ButtonYellowtext"] = Label(_("Stop test"))
-               self["ButtonYellow_Check"] = MultiPixmap()
+               self["key_red"] = StaticText(_("Close"))
+               self["key_green"] = StaticText(_("Start test"))
+               self["key_yellow"] = StaticText(_("Stop test"))
                 
                 self["InfoTextBorder"] = Pixmap()
                 self["InfoText"] = Label()
                 
                 self["InfoTextBorder"] = Pixmap()
                 self["InfoText"] = Label()
@@ -910,28 +1309,18 @@ class NetworkAdapterTest(Screen):
         def getLinkState(self,iface):
                 if iface == 'wlan0' or iface == 'ath0':
                         try:
         def getLinkState(self,iface):
                 if iface == 'wlan0' or iface == 'ath0':
                         try:
-                               from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
-                               w = Wlan(iface)
-                               stats = w.getStatus()
-                               if stats['BSSID'] == "00:00:00:00:00:00":
-                                       self["Network"].setForegroundColorNum(1)
-                                       self["Network"].setText(_("disconnected"))
-                                       self["NetworkInfo_Check"].setPixmapNum(1)
-                                       self["NetworkInfo_Check"].show()
-                               else:
-                                       self["Network"].setForegroundColorNum(2)
-                                       self["Network"].setText(_("connected"))
-                                       self["NetworkInfo_Check"].setPixmapNum(0)
-                                       self["NetworkInfo_Check"].show()
+                               from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
                         except:
                                         self["Network"].setForegroundColorNum(1)
                                         self["Network"].setText(_("disconnected"))
                                         self["NetworkInfo_Check"].setPixmapNum(1)
                                         self["NetworkInfo_Check"].show()
                         except:
                                         self["Network"].setForegroundColorNum(1)
                                         self["Network"].setText(_("disconnected"))
                                         self["NetworkInfo_Check"].setPixmapNum(1)
                                         self["NetworkInfo_Check"].show()
+                       else:
+                               iStatus.getDataForInterface(self.iface,self.getInfoCB)
                 else:
                 else:
-                       iNetwork.getLinkState(iface,self.dataAvail)
+                       iNetwork.getLinkState(iface,self.LinkStatedataAvail)
  
  
-       def dataAvail(self,data):
+       def LinkStatedataAvail(self,data):
                 self.output = data.strip()
                 result = self.output.split('\n')
                 pattern = re_compile("Link detected: yes")
                 self.output = data.strip()
                 result = self.output.split('\n')
                 pattern = re_compile("Link detected: yes")
@@ -946,4 +1335,65 @@ class NetworkAdapterTest(Screen):
                                 self["NetworkInfo_Check"].setPixmapNum(1)
                 self["NetworkInfo_Check"].show()
  
                                 self["NetworkInfo_Check"].setPixmapNum(1)
                 self["NetworkInfo_Check"].show()
  
+       def NetworkStatedataAvail(self,data):
+               if data <= 2:
+                       self["IP"].setForegroundColorNum(2)
+                       self["IP"].setText(_("confirmed"))
+                       self["IPInfo_Check"].setPixmapNum(0)
+               else:
+                       self["IP"].setForegroundColorNum(1)
+                       self["IP"].setText(_("unconfirmed"))
+                       self["IPInfo_Check"].setPixmapNum(1)
+               self["IPInfo_Check"].show()
+               self["IPInfo_Text"].setForegroundColorNum(1)            
+               self.steptimer = True
+               self.nextStepTimer.start(3000)          
+               
+       def DNSLookupdataAvail(self,data):
+               if data <= 2:
+                       self["DNS"].setForegroundColorNum(2)
+                       self["DNS"].setText(_("confirmed"))
+                       self["DNSInfo_Check"].setPixmapNum(0)
+               else:
+                       self["DNS"].setForegroundColorNum(1)
+                       self["DNS"].setText(_("unconfirmed"))
+                       self["DNSInfo_Check"].setPixmapNum(1)
+               self["DNSInfo_Check"].show()
+               self["DNSInfo_Text"].setForegroundColorNum(1)
+               self["EditSettings_Text"].show()
+               self["EditSettingsButton"].setPixmapNum(1)
+               self["EditSettings_Text"].setForegroundColorNum(2) # active
+               self["EditSettingsButton"].show()
+               self["key_yellow"].setText("")
+               self["key_green"].setText(_("Restart test"))
+               self["shortcutsgreen"].setEnabled(False)
+               self["shortcutsgreen_restart"].setEnabled(True)
+               self["shortcutsyellow"].setEnabled(False)
+               self["updown_actions"].setEnabled(True)
+               self.activebutton = 6
+
+       def getInfoCB(self,data,status):
+               if data is not None:
+                       if data is True:
+                               if status is not None:
+                                       if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+                                               self["Network"].setForegroundColorNum(1)
+                                               self["Network"].setText(_("disconnected"))
+                                               self["NetworkInfo_Check"].setPixmapNum(1)
+                                               self["NetworkInfo_Check"].show()
+                                       else:
+                                               self["Network"].setForegroundColorNum(2)
+                                               self["Network"].setText(_("connected"))
+                                               self["NetworkInfo_Check"].setPixmapNum(0)
+                                               self["NetworkInfo_Check"].show()
+                                               
+       def cleanup(self):
+               iNetwork.stopLinkStateConsole()
+               iNetwork.stopDNSConsole()
+               try:
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+               except ImportError:
+                       pass
+               else:
+                       iStatus.stopWlanConsole()