projects / vuplus_dvbapp / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
add virtual keyboard as easy input help
[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 862bce4..c26302f
--- a/lib/python/Screens/NetworkSetup.py
+++ b/lib/python/Screens/NetworkSetup.py
@@ -1,25 +1,25 @@
 from Screen import Screen
 from Screen import Screen
-from Components.ActionMap import ActionMap,NumberActionMap
 from Screens.MessageBox import MessageBox
 from Screens.InputBox import InputBox
 from Screens.Standby import *
 from Screens.MessageBox import MessageBox
 from Screens.InputBox import InputBox
 from Screens.Standby import *
+from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Screens.HelpMenu import HelpableScreen
 from Components.Network import iNetwork
 from Components.Label import Label,MultiColorLabel
 from Components.Pixmap import Pixmap,MultiPixmap
 from Components.MenuList import MenuList
 from Components.Network import iNetwork
 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, ConfigNothing
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing
 from Components.ConfigList import ConfigListScreen
 from Components.PluginComponent import plugins
 from Components.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_SKIN_IMAGE
+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):
 
 class InterfaceList(MenuList):
        def __init__(self, list, enableWrapAround=False):
@@ -30,11 +30,13 @@ class InterfaceList(MenuList):
 def InterfaceEntryComponent(index,name,default,active ):
        res = [ (index) ]
        res.append(MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name))
 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))
+       num_configured_if = len(iNetwork.getConfiguredAdapters())
+       if num_configured_if >= 2:
+               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:
        if active is True:
                png2 = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/icons/lock_on.png"))
        if active is False:
@@ -43,41 +45,64 @@ def InterfaceEntryComponent(index,name,default,active ):
        return res
 
 
        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)
-
+               HelpableScreen.__init__(self)
+               
                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.")
                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.")
+               self.oktext = _("Press OK on your remote control to continue.")
+               self.restartLanRef = None
                
                self["ButtonBluetext"] = Label(_("Set as default Interface"))
                
                self["ButtonBluetext"] = Label(_("Set as default Interface"))
+               self["ButtonBlue"] = Pixmap()
                self["ButtonRedtext"] = Label(_("Close"))
                self["introduction"] = Label(_("Press OK to edit the settings."))
                
                self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
                self["ButtonRedtext"] = Label(_("Close"))
                self["introduction"] = Label(_("Press OK to edit the settings."))
                
                self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
-
+               
                if len(self.adapters) == 0:
                        self.onFirstExecBegin.append(self.NetworkFallback)
                if len(self.adapters) == 0:
                        self.onFirstExecBegin.append(self.NetworkFallback)
-
+                       
+               self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+                       {
+                       "cancel": (self.close, _("exit networkinterface list")),
+                       "ok": (self.okbuttonClick, _("select interface")),
+                       })
+
+               self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "red": (self.close, _("exit networkinterface list")),   
+                       })
+               
+               self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "blue": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more then one interface is active.")] ),     
+                       })
+               
                self.list = []
                self["list"] = InterfaceList(self.list)
                self.updateList()
                self.list = []
                self["list"] = InterfaceList(self.list)
                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 updateList(self):
                iNetwork.getInterfaces()
                self.list = []
                default_gw = None
        def updateList(self):
                iNetwork.getInterfaces()
                self.list = []
                default_gw = None
-               num_configured_if = len(iNetwork.configuredInterfaces)
+               num_configured_if = len(iNetwork.getConfiguredAdapters())
+               if num_configured_if >= 2:
+                       self["ButtonBlue"].show()
+                       self["ButtonBluetext"].show()
+                       self["DefaultInterfaceAction"].setEnabled(True)
+               else:
+                       self["ButtonBlue"].hide()
+                       self["ButtonBluetext"].hide()
+                       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")
                        
@@ -86,7 +111,7 @@ 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:
                if len(self.adapters) == 0: # no interface available => display only eth0
                        self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
                else:
@@ -106,24 +131,22 @@ class NetworkAdapterSelection(Screen):
                selection = self["list"].getCurrent()
                num_if = len(self.list)
                old_default_gw = None
                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,25 +157,47 @@ class NetworkAdapterSelection(Screen):
                        self.updateList()
 
        def NetworkFallback(self):
                        self.updateList()
 
        def NetworkFallback(self):
-               if iNetwork.configuredInterfaces.has_key('wlan0') is True:
+               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
                        self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
                        self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               if iNetwork.configuredInterfaces.has_key('ath0') is True:
+               if iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
                        self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
                else:
                        self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
 
        def ErrorMessageClosed(self, *ret):
                        self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
                else:
                        self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
 
        def ErrorMessageClosed(self, *ret):
-               if iNetwork.configuredInterfaces.has_key('wlan0') is True:
+               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
-               elif iNetwork.configuredInterfaces.has_key('ath0') is True:
+               elif iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
                else:
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
 
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
                else:
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
 
-class NameserverSetup(Screen, ConfigListScreen):
+       def cleanup(self):
+               iNetwork.stopLinkStateConsole()
+               iNetwork.stopRestartConsole()
+
+       def restartLan(self):
+               iNetwork.restartNetwork(self.restartLanDataAvail)
+               self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while we configure your network..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       
+       def restartLanDataAvail(self, data):
+               if data is True:
+                       iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+       def getInterfacesDataAvail(self, data):
+               if data is True:
+                       self.restartLanRef.close(True)
+
+       def restartfinishedCB(self,data):
+               if data is True:
+                       self.updateList()
+                       self.session.open(MessageBox, _("Finished configuring your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
+
+
+class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
        def __init__(self, session):
                Screen.__init__(self, session)
        def __init__(self, session):
                Screen.__init__(self, session)
-               iNetwork.getInterfaces()
+               HelpableScreen.__init__(self)
                self.backupNameserverList = iNetwork.getNameserverList()[:]
                print "backup-list:", self.backupNameserverList
                
                self.backupNameserverList = iNetwork.getNameserverList()[:]
                print "backup-list:", self.backupNameserverList
                
@@ -162,14 +207,19 @@ class NameserverSetup(Screen, ConfigListScreen):
                self["introduction"] = Label(_("Press OK to activate the settings."))
                self.createConfig()
                
                self["introduction"] = Label(_("Press OK to activate the settings."))
                self.createConfig()
                
-               self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
-               {
-                       "ok": self.ok,
-                       "cancel": self.cancel,
-                       "red": self.cancel,
-                       "green": self.add,
-                       "yellow": self.remove
-               }, -2)
+               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.list = []
                ConfigListScreen.__init__(self, self.list)
                
                self.list = []
                ConfigListScreen.__init__(self, self.list)
@@ -222,31 +272,51 @@ class NameserverSetup(Screen, ConfigListScreen):
                        self.createConfig()
                        self.createSetup()
        
                        self.createConfig()
                        self.createSetup()
        
-class AdapterSetup(Screen, ConfigListScreen):
+class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
        def __init__(self, session, iface,essid=None, aplist=None):
                Screen.__init__(self, session)
        def __init__(self, session, iface,essid=None, aplist=None):
                Screen.__init__(self, session)
+               HelpableScreen.__init__(self)
                self.session = session
                self.iface = iface
                self.essid = essid
                self.aplist = aplist
                self.extended = None
                self.session = session
                self.iface = iface
                self.essid = essid
                self.aplist = aplist
                self.extended = None
+               self.applyConfigRef = None
+               self.finished_cb = None
+               self.oktext = _("Press OK on your remote control to continue.")
                self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
                self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
-               iNetwork.getInterfaces()
-
-               self.createConfig()
+               #iNetwork.getInterfaces()
                
                
-               self["actions"] = NumberActionMap(["SetupActions", "ColorActions"],
+               self.createConfig()
+
+               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.cancel, _("exit networkadapter configuration")),
+                       "blue": (self.KeyBlue, _("open nameserver configuration")),
+                       })
+
+               self["VirtualKB"] = HelpableActionMap(self, "ColorActions",
+                       {
+                       "green": (self.KeyGreen, [_("open virtual keyboard input help"),_("* Only available when entering hidden ssid or network key")] ),                                      
+                       })
+
+               self["actions"] = NumberActionMap(["SetupActions"],
                {
                        "ok": self.ok,
                {
                        "ok": self.ok,
-                       "cancel": self.cancel,
-                       "red": self.cancel,
-                       "blue": self.KeyBlue,
                }, -2)
                
                }, -2)
                
+               
                self.list = []
                ConfigListScreen.__init__(self, self.list,session = self.session)
                self.createSetup()
                self.onLayoutFinish.append(self.layoutFinished)
                self.list = []
                ConfigListScreen.__init__(self, self.list,session = self.session)
                self.createSetup()
                self.onLayoutFinish.append(self.layoutFinished)
+               self.onClose.append(self.cleanup)
                
                self["DNS1text"] = Label(_("Primary DNS"))
                self["DNS2text"] = Label(_("Secondary DNS"))
                
                self["DNS1text"] = Label(_("Primary DNS"))
                self["DNS2text"] = Label(_("Secondary DNS"))
@@ -271,56 +341,81 @@ class AdapterSetup(Screen, ConfigListScreen):
                self["ButtonRedtext"] = Label(_("Close"))
                self["ButtonBlue"] = Pixmap()
                self["ButtonBluetext"] = Label(_("Edit DNS"))
                self["ButtonRedtext"] = Label(_("Close"))
                self["ButtonBlue"] = Pixmap()
                self["ButtonBluetext"] = Label(_("Edit DNS"))
+               self["ButtonGreen"] = Pixmap()
+               self["VKeyIcon"] = Pixmap()
+               self["HelpWindow"] = Pixmap()
 
        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:
                else:
-                       self["IP"].setText([0,0,0,0])
-               self["Mask"].setText(self.netmaskConfigEntry.getText())
+                       self["IP"].setText(_("N/A"))
+               if self.netmaskConfigEntry.getText() is not None:
+                       if self.netmaskConfigEntry.getText() == "0.0.0.0":
+                                       self["Mask"].setText(_("N/A"))
+                       else:   
+                               self["Mask"].setText(self.netmaskConfigEntry.getText())
+               else:
+                       self["IP"].setText(_("N/A"))                    
                if iNetwork.getAdapterAttribute(self.iface, "gateway"):
                if iNetwork.getAdapterAttribute(self.iface, "gateway"):
-                       self["Gateway"].setText(self.gatewayConfigEntry.getText())
+                       if self.gatewayConfigEntry.getText() == "0.0.0.0":
+                               self["Gateway"].setText(_("N/A"))
+                       else:
+                               self["Gateway"].setText(self.gatewayConfigEntry.getText())
                else:
                        self["Gateway"].hide()
                        self["Gatewaytext"].hide()
                self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                else:
                        self["Gateway"].hide()
                        self["Gatewaytext"].hide()
                self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
+               self["ButtonGreen"].hide()
+               self["VKeyIcon"].hide()
+               self["VirtualKB"].setEnabled(False)
+               self["HelpWindow"].hide()
 
        def createConfig(self):
                self.InterfaceEntry = None
                self.dhcpEntry = None
                self.gatewayEntry = None
 
        def createConfig(self):
                self.InterfaceEntry = None
                self.dhcpEntry = None
                self.gatewayEntry = None
-               self.SSIDscan = None
+               self.hiddenSSID = None
                self.wlanSSID = None
                self.wlanSSID = None
-               self.manualwlanSSID = None
                self.encryptionEnabled = None
                self.encryptionKey = None
                self.encryptionEnabled = None
                self.encryptionKey = None
+               self.encryptionType = None
                self.nwlist = None
                self.nwlist = None
+               self.encryptionlist = None
+               self.weplist = None
                self.wsconfig = None
                self.default = None
                
                if self.iface == "wlan0" or self.iface == "ath0" :
                        from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
                self.wsconfig = None
                self.default = None
                
                if self.iface == "wlan0" or self.iface == "ath0" :
                        from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
+                       self.w = Wlan(self.iface)
                        self.ws = wpaSupplicant()
                        self.ws = wpaSupplicant()
-                       list = []
-                       list.append(_("WEP"))
-                       list.append(_("WPA"))
-                       list.append(_("WPA2"))
+                       self.encryptionlist = []
+                       self.encryptionlist.append(("WEP", _("WEP")))
+                       self.encryptionlist.append(("WPA", _("WPA")))
+                       self.encryptionlist.append(("WPA2", _("WPA2")))
+                       self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+                       self.weplist = []
+                       self.weplist.append("ASCII")
+                       self.weplist.append("HEX")
                        if self.aplist is not None:
                                self.nwlist = self.aplist
                                self.nwlist.sort(key = lambda x: x[0])
                        else:
                                self.nwlist = []
                        if self.aplist is not None:
                                self.nwlist = self.aplist
                                self.nwlist.sort(key = lambda x: x[0])
                        else:
                                self.nwlist = []
-                               self.w = None
                                self.aps = None
                                try:
                                self.aps = None
                                try:
-                                       self.w = Wlan(self.iface)
                                        self.aps = self.w.getNetworkList()
                                        if self.aps is not None:
                                                print "[NetworkSetup.py] got Accespoints!"
                                        self.aps = self.w.getNetworkList()
                                        if self.aps is not None:
                                                print "[NetworkSetup.py] got Accespoints!"
-                                               for ap in aps:
-                                                       a = aps[ap]
+                                               print self.aps
+                                               for ap in self.aps:
+                                                       a = self.aps[ap]
                                                        if a['active']:
                                                                if a['essid'] == "":
                                                                        a['essid'] = a['bssid']
                                                        if a['active']:
                                                                if a['essid'] == "":
                                                                        a['essid'] = a['bssid']
@@ -330,17 +425,23 @@ class AdapterSetup(Screen, ConfigListScreen):
                                        self.nwlist.append("No Networks found")
 
                        self.wsconfig = self.ws.loadConfig()
                                        self.nwlist.append("No Networks found")
 
                        self.wsconfig = self.ws.loadConfig()
-                       self.default = self.essid or self.wsconfig['ssid']
+                       if self.essid is not None: # ssid from wlan scan
+                               self.default = self.essid
+                       else:
+                               self.default = self.wsconfig['ssid']
+                               
+                       if "hidden..." not in self.nwlist:
+                               self.nwlist.append("hidden...")
                        if self.default not in self.nwlist:
                                self.nwlist.append(self.default)
                        if self.default not in self.nwlist:
                                self.nwlist.append(self.default)
-                       config.plugins.wlan.essidscan = NoSave(ConfigYesNo(default = self.wsconfig['ssidscan']))
-                       if self.wsconfig['ssidscan'] is True:
-                               config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
-                       else:
-                               config.plugins.wlan.essid = NoSave(ConfigText(default = self.default, visible_width = 50, fixed_size = False))
+
+                       config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
+                       config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
+
                        config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
                        config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
-                       config.plugins.wlan.encryption.type = NoSave(ConfigSelection(list, default = self.wsconfig['encryption_type'] ))
-                       config.plugins.wlan.encryption.psk = NoSave(ConfigText(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
+                       config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
+                       config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
+                       config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
                
                self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
                
                self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
@@ -382,26 +483,56 @@ class AdapterSetup(Screen, ConfigListScreen):
                                                        self.configStrings = p.__call__["configStrings"]
                                                else:
                                                        self.configStrings = None
                                                        self.configStrings = p.__call__["configStrings"]
                                                else:
                                                        self.configStrings = None
-                                               self.SSIDscan = getConfigListEntry(_("Automatic SSID lookup"), config.plugins.wlan.essidscan)
-                                               self.list.append(self.SSIDscan)
-                                               self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
-                                               self.list.append(self.wlanSSID)
+                                               if config.plugins.wlan.essid.value == 'hidden...':
+                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
+                                                       self.list.append(self.wlanSSID)
+                                                       self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid)
+                                                       self.list.append(self.hiddenSSID)
+                                               else:
+                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
+                                                       self.list.append(self.wlanSSID)
                                                self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
                                                self.list.append(self.encryptionEnabled)
                                                
                                                if config.plugins.wlan.encryption.enabled.value:
                                                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.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)                                                
-                                                       self.list.append(self.encryptionKey)
+                                                       self.encryptionType = getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type)
+                                                       self.list.append(self.encryptionType)
+                                                       if config.plugins.wlan.encryption.type.value == 'WEP':
+                                                               self.list.append(getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.encryption.wepkeytype))
+                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)                                                
+                                                               self.list.append(self.encryptionKey)                                                    
+                                                       else:                                                           
+                                                               self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)                                                
+                                                               self.list.append(self.encryptionKey)
+       
                
                self["config"].list = self.list
                self["config"].l.setList(self.list)
                
                self["config"].list = self.list
                self["config"].l.setList(self.list)
+               if not self.selectionChanged in self["config"].onSelectionChanged:
+                       self["config"].onSelectionChanged.append(self.selectionChanged)
 
        def KeyBlue(self):
                self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
 
 
        def KeyBlue(self):
                self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
 
+       def KeyGreen(self):
+               if self.iface == "wlan0" or self.iface == "ath0" :      
+                       if self["config"].getCurrent() == self.hiddenSSID:
+                               if config.plugins.wlan.essid.value == 'hidden...':
+                                       self.session.openWithCallback(self.VirtualKeyBoardSSIDCallback, VirtualKeyBoard, title = (_("Enter WLAN networkname/SSID:")), text = config.plugins.wlan.essid.value)
+                       if self["config"].getCurrent() == self.encryptionKey:
+                               self.session.openWithCallback(self.VirtualKeyBoardKeyCallback, VirtualKeyBoard, title = (_("Enter WLAN passphrase/key:")), text = config.plugins.wlan.encryption.psk.value)
+       
+       def VirtualKeyBoardSSIDCallback(self, callback = None):
+               if callback is not None and len(callback):
+                       config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = callback, visible_width = 50, fixed_size = False))
+                       self.createSetup()
+                       
+       def VirtualKeyBoardKeyCallback(self, callback = None):
+               if callback is not None and len(callback):
+                       config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = callback, visible_width = 50, fixed_size = False))
+                       self.createSetup()
+                       
        def newConfig(self):
        def newConfig(self):
-               print self["config"].getCurrent()
                if self["config"].getCurrent() == self.InterfaceEntry:
                        self.createSetup()
                if self["config"].getCurrent() == self.dhcpEntry:
                if self["config"].getCurrent() == self.InterfaceEntry:
                        self.createSetup()
                if self["config"].getCurrent() == self.dhcpEntry:
@@ -409,15 +540,12 @@ class AdapterSetup(Screen, ConfigListScreen):
                if self["config"].getCurrent() == self.gatewayEntry:
                        self.createSetup()
                if self.iface == "wlan0" or self.iface == "ath0" :      
                if self["config"].getCurrent() == self.gatewayEntry:
                        self.createSetup()
                if self.iface == "wlan0" or self.iface == "ath0" :      
-                       if self["config"].getCurrent() == self.SSIDscan:
-                               if config.plugins.wlan.essidscan.value is True:
-                                       config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
-                               else:
-                                       config.plugins.wlan.essid = NoSave(ConfigText(default = self.default, visible_width = 50, fixed_size = False))
+                       if self["config"].getCurrent() == self.wlanSSID:
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionEnabled:
                                self.createSetup()
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionEnabled:
                                self.createSetup()
-               
+                       if self["config"].getCurrent() == self.encryptionType:
+                               self.createSetup()      
        def keyLeft(self):
                ConfigListScreen.keyLeft(self)
                self.newConfig()
        def keyLeft(self):
                ConfigListScreen.keyLeft(self)
                self.newConfig()
@@ -426,24 +554,92 @@ class AdapterSetup(Screen, ConfigListScreen):
                ConfigListScreen.keyRight(self)
                self.newConfig()
 
                ConfigListScreen.keyRight(self)
                self.newConfig()
 
+       def selectionChanged(self):
+               current = self["config"].getCurrent()
+               if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+                       helpwindowpos = self["HelpWindow"].getPosition()
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+                               self["ButtonGreen"].show()
+                               self["VKeyIcon"].show()
+                               self["VirtualKB"].setEnabled(True)                      
+               elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+                       helpwindowpos = self["HelpWindow"].getPosition()
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+                               self["ButtonGreen"].show()
+                               self["VKeyIcon"].show()
+                               self["VirtualKB"].setEnabled(True)                      
+               else:   
+                       self["ButtonGreen"].hide()
+                       self["VKeyIcon"].hide()
+                       self["VirtualKB"].setEnabled(False)
+
        def ok(self):
        def ok(self):
-               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)
+               current = self["config"].getCurrent()
+               if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+               elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+               self.session.openWithCallback(self.applyConfig, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) )
+
+       def applyConfig(self, ret = False):
+               if (ret == True):
+                       iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
+                       iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
+                       iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
+                       iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
+                       if self.hasGatewayConfigEntry.value:
+                               iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
+                       else:
+                               iNetwork.removeAdapterAttribute(self.iface, "gateway")
+                       if self.extended is not None and self.configStrings is not None:
+                               iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
+                               self.ws.writeConfig()
+                       if self.activateInterfaceEntry.value is False:
+                               iNetwork.deactivateInterface(self.iface)
+                       iNetwork.writeNetworkConfig()                   
+                       iNetwork.restartNetwork(self.applyConfigDataAvail)
+                       self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait while activating your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
                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()
-               if self.activateInterfaceEntry.value is False:
-                       iNetwork.deactivateInterface(self.iface)
-               iNetwork.writeNetworkConfig()
-               iNetwork.deactivateNetworkConfig()
-               iNetwork.activateNetworkConfig()
-               self.close()
+                       self.cancel()
+                       
+       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:
+                       num_configured_if = len(iNetwork.getConfiguredAdapters())
+                       if num_configured_if >= 2:
+                               self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("Your network configuration has been activated.\nA second configured interface has been found.\n\nDo you want to disable the second networkinterface?"), default = True)
+                       else:
+                               if self.finished_cb:
+                                       self.session.openWithCallback(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 secondIfaceFoundCB(self,data):
+               if data is False:
+                       self.close('ok')
+               else:
+                       configuredInterfaces = configuredNetworkAdapters
+                       for interface in configuredInterfaces:
+                               if interface == self.iface:
+                                       continue
+                               iNetwork.setAdapterAttribute(interface, "up", False)
+                               iNetwork.deactivateInterface(interface)
+                               self.applyConfig(True)
+                       
+       def ConfigfinishedCB(self,data):
+               if data is True:
+                       self.close('ok')
 
        def cancel(self):
                iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
 
        def cancel(self):
                iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
@@ -451,11 +647,12 @@ class AdapterSetup(Screen, ConfigListScreen):
                if self.activateInterfaceEntry.value is False:
                        iNetwork.deactivateInterface(self.iface)
                iNetwork.getInterfaces()
                if self.activateInterfaceEntry.value is False:
                        iNetwork.deactivateInterface(self.iface)
                iNetwork.getInterfaces()
-               self.close()
+               self.close('cancel')
 
 
-       def run(self):
+       def runAsync(self, finished_cb):
+               self.finished_cb = finished_cb
                self.ok()
                self.ok()
-
+               
        def NameserverSetupClosed(self, *ret):
                iNetwork.loadNameserverConfig()
                nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
        def NameserverSetupClosed(self, *ret):
                iNetwork.loadNameserverConfig()
                nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
@@ -463,13 +660,18 @@ 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()
-       
+               
+       def cleanup(self):
+               iNetwork.stopLinkStateConsole()
+               iNetwork.stopRestartConsole()   
 
 
-class AdapterSetupConfiguration(Screen):
+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.mainmenu = self.genMainMenu()
                self["menulist"] = MenuList(self.mainmenu)
                self["description"] = Label()
                self.mainmenu = self.genMainMenu()
                self["menulist"] = MenuList(self.mainmenu)
                self["description"] = Label()
@@ -485,8 +687,27 @@ class AdapterSetupConfiguration(Screen):
                
                self.oktext = _("Press OK on your remote control to continue.")
                self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
                
                self.oktext = _("Press OK on your remote control to continue.")
                self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
-               self.errortext = _("No working wireless interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")      
+               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["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,
@@ -498,9 +719,10 @@ class AdapterSetupConfiguration(Screen):
                        "right": self.right,
                }, -2)
                
                        "right": self.right,
                }, -2)
                
-               iNetwork.getInterfaces()
+               iNetwork.getInterfaces(self.updateStatusbar)
                self.onLayoutFinish.append(self.layoutFinished)
                self.onLayoutFinish.append(self.layoutFinished)
-               self.updateStatusbar()
+               self.onClose.append(self.cleanup)
+               self.onHide.append(self.cleanup)
 
        def ok(self):
                if self["menulist"].getCurrent()[1] == 'edit':
 
        def ok(self):
                if self["menulist"].getCurrent()[1] == 'edit':
@@ -549,7 +771,6 @@ class AdapterSetupConfiguration(Screen):
                                self.wlanresponse = ifobj.getStatistics()
                                if self.wlanresponse[0] != 19:
                                        self.session.openWithCallback(self.AdapterSetupClosed, WlanStatus,self.iface)
                                self.wlanresponse = ifobj.getStatistics()
                                if self.wlanresponse[0] != 19:
                                        self.session.openWithCallback(self.AdapterSetupClosed, WlanStatus,self.iface)
-                                       #self.session.open(WlanStatus,self.iface)
                                else:
                                        # Display Wlan not available Message
                                        self.showErrorMessage()
                                else:
                                        # Display Wlan not available Message
                                        self.showErrorMessage()
@@ -584,6 +805,7 @@ class AdapterSetupConfiguration(Screen):
                self.loadDescription()
 
        def loadDescription(self):
                self.loadDescription()
 
        def loadDescription(self):
+               print self["menulist"].getCurrent()[1]
                if self["menulist"].getCurrent()[1] == 'edit':
                        self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext )
                if self["menulist"].getCurrent()[1] == 'test':
                if self["menulist"].getCurrent()[1] == 'edit':
                        self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext )
                if self["menulist"].getCurrent()[1] == 'test':
@@ -601,7 +823,7 @@ class AdapterSetupConfiguration(Screen):
                if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
                        self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
                
                if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
                        self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
                
-       def updateStatusbar(self):
+       def updateStatusbar(self, data = None):
                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:"))
@@ -661,21 +883,52 @@ class AdapterSetupConfiguration(Screen):
                return menu
 
        def AdapterSetupClosed(self, *ret):
                return menu
 
        def AdapterSetupClosed(self, *ret):
-               self.mainmenu = self.genMainMenu()
-               self["menulist"].l.setList(self.mainmenu)
-               iNetwork.getInterfaces()
-               self.updateStatusbar()
+               if ret is not None and len(ret):
+                       if ret[0] == 'ok' and (self.iface == 'wlan0' or self.iface == 'ath0') and iNetwork.getAdapterAttribute(self.iface, "up") is True:
+                               try:
+                                       from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
+                                       from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+                               except ImportError:
+                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                               else:   
+                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
+                                       self.wlanresponse = ifobj.getStatistics()
+                                       if self.wlanresponse[0] != 19:
+                                               self.session.openWithCallback(self.AdapterSetupClosed, WlanStatus,self.iface)
+                                       else:
+                                               # Display Wlan not available Message
+                                               self.showErrorMessage()
+                       else:
+                               self.mainmenu = self.genMainMenu()
+                               self["menulist"].l.setList(self.mainmenu)
+                               iNetwork.getInterfaces(self.updateStatusbar)
+               else:
+                       self.mainmenu = self.genMainMenu()
+                       self["menulist"].l.setList(self.mainmenu)
+                       iNetwork.getInterfaces(self.updateStatusbar)
 
        def WlanScanClosed(self,*ret):
                if ret[0] is not None:
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
                else:
 
        def WlanScanClosed(self,*ret):
                if ret[0] is not None:
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
                else:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,None,ret[0])
-
+                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,None,None)
 
        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 getInterfacesDataAvail(self, data):
+               if data is True:
+                       self.restartLanRef.close(True)
+
+       def restartfinishedCB(self,data):
+               if data is True:
+                       self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
 
        def getLinkState(self,iface):
                iNetwork.getLinkState(iface,self.dataAvail)
 
        def getLinkState(self,iface):
                iNetwork.getLinkState(iface,self.dataAvail)
@@ -693,12 +946,16 @@ class AdapterSetupConfiguration(Screen):
 
        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()
 
 
 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
+               self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
                iNetwork.getInterfaces()
                self.setLabels()
                
                iNetwork.getInterfaces()
                self.setLabels()
                
@@ -713,8 +970,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"],
                {
@@ -745,6 +1002,12 @@ 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)
        def closeInfo(self):
                self["shortcuts"].setEnabled(True)              
                self["infoshortcuts"].setEnabled(False)
@@ -874,48 +1137,15 @@ 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)
 
        def KeyGreen(self):
                self["shortcutsgreen"].setEnabled(False)
@@ -1076,9 +1306,9 @@ class NetworkAdapterTest(Screen):
                                        self["NetworkInfo_Check"].setPixmapNum(1)
                                        self["NetworkInfo_Check"].show()
                else:
                                        self["NetworkInfo_Check"].setPixmapNum(1)
                                        self["NetworkInfo_Check"].show()
                else:
-                       iNetwork.getLinkState(iface,self.dataAvail)
+                       iNetwork.getLinkState(iface,self.LinkStatedataAvail)
 
 
-       def dataAvail(self,data):
+       def LinkStatedataAvail(self,data):
                self.output = data.strip()
                result = self.output.split('\n')
                pattern = re_compile("Link detected: yes")
                self.output = data.strip()
                result = self.output.split('\n')
                pattern = re_compile("Link detected: yes")
@@ -1093,4 +1323,44 @@ 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):
+               print "DATA",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):
+               print "DATA",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["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
+               
+               
\ No newline at end of file
Unnamed repository; edit this file 'description' to name the repository.