NetworkSetup: use manual-nameserver.

[vuplus_dvbapp] / 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 29f9705..e5eb740
--- a/lib/python/Screens/NetworkSetup.py
+++ b/lib/python/Screens/NetworkSetup.py
@@ -1,84 +1,131 @@
  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 Screens.VirtualKeyBoard import VirtualKeyBoard
+from Screens.HelpMenu import HelpableScreen
  from Components.Network import iNetwork
  from Components.Network import iNetwork
+from Components.Sources.StaticText import StaticText
+from Components.Sources.Boolean import Boolean
+from Components.Sources.List import List
  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, ConfigBoolean
  from Components.ConfigList import ConfigListScreen
  from Components.PluginComponent import plugins
  from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
  from Components.ConfigList import ConfigListScreen
  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 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 os import path as os_path, system as os_system, unlink
  from re import compile as re_compile, search as re_search
-from Tools.Directories import resolveFilename, SCOPE_PLUGINS
  
  
-from Tools.Directories import SCOPE_SKIN_IMAGE,SCOPE_PLUGINS, resolveFilename
-from Tools.LoadPixmap import LoadPixmap
-from enigma import RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont
-
-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) ]
-       res.append(MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name))
-       if default is True:
-               png = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/buttons/button_blue.png"))
-       if default is False:
-               png = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/buttons/button_blue_off.png"))
-       res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png))
-       if active is True:
-               png2 = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/icons/lock_on.png"))
-       if active is False:
-               png2 = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/icons/lock_error.png"))
-       res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2))
-       return res
-
-
-class NetworkAdapterSelection(Screen):
+
+class NetworkAdapterSelection(Screen,HelpableScreen):
         def __init__(self, session):
                 Screen.__init__(self, session)
         def __init__(self, session):
                 Screen.__init__(self, session)
-
-               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["key_blue"] = StaticText("")
+               self["introduction"] = StaticText(self.edittext)
                 
                 
-               self["ButtonBluetext"] = Label(_("Set as default Interface"))
-               self["ButtonRedtext"] = Label(_("Close"))
-               self["introduction"] = Label(_("Press OK to edit the settings."))
+               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")),
+                       "blue": (self.openNetworkWizard, _("Use the Networkwizard to configure selected network adapter")),
+                       })
                 
                 
+               self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),
+                       })
+
                 self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
  
                 self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
  
+               if not self.adapters:
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getConfiguredAdapters()]
+
                 if len(self.adapters) == 0:
                 if len(self.adapters) == 0:
-                       self.onFirstExecBegin.append(self.NetworkFallback)
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getInstalledAdapters()]
  
                 self.list = []
  
                 self.list = []
-               self["list"] = InterfaceList(self.list)
+               self["list"] = List(self.list)
                 self.updateList()
                 self.updateList()
-               self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
-               {
-                       "ok": self.okbuttonClick,
-                       "cancel": self.close,
-                       "blue": self.setDefaultInterface,                       
-                       "red": self.close
-               }, -2)
  
                 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 buildInterfaceList(self,iface,name,default,active ):
+               divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
+               defaultpng = None
+               activepng = None
+               description = None
+               interfacepng = None
+
+               if not iNetwork.isWirelessInterface(iface):
+                       if active is True:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-active.png"))
+                       elif active is False:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-inactive.png"))
+                       else:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired.png"))
+               elif iNetwork.isWirelessInterface(iface):
+                       if active is True:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-active.png"))
+                       elif active is False:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-inactive.png"))
+                       else:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless.png"))
+
+               num_configured_if = len(iNetwork.getConfiguredAdapters())
+               if num_configured_if >= 2:
+                       if default is True:
+                               defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
+                       elif default is False:
+                               defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
+               if active is True:
+                       activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
+               elif active is False:
+                       activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
+               
+               description = iNetwork.getFriendlyAdapterDescription(iface)
+
+               return((iface, name, description, interfacepng, defaultpng, activepng, divpng)) 
  
         def updateList(self):
  
         def updateList(self):
-               print "update list"
-               iNetwork.getInterfaces()
                 self.list = []
                 default_gw = None
                 self.list = []
                 default_gw = None
-               num_configured_if = len(iNetwork.configuredInterfaces)
-               print "num_configured_if :",num_configured_if 
+               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 num_configured_if < 2 and os_path.exists("/etc/default_gw"):
                         unlink("/etc/default_gw")
                         
@@ -87,44 +134,42 @@ class NetworkAdapterSelection(Screen):
                         result = fp.read()
                         fp.close()
                         default_gw = result
                         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)
+                                       
+               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(self.buildInterfaceList(x[1],_(x[0]),default_int,active_int ))
+               
+               if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
+                       self["key_blue"].setText(_("NetworkWizard"))
+               self["list"].setList(self.list)
  
         def setDefaultInterface(self):
                 selection = self["list"].getCurrent()
                 num_if = len(self.list)
                 old_default_gw = None
  
         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 os_path.exists("/etc/default_gw"):
                         fp = open('/etc/default_gw', 'r')
                         old_default_gw = fp.read()
                         fp.close()
-               if num_if > 1 and (not old_default_gw or old_default_gw != selection[0]):
+               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()
                         fp = open('/etc/default_gw', 'w+')
                         fp.write(selection[0])
                         fp.close()
-                       iNetwork.restartNetwork()
-                       self.updateList()
-               elif old_default_gw and num_if < 2:
+                       self.restartLan()
+               elif old_default_gw and num_configured_if < 2:
                         unlink("/etc/default_gw")
                         unlink("/etc/default_gw")
-                       iNetwork.restartNetwork()
-                       self.updateList()
+                       self.restartLan()
  
         def okbuttonClick(self):
                 selection = self["list"].getCurrent()
  
         def okbuttonClick(self):
                 selection = self["list"].getCurrent()
-               print "selection",selection
                 if selection is not None:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0])
  
                 if selection is not None:
                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0])
  
@@ -134,61 +179,88 @@ class NetworkAdapterSelection(Screen):
                 else:
                         self.updateList()
  
                 else:
                         self.updateList()
  
-       def NetworkFallback(self):
-               if iNetwork.configuredInterfaces.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               if iNetwork.configuredInterfaces.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 cleanup(self):
+               iNetwork.stopLinkStateConsole()
+               iNetwork.stopRestartConsole()
+               iNetwork.stopGetInterfacesConsole()
  
  
-       def ErrorMessageClosed(self, *ret):
-               if iNetwork.configuredInterfaces.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
-               elif iNetwork.configuredInterfaces.has_key('ath0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
-               else:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
+       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)
+
+       def openNetworkWizard(self):
+               if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
+                       try:
+                               from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
+                       except ImportError:
+                               self.session.open(MessageBox, _("The NetworkWizard extension is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                       else:
+                               selection = self["list"].getCurrent()
+                               if selection is not None:
+                                       self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, selection[0])
  
  
-class NameserverSetup(Screen, ConfigListScreen):
+
+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()
                 self.list = []
                 ConfigListScreen.__init__(self, self.list)
                 self.createSetup()
-
+               
         def createConfig(self):
                 self.nameservers = iNetwork.getNameserverList()
         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)
  
@@ -216,131 +288,172 @@ 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):
                 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]
+               else:
+                       self.iface = networkinfo
+                       self.essid = essid
+                       
                 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")
  
  
-               if self.iface == "wlan0" or self.iface == "ath0" :
-                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
-                       self.ws = wpaSupplicant()
-                       list = []
-                       list.append(_("WEP"))
-                       list.append(_("WPA"))
-                       list.append(_("WPA2"))
-                       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.w = Wlan(self.iface)
-                                       self.aps = self.w.getNetworkList()
-                                       if self.aps is not None:
-                                               print "[Wlan.py] got Accespoints!"
-                                               for ap in aps:
-                                                       a = aps[ap]
-                                                       if a['active']:
-                                                               if a['essid'] == "":
-                                                                       a['essid'] = a['bssid']
-                                                               self.nwlist.append( a['essid'])
-                                       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.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.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask") or [255,0,0,0]))
-               if iNetwork.getAdapterAttribute(self.iface, "gateway"):
-                       self.dhcpdefault=True
-               else:
-                       self.dhcpdefault=False
-               self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=self.dhcpdefault or False))
-               self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway") or [0,0,0,0]))
-               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"],
+               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")),
+                       })
+
+               self["actions"] = NumberActionMap(["SetupActions"],
                 {
                 {
-                       "ok": self.ok,
-                       "cancel": self.cancel,
-                       "red": self.cancel,
-                       "blue": self.KeyBlue,
+                       "ok": self.keySave,
                 }, -2)
                 }, -2)
-               
+
                 self.list = []
                 self.list = []
-               ConfigListScreen.__init__(self, self.list)
+               ConfigListScreen.__init__(self, self.list,session = self.session)
                 self.createSetup()
                 self.onLayoutFinish.append(self.layoutFinished)
                 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()
+
+               self["VKeyIcon"] = Boolean(False)
+               self["HelpWindow"] = Pixmap()
+               self["HelpWindow"].hide()
                 
                 
-               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:
         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())
+                       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:
                 else:
-                       self["IP"].setText([0,0,0,0])
-               self["Mask"].setText(self.netmaskConfigEntry.getText())
+                       self["IP"].setText(_("N/A"))                    
                 if iNetwork.getAdapterAttribute(self.iface, "gateway"):
                 if iNetwork.getAdapterAttribute(self.iface, "gateway"):
-                       self["Gateway"].setText(self.gatewayConfigEntry.getText())
+                       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:
                 else:
-                       self["Gateway"].hide()
-                       self["Gatewaytext"].hide()
+                       self["Gateway"].setText("")
+                       self["Gatewaytext"].setText("")
                 self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
  
                 self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
  
+       def createConfig(self):
+               self.InterfaceEntry = None
+               self.dhcpEntry = None
+               self.gatewayEntry = None
+               self.DNSConfigEntry = None
+               self.hiddenSSID = None
+               self.wlanSSID = None
+               self.encryption = None
+               self.encryptionType = None
+               self.encryptionKey = None
+               self.encryptionlist = None
+               self.weplist = None
+               self.wsconfig = None
+               self.default = None
+
+               if iNetwork.isWirelessInterface(self.iface):
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant
+                       self.ws = wpaSupplicant()
+                       self.encryptionlist = []
+                       self.encryptionlist.append(("Unencrypted", _("Unencrypted")))
+                       self.encryptionlist.append(("WEP", _("WEP")))
+                       self.encryptionlist.append(("WPA", _("WPA")))
+                       self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+                       self.encryptionlist.append(("WPA2", _("WPA2")))
+                       self.weplist = []
+                       self.weplist.append("ASCII")
+                       self.weplist.append("HEX")
+
+                       self.wsconfig = self.ws.loadConfig(self.iface)
+                       if self.essid is None:
+                               self.essid = self.wsconfig['ssid']
+
+                       config.plugins.wlan.hiddenessid = NoSave(ConfigYesNo(default = self.wsconfig['hiddenessid']))
+                       config.plugins.wlan.essid = NoSave(ConfigText(default = self.essid, visible_width = 50, fixed_size = False))
+                       config.plugins.wlan.encryption = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption'] ))
+                       config.plugins.wlan.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['wepkeytype'] ))
+                       config.plugins.wlan.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.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask") or [255,0,0,0]))
+               if iNetwork.getAdapterAttribute(self.iface, "gateway"):
+                       self.dhcpdefault=True
+               else:
+                       self.dhcpdefault=False
+               self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=self.dhcpdefault or False))
+               self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway") or [0,0,0,0]))
+               if iNetwork.getAdapterAttribute(self.iface, "dns-nameservers"):
+                       self.dnsconfigdefault=True
+               else:
+                       self.dnsconfigdefault=False
+               self.hasDNSConfigEntry = NoSave(ConfigYesNo(default=self.dnsconfigdefault or False))
+               manualNameservers = (iNetwork.getInterfacesNameserverList(self.iface) + [[0,0,0,0]] * 2)[0:2]
+               self.manualPrimaryDNS = NoSave(ConfigIP(default=manualNameservers[0]))
+               self.manualSecondaryDNS = NoSave(ConfigIP(default=manualNameservers[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]))
  
         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)
@@ -348,79 +461,193 @@ 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.DNSConfigEntry =  getConfigListEntry(_("Use Manual dns-nameserver"), self.hasDNSConfigEntry)
+                       if self.dhcpConfigEntry.value:
+                               self.list.append(self.DNSConfigEntry)
+                       if self.hasDNSConfigEntry.value or not self.dhcpConfigEntry.value:
+                               self.list.append(getConfigListEntry(_('Primary DNS'), self.manualPrimaryDNS))
+                               self.list.append(getConfigListEntry(_('Secondary DNS'), self.manualSecondaryDNS))
+
+                       self.extended = None
+                       self.configStrings = 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"]
+
+                                               self.hiddenSSID = getConfigListEntry(_("Hidden network"), config.plugins.wlan.hiddenessid)
+                                               self.list.append(self.hiddenSSID)
+                                               self.wlanSSID = getConfigListEntry(_("Networkname (SSID)"), config.plugins.wlan.essid)
+                                               self.list.append(self.wlanSSID)
+                                               self.encryption = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption)
+                                               self.list.append(self.encryption)                                               
+
+                                               self.encryptionType = getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.wepkeytype)
+                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.psk)
                                                 
                                                 
-                                       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.value != "Unencrypted":
+                                                       if config.plugins.wlan.encryption.value == 'WEP':
+                                                               self.list.append(self.encryptionType)
+                                                       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)
  
-       def KeyBlue(self):
-               self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
-
         def newConfig(self):
         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["config"].getCurrent() == self.DNSConfigEntry:
+                       self.createSetup()
+               if iNetwork.isWirelessInterface(self.iface):
+                       if self["config"].getCurrent() == self.encryption:
+                               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 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:
-               iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
-               iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
-               iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
-               if self.hasGatewayConfigEntry.value:
-                       iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
+       def secondIfaceFoundCB(self,data):
+               if data is False:
+                       self.applyConfig(True)
                 else:
                 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()
-               #else:
-               #       iNetwork.removeAdapterAttribute(self.iface, "ip")
-               #       iNetwork.removeAdapterAttribute(self.iface, "netmask")
-               #       iNetwork.removeAdapterAttribute(self.iface, "gateway")
-               #       iNetwork.deactivateInterface(self.iface)
-               if self.activateInterfaceEntry.value is False:
-                       iNetwork.deactivateInterface(self.iface)
-               iNetwork.deactivateNetworkConfig()
-               iNetwork.writeNetworkConfig()
-               iNetwork.activateNetworkConfig()
-               self.close()
+                       configuredInterfaces = iNetwork.getConfiguredAdapters()
+                       for interface in configuredInterfaces:
+                               if interface == self.iface:
+                                       continue
+                               iNetwork.setAdapterAttribute(interface, "up", False)
+                       iNetwork.deactivateInterface(configuredInterfaces,self.deactivateSecondInterfaceCB)
+
+       def deactivateSecondInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfig(True)
+
+       def applyConfig(self, ret = False):
+               if (ret == True):
+                       self.applyConfigRef = None
+                       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)
+                       if self.hasGatewayConfigEntry.value:
+                               iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
+                       else:
+                               iNetwork.removeAdapterAttribute(self.iface, "gateway")
  
  
-       def cancel(self):
-               if self.activateInterfaceEntry.value is False:
-                       iNetwork.deactivateInterface(self.iface)
-               iNetwork.getInterfaces()
-               self.close()
+                       if self.hasDNSConfigEntry.value or not self.dhcpConfigEntry.value:
+                               interfacesDnsLines = self.makeLineDnsNameservers([self.manualPrimaryDNS.value, self.manualSecondaryDNS.value])
+                               if interfacesDnsLines == "" :
+                                       interfacesDnsLines = False
+                               iNetwork.setAdapterAttribute(self.iface, "dns-nameservers", interfacesDnsLines)
+                       else:
+                               iNetwork.setAdapterAttribute(self.iface, "dns-nameservers", False)
  
  
-       def run(self):
-               self.ok()
+                       if (self.extended is not None and self.configStrings is not None):
+                               iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
+                               self.ws.writeConfig(self.iface)
+                               
+                       if self.activateInterfaceEntry.value is False:
+                               iNetwork.deactivateInterface(self.iface,self.deactivateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       else:
+                               if self.oldInterfaceState is False:
+                                       iNetwork.activateInterface(self.iface,self.deactivateInterfaceCB)
+                               else:
+                                       iNetwork.deactivateInterface(self.iface,self.activateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+               else:
+                       self.keyCancel()
+
+       def deactivateInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfigDataAvail(True)
+
+       def activateInterfaceCB(self, data):
+               if data is True:
+                       iNetwork.activateInterface(self.iface,self.applyConfigDataAvail)
+
+       def applyConfigDataAvail(self, data):
+               if data is True:
+                       iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+       def getInterfacesDataAvail(self, data):
+               if data is True:
+                       self.applyConfigRef.close(True)
+
+       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()
@@ -429,30 +656,68 @@ 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.wlanSSID:
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+               elif current == self.encryptionKey and config.plugins.wlan.encryption.value is not "Unencrypted":
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+
+       def makeLineDnsNameservers(self, nameservers = []):
+               line = ""
+               entry = ' '.join([("%d.%d.%d.%d" % tuple(x)) for x in nameservers if x != [0, 0, 0, 0] ])
+               if len(entry):
+                       line+="\tdns-nameservers %s\n" % entry
+               return line
+
+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.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.reboottext = _("Your STB will restart after pressing OK on your remote control.")
+               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.missingwlanplugintxt = _("The wireless LAN plugin is not installed!\nPlease install it.")
                 
                 
+               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,
@@ -464,28 +729,43 @@ 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 queryWirelessDevice(self,iface):
+               try:
+                       from pythonwifi.iwlibs import Wireless
+                       import errno
+               except ImportError:
+                       return False
+               else:
+                       try:
+                               ifobj = Wireless(iface) # a Wireless NIC Object
+                               wlanresponse = ifobj.getAPaddr()
+                       except IOError, (error_no, error_str):
+                               if error_no in (errno.EOPNOTSUPP, errno.ENODEV, errno.EPERM):
+                                       return False
+                               else:
+                                       print "error: ",error_no,error_str
+                                       return True
+                       else:
+                               return True
  
         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["menulist"].getCurrent()[1] == 'edit':
-                       if self.iface == 'wlan0' or self.iface == 'ath0':
+                       if iNetwork.isWirelessInterface(self.iface):
                                 try:
                                         from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
                                 try:
                                         from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
-                                       from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
                                 except ImportError:
                                 except ImportError:
-                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                                 else:
                                 else:
-                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
-                                       self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse[0] != 19: # Wlan Interface found.
+                                       if self.queryWirelessDevice(self.iface):
                                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                                         else:
                                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                                         else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                                               self.showErrorMessage() # Display Wlan not available Message
                         else:
                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                 if self["menulist"].getCurrent()[1] == 'test':
                         else:
                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                 if self["menulist"].getCurrent()[1] == 'test':
@@ -495,36 +775,31 @@ class AdapterSetupConfiguration(Screen):
                 if self["menulist"].getCurrent()[1] == 'scanwlan':
                         try:
                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
                 if self["menulist"].getCurrent()[1] == 'scanwlan':
                         try:
                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
-                               from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
                         except ImportError:
                         except ImportError:
-                               self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                         else:
                         else:
-                               ifobj = Wireless(self.iface) # a Wireless NIC Object
-                               self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse[0] != 19:
+                               if self.queryWirelessDevice(self.iface):
                                         self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
                                 else:
                                         self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
                                 else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
                         try:
                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
                         try:
                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
-                               from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
                         except ImportError:
                         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.open(WlanStatus,self.iface)
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
+                       else:
+                               if self.queryWirelessDevice(self.iface):
+                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                 else:
                                 else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                 if self["menulist"].getCurrent()[1] == 'lanrestart':
                         self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
                 if self["menulist"].getCurrent()[1] == 'openwizard':
                         from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
                 if self["menulist"].getCurrent()[1] == 'lanrestart':
                         self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
                 if self["menulist"].getCurrent()[1] == 'openwizard':
                         from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
-                       self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard)
+                       self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, self.iface)
+               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()
@@ -549,40 +824,39 @@ class AdapterSetupConfiguration(Screen):
  
         def loadDescription(self):
                 if self["menulist"].getCurrent()[1] == 'edit':
  
         def loadDescription(self):
                 if self["menulist"].getCurrent()[1] == 'edit':
-                       self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext )
+                       self["description"].setText(_("Edit the network configuration of your STB.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'test':
                 if self["menulist"].getCurrent()[1] == 'test':
-                       self["description"].setText(_("Test the network configuration of your Dreambox.\n" ) + self.oktext )
+                       self["description"].setText(_("Test the network configuration of your STB.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'dns':
                 if self["menulist"].getCurrent()[1] == 'dns':
-                       self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext )
+                       self["description"].setText(_("Edit the Nameserver configuration of your STB.\n" ) + self.oktext )
                 if self["menulist"].getCurrent()[1] == 'scanwlan':
                 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:"))
                 
                 self["IFtext"].setText(_("Network:"))
                 self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                 self["Statustext"].setText(_("Link:"))
                 
-               if self.iface == 'wlan0' or self.iface == 'ath0':
+               if iNetwork.isWirelessInterface(self.iface):
                         try:
                         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
@@ -590,62 +864,155 @@ class AdapterSetupConfiguration(Screen):
         def genMainMenu(self):
                 menu = []
                 menu.append((_("Adapter settings"), "edit"))
         def genMainMenu(self):
                 menu = []
                 menu.append((_("Adapter settings"), "edit"))
-               menu.append((_("Nameserver settings"), "dns"))
+#              menu.append((_("Nameserver settings"), "dns"))
                 menu.append((_("Network test"), "test"))
                 menu.append((_("Restart network"), "lanrestart"))
                 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 (iNetwork.isWirelessInterface(self.iface) and iNetwork.getAdapterAttribute(self.iface, "up") is True):
+                               try:
+                                       from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
+                               except ImportError:
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
+                               else:   
+                                       if self.queryWirelessDevice(self.iface):
+                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+                                       else:
+                                               self.showErrorMessage() # Display Wlan not available Message
+                       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
+                       iStatus.stopWlanConsole()
+                       self.updateStatusbar()
  
         def WlanScanClosed(self,*ret):
                 if ret[0] is not None:
  
         def WlanScanClosed(self,*ret):
                 if ret[0] is not None:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
+                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0])
                 else:
                 else:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,None,ret[0])
-
-
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+                       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.stopActivateInterfaceConsole()
+               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]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == False:
+                                               self.LinkState = False
+                                               self["statuspic"].setPixmapNum(1)
+                                               self["statuspic"].show()
+                                       else:
+                                               self.LinkState = True
+                                               iNetwork.checkNetworkState(self.checkNetworkCB)
+
+       def checkNetworkCB(self,data):
+               try:
+                       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()
+               except:
+                       pass
  
  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"],
                 {
@@ -658,8 +1025,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"],
                 {
@@ -690,12 +1057,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
@@ -783,6 +1156,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))
@@ -795,6 +1169,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
@@ -817,55 +1192,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)
  
@@ -886,8 +1228,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)
  
@@ -898,27 +1240,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)
  
@@ -927,13 +1269,13 @@ 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()
  
         def layoutFinished(self):
                 self.steptimer = False
                 self.nextStepTimer.stop()
  
         def layoutFinished(self):
+               self.setTitle(_("Network test: ") + iNetwork.getFriendlyAdapterName(self.iface) )
                 self["shortcutsyellow"].setEnabled(False)
                 self["AdapterInfo_OK"].hide()
                 self["NetworkInfo_Check"].hide()
                 self["shortcutsyellow"].setEnabled(False)
                 self["AdapterInfo_OK"].hide()
                 self["NetworkInfo_Check"].hide()
@@ -944,6 +1286,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"))
@@ -952,7 +1295,7 @@ class NetworkAdapterTest(Screen):
                 self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info"))
                 self["AdapterInfo_OK"] = Pixmap()
                 
                 self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info"))
                 self["AdapterInfo_OK"] = Pixmap()
                 
-               if self.iface == 'wlan0' or self.iface == 'ath0':
+               if self.iface in iNetwork.wlan_interfaces:
                         self["Networktext"] = MultiColorLabel(_("Wireless Network"))
                 else:
                         self["Networktext"] = MultiColorLabel(_("Local Network"))
                         self["Networktext"] = MultiColorLabel(_("Wireless Network"))
                 else:
                         self["Networktext"] = MultiColorLabel(_("Local Network"))
@@ -983,45 +1326,30 @@ 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()
  
         def getLinkState(self,iface):
                 
                 self["InfoTextBorder"] = Pixmap()
                 self["InfoText"] = Label()
  
         def getLinkState(self,iface):
-               if iface == 'wlan0' or iface == 'ath0':
+               if iface in iNetwork.wlan_interfaces:
                         try:
                         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
                         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()
                 self.output = data.strip()
-               result = self.output.split('\n')
+               result = self.output.splitlines()
                 pattern = re_compile("Link detected: yes")
                 for item in result:
                         if re_search(pattern, item):
                 pattern = re_compile("Link detected: yes")
                 for item in result:
                         if re_search(pattern, item):
@@ -1034,4 +1362,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]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == 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
+               except ImportError:
+                       pass
+               else:
+                       iStatus.stopWlanConsole()