Merge commit 'dm/experimental' into vuplus_experimental

[vuplus_dvbapp] / lib / python / Screens / NetworkSetup.py

diff --git a/lib/python/Screens/NetworkSetup.py b/lib/python/Screens/NetworkSetup.py
index 32e2daf..908a615 100755 (executable)
--- a/lib/python/Screens/NetworkSetup.py
+++ b/lib/python/Screens/NetworkSetup.py
@@ -5,6 +5,9 @@ from Screens.Standby import *
 from Screens.VirtualKeyBoard import VirtualKeyBoard
 from Screens.HelpMenu import HelpableScreen
 from Components.Network import iNetwork
 from Screens.VirtualKeyBoard import VirtualKeyBoard
 from Screens.HelpMenu import HelpableScreen
 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


@@ -13,7 +16,7 @@ from Components.ConfigList import ConfigListScreen
 from Components.PluginComponent import plugins
 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
 from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap
 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.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_CURRENT_SKIN

 from Tools.LoadPixmap import LoadPixmap
 from Plugins.Plugin import PluginDescriptor
 from enigma import eTimer, ePoint, eSize, RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont
 from Tools.LoadPixmap import LoadPixmap
 from Plugins.Plugin import PluginDescriptor
 from enigma import eTimer, ePoint, eSize, RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont


@@ -21,30 +24,6 @@ from os import path as os_path, system as os_system, unlink
 from re import compile as re_compile, search as re_search
 
 
 from re import compile as re_compile, search as re_search
 
 

-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))
-       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:
-               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,HelpableScreen):
        def __init__(self, session):
                Screen.__init__(self, session)
 class NetworkAdapterSelection(Screen,HelpableScreen):
        def __init__(self, session):
                Screen.__init__(self, session)


@@ -53,16 +32,19 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                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.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.restartLanRef = None
                

-               self["ButtonBluetext"] = Label(_("Set as default Interface"))
-               self["ButtonBlue"] = Pixmap()
-               self["ButtonRedtext"] = Label(_("Close"))
-               self["introduction"] = Label(_("Press OK to edit the settings."))
+               self["key_red"] = StaticText(_("Close"))
+               self["key_green"] = StaticText(_("Select"))
+               self["key_yellow"] = StaticText("")
+               self["key_blue"] = StaticText("")
+               self["introduction"] = StaticText(self.edittext)

                
                self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
                
                
                self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
                

-               if len(self.adapters) == 0:
+               if not self.adapters:

                        self.onFirstExecBegin.append(self.NetworkFallback)
                        
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        self.onFirstExecBegin.append(self.NetworkFallback)
                        
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",


@@ -73,33 +55,72 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
 
                self["ColorActions"] = HelpableActionMap(self, "ColorActions",
                        {
 
                self["ColorActions"] = HelpableActionMap(self, "ColorActions",
                        {

-                       "red": (self.close, _("exit network interface list")),  
+                       "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",
                        {
                        })
                
                self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions",
                        {

-                       "blue": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),     
+                       "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),

                        })
                        })

-               
+

                self.list = []
                self.list = []

-               self["list"] = InterfaceList(self.list)
+               self["list"] = List(self.list)

                self.updateList()
                self.updateList()

-               
+

                if len(self.adapters) == 1:
                        self.onFirstExecBegin.append(self.okbuttonClick)
                self.onClose.append(self.cleanup)
                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 iface in iNetwork.lan_interfaces:
+                       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 iface in iNetwork.wlan_interfaces:
+                       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):
                self.list = []
                default_gw = None
                num_configured_if = len(iNetwork.getConfiguredAdapters())
                if num_configured_if >= 2:
        def updateList(self):
                self.list = []
                default_gw = None
                num_configured_if = len(iNetwork.getConfiguredAdapters())
                if num_configured_if >= 2:

-                       self["ButtonBlue"].show()
-                       self["ButtonBluetext"].show()
+                       self["key_yellow"].setText(_("Default"))
+                       self["introduction"].setText(self.defaulttext)

                        self["DefaultInterfaceAction"].setEnabled(True)
                else:
                        self["DefaultInterfaceAction"].setEnabled(True)
                else:

-                       self["ButtonBlue"].hide()
-                       self["ButtonBluetext"].hide()
+                       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"):
                        self["DefaultInterfaceAction"].setEnabled(False)
 
                if num_configured_if < 2 and os_path.exists("/etc/default_gw"):


@@ -112,7 +133,7 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        default_gw = result
                                        
                if len(self.adapters) == 0: # no interface available => display only eth0
                        default_gw = result
                                        
                if len(self.adapters) == 0: # no interface available => display only eth0

-                       self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
+                       self.list.append(self.buildInterfaceList("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))

                else:
                        for x in self.adapters:
                                if x[1] == default_gw:
                else:
                        for x in self.adapters:
                                if x[1] == default_gw:


@@ -123,8 +144,11 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                                        active_int = True
                                else:
                                        active_int = False
                                        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)
+                               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()
 
        def setDefaultInterface(self):
                selection = self["list"].getCurrent()


@@ -193,6 +217,17 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        self.updateList()
                        self.session.open(MessageBox, _("Finished configuring your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
 
                        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, HelpableScreen):
        def __init__(self, session):
 
 class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
        def __init__(self, session):


@@ -201,47 +236,47 @@ class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
                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["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {
                        "cancel": (self.cancel, _("exit nameserver configuration")),
                        "ok": (self.ok, _("activate current configuration")),
                        })
                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["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,
                self["actions"] = NumberActionMap(["SetupActions"],
                {
                        "ok": self.ok,

-               }, -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)
 


@@ -269,13 +304,13 @@ class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
 
        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, HelpableScreen):
        def __init__(self, session, networkinfo, essid=None, aplist=None):
                Screen.__init__(self, session)
 class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
        def __init__(self, session, networkinfo, essid=None, aplist=None):
                Screen.__init__(self, session)


@@ -299,60 +334,51 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
 
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {
 
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {

-                       "cancel": (self.cancel, _("exit network adapter setup menu")),
-                       "ok": (self.ok, _("select menu entry")),
+                       "cancel": (self.keyCancel, _("exit network adapter configuration")),
+                       "ok": (self.keySave, _("activate network adapter configuration")),

                        })
 
                self["ColorActions"] = HelpableActionMap(self, "ColorActions",
                        {
                        })
 
                self["ColorActions"] = HelpableActionMap(self, "ColorActions",
                        {

-                       "red": (self.cancel, _("exit network adapter configuration")),
+                       "red": (self.keyCancel, _("exit network adapter configuration")),

                        "blue": (self.KeyBlue, _("open nameserver 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"],
                {
                self["actions"] = NumberActionMap(["SetupActions"],
                {

-                       "ok": self.ok,
+                       "ok": self.keySave,

                }, -2)
                }, -2)

-               
-               
+

                self.list = []
                ConfigListScreen.__init__(self, self.list,session = self.session)
                self.createSetup()
                self.onLayoutFinish.append(self.layoutFinished)
                self.onClose.append(self.cleanup)
                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["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"))
-               self["ButtonGreen"] = Pixmap()
-               self["VKeyIcon"] = Pixmap()
-               self["HelpWindow"] = Pixmap()

 
 

+               self["DNS1text"] = StaticText(_("Primary DNS"))
+               self["DNS2text"] = StaticText(_("Secondary DNS"))
+               self["DNS1"] = StaticText()
+               self["DNS2"] = StaticText()
+               self["introduction"] = StaticText(_("Current settings:"))
+
+               self["IPtext"] = StaticText(_("IP Address"))
+               self["Netmasktext"] = StaticText(_("Netmask"))
+               self["Gatewaytext"] = StaticText(_("Gateway"))
+
+               self["IP"] = StaticText()
+               self["Mask"] = StaticText()
+               self["Gateway"] = StaticText()
+
+               self["Adaptertext"] = StaticText(_("Network:"))
+               self["Adapter"] = StaticText()
+               self["introduction2"] = StaticText(_("Press OK to activate the settings."))
+               self["key_red"] = StaticText(_("Cancel"))
+               self["key_blue"] = StaticText(_("Edit DNS"))
+
+               self["VKeyIcon"] = Boolean(False)
+               self["HelpWindow"] = Pixmap()
+               self["HelpWindow"].hide()
+               

        def layoutFinished(self):
                self["DNS1"].setText(self.primaryDNS.getText())
                self["DNS2"].setText(self.secondaryDNS.getText())
        def layoutFinished(self):
                self["DNS1"].setText(self.primaryDNS.getText())
                self["DNS2"].setText(self.secondaryDNS.getText())


@@ -372,17 +398,15 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                        self["IP"].setText(_("N/A"))                    
                if iNetwork.getAdapterAttribute(self.iface, "gateway"):
                        if self.gatewayConfigEntry.getText() == "0.0.0.0":
                        self["IP"].setText(_("N/A"))                    
                if iNetwork.getAdapterAttribute(self.iface, "gateway"):
                        if self.gatewayConfigEntry.getText() == "0.0.0.0":

+                               self["Gatewaytext"].setText(_("Gateway"))

                                self["Gateway"].setText(_("N/A"))
                        else:
                                self["Gateway"].setText(_("N/A"))
                        else:

+                               self["Gatewaytext"].setText(_("Gateway"))

                                self["Gateway"].setText(self.gatewayConfigEntry.getText())
                else:
                                self["Gateway"].setText(self.gatewayConfigEntry.getText())
                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))

-               self["ButtonGreen"].hide()
-               self["VKeyIcon"].hide()
-               self["VirtualKB"].setEnabled(False)
-               self["HelpWindow"].hide()

 
        def createConfig(self):
                self.InterfaceEntry = None
 
        def createConfig(self):
                self.InterfaceEntry = None


@@ -398,8 +422,8 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                self.weplist = None
                self.wsconfig = None
                self.default = None
                self.weplist = None
                self.wsconfig = None
                self.default = None

-               
-               if self.iface == "wlan0" or self.iface == "ath0" :
+
+               if self.iface in iNetwork.wlan_interfaces:

                        from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
                        self.w = Wlan(self.iface)
                        self.ws = wpaSupplicant()
                        from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
                        self.w = Wlan(self.iface)
                        self.ws = wpaSupplicant()


@@ -420,28 +444,25 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                try:
                                        self.aps = self.w.getNetworkList()
                                        if self.aps is not None:
                                try:
                                        self.aps = self.w.getNetworkList()
                                        if self.aps is not None:

-                                               print "[NetworkSetup.py] got Accespoints!"

                                                for ap in self.aps:
                                                        a = self.aps[ap]
                                                        if a['active']:
                                                for ap in self.aps:
                                                        a = self.aps[ap]
                                                        if a['active']:

-                                                               if a['essid'] == "":
-                                                                       a['essid'] = a['bssid']
-                                                               self.nwlist.append( a['essid'])
+                                                               if a['essid'] != '':
+                                                                       self.nwlist.append((a['essid'],a['essid']))

                                        self.nwlist.sort(key = lambda x: x[0])
                                except:
                                        self.nwlist.sort(key = lambda x: x[0])
                                except:

-                                       self.nwlist.append("No Networks found")
+                                       self.nwlist.append(("No Networks found",_("No Networks found")))

 
                        self.wsconfig = self.ws.loadConfig()
                        if self.essid is not None: # ssid from wlan scan
                                self.default = self.essid
                        else:
                                self.default = self.wsconfig['ssid']
 
                        self.wsconfig = self.ws.loadConfig()
                        if self.essid is not None: # ssid from wlan scan
                                self.default = self.essid
                        else:
                                self.default = self.wsconfig['ssid']

-                               
+

                        if "hidden..." not in self.nwlist:
                        if "hidden..." not in self.nwlist:

-                               self.nwlist.append("hidden...")
+                               self.nwlist.append(("hidden...",_("enter hidden network SSID")))

                        if self.default not in self.nwlist:
                        if self.default not in self.nwlist:

-                               self.nwlist.append(self.default)
-
+                               self.nwlist.append((self.default,self.default))

                        config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
                        config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
 
                        config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
                        config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
 


@@ -449,7 +470,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                        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))
                        config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
                        config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
                        config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))

-               
+

                self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
                self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])
                self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
                self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
                self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])


@@ -467,7 +488,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
        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)


@@ -479,8 +500,8 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                self.list.append(self.gatewayEntry)
                                if self.hasGatewayConfigEntry.value:
                                        self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
                                self.list.append(self.gatewayEntry)
                                if self.hasGatewayConfigEntry.value:
                                        self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))

-                       
-                       self.extended = None            
+
+                       self.extended = None

                        for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                callFnc = p.__call__["ifaceSupported"](self.iface)
                                if callFnc is not None:
                        for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                callFnc = p.__call__["ifaceSupported"](self.iface)
                                if callFnc is not None:


@@ -506,39 +527,18 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                                        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.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.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)

                                                                self.list.append(self.encryptionKey)
                                                                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 network name/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):
                if self["config"].getCurrent() == self.InterfaceEntry:
                        self.createSetup()
        def newConfig(self):
                if self["config"].getCurrent() == self.InterfaceEntry:
                        self.createSetup()


@@ -546,13 +546,14 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                        self.createSetup()
                if self["config"].getCurrent() == self.gatewayEntry:
                        self.createSetup()
                        self.createSetup()
                if self["config"].getCurrent() == self.gatewayEntry:
                        self.createSetup()

-               if self.iface == "wlan0" or self.iface == "ath0" :      
+               if self.iface in iNetwork.wlan_interfaces:

                        if self["config"].getCurrent() == self.wlanSSID:
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionEnabled:
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionType:
                        if self["config"].getCurrent() == self.wlanSSID:
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionEnabled:
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionType:

-                               self.createSetup()      
+                               self.createSetup()
+

        def keyLeft(self):
                ConfigListScreen.keyLeft(self)
                self.newConfig()
        def keyLeft(self):
                ConfigListScreen.keyLeft(self)
                self.newConfig()


@@ -560,37 +561,41 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
        def keyRight(self):
                ConfigListScreen.keyRight(self)
                self.newConfig()
        def keyRight(self):
                ConfigListScreen.keyRight(self)
                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 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 keySaveConfirm(self, ret = False):
+               if (ret == True):               
+                       num_configured_if = len(iNetwork.getConfiguredAdapters())
+                       if num_configured_if >= 1:
+                               if num_configured_if == 1 and self.iface in iNetwork.getConfiguredAdapters():
+                                       self.applyConfig(True)
+                               else:
+                                       self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True)
+                       else:
+                               self.applyConfig(True)
+               else:
+                       self.keyCancel()                

 
 

-       def ok(self):
-               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 secondIfaceFoundCB(self,data):
+               if data is False:
+                       self.applyConfig(True)
+               else:
+                       configuredInterfaces = iNetwork.getConfiguredAdapters()
+                       for interface in configuredInterfaces:
+                               if interface == self.iface:
+                                       continue
+                               iNetwork.setAdapterAttribute(interface, "up", False)
+                               iNetwork.deactivateInterface(interface)
+                               self.applyConfig(True)

 
        def applyConfig(self, ret = False):
                if (ret == True):
 
        def applyConfig(self, ret = False):
                if (ret == True):


@@ -607,12 +612,12 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                self.ws.writeConfig()
                        if self.activateInterfaceEntry.value is False:
                                iNetwork.deactivateInterface(self.iface)
                                self.ws.writeConfig()
                        if self.activateInterfaceEntry.value is False:
                                iNetwork.deactivateInterface(self.iface)

-                       iNetwork.writeNetworkConfig()                   
+                       iNetwork.writeNetworkConfig()

                        iNetwork.restartNetwork(self.applyConfigDataAvail)
                        self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
                else:
                        iNetwork.restartNetwork(self.applyConfigDataAvail)
                        self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
                else:

-                       self.cancel()
-                       
+                       self.keyCancel()
+

        def applyConfigDataAvail(self, data):
                if data is True:
                        iNetwork.getInterfaces(self.getInterfacesDataAvail)
        def applyConfigDataAvail(self, data):
                if data is True:
                        iNetwork.getInterfaces(self.getInterfacesDataAvail)


@@ -623,52 +628,40 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
 
        def applyConfigfinishedCB(self,data):
                if data is 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 network interface?"), default = 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:
                        else:

-                               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 secondIfaceFoundCB(self,data):
-               if data is False:
-                       self.close('ok')
-               else:
-                       configuredInterfaces = iNetwork.getConfiguredAdapters()
-                       for interface in configuredInterfaces:
-                               if interface == self.iface:
-                                       continue
-                               iNetwork.setAdapterAttribute(interface, "up", False)
-                               iNetwork.deactivateInterface(interface)
-                               self.applyConfig(True)
-                       
+                               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 ConfigfinishedCB(self,data):
                if data is not None:
                        if data is True:
                                self.close('ok')
 

-       def cancel(self):
+       def keyCancelConfirm(self, result):
+               if not result:
+                       return

                if self.oldInterfaceState is False:
                if self.oldInterfaceState is False:

-                       iNetwork.deactivateInterface(self.iface,self.deactivateInterfaceCB)
+                       iNetwork.deactivateInterface(self.iface,self.keyCancelCB)

                else:
                        self.close('cancel')
 
                else:
                        self.close('cancel')
 

-       def deactivateInterfaceCB(self,data):
-               if data is not None:
-                       if data is True:
-                               iNetwork.getInterfaces(self.cancelCB)
-       
-       def cancelCB(self,data):                        
+       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')
                if data is not None:
                        if data is True:
                                self.close('cancel')

-                               
+

        def runAsync(self, finished_cb):
                self.finished_cb = finished_cb
        def runAsync(self, finished_cb):
                self.finished_cb = finished_cb

-               self.ok()
-               
+               self.keySave()
+

        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]


@@ -676,10 +669,19 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                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()
        def cleanup(self):
                iNetwork.stopLinkStateConsole()

-       
+               
+       def hideInputHelp(self):
+               current = self["config"].getCurrent()
+               if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+               elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+                       if current[1].help_window.instance is not None:
+                               current[1].help_window.instance.hide()
+

 
 class AdapterSetupConfiguration(Screen, HelpableScreen):
        def __init__(self, session,iface):
 
 class AdapterSetupConfiguration(Screen, HelpableScreen):
        def __init__(self, session,iface):


@@ -688,21 +690,19 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self.session = session
                self.iface = iface
                self.restartLanRef = None
                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.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["WizardActions"] = HelpableActionMap(self, "WizardActions",
                self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")      
                
                self["WizardActions"] = HelpableActionMap(self, "WizardActions",


@@ -740,18 +740,26 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self.onClose.append(self.cleanup)
 
        def ok(self):
                self.onClose.append(self.cleanup)
 
        def ok(self):

+               self.cleanup()

                if self["menulist"].getCurrent()[1] == 'edit':
                if self["menulist"].getCurrent()[1] == 'edit':

-                       if self.iface == 'wlan0' or self.iface == 'ath0':
+                       if self.iface in iNetwork.wlan_interfaces:

                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan

-                                       from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+                                       from pythonwifi.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
                                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: # Wlan Interface found.
-                                               self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
+                                       try:
+                                               self.wlanresponse = ifobj.getAPaddr()
+                                       except IOError:
+                                               self.wlanresponse = ifobj.getStatistics()
+                                       if self.wlanresponse:
+                                               if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+                                                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
+                                               else:
+                                                       # Display Wlan not available Message
+                                                       self.showErrorMessage()

                                        else:
                                                # Display Wlan not available Message
                                                self.showErrorMessage()
                                        else:
                                                # Display Wlan not available Message
                                                self.showErrorMessage()


@@ -764,28 +772,42 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                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
+                               from pythonwifi.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
                        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.WlanScanClosed, WlanScan, self.iface)
+                               try:
+                                       self.wlanresponse = ifobj.getAPaddr()
+                               except IOError:
+                                       self.wlanresponse = ifobj.getStatistics()
+                               if self.wlanresponse:
+                                       if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+                                               self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
+                                       else:
+                                               # Display Wlan not available Message
+                                               self.showErrorMessage()

                                else:
                                        # Display Wlan not available Message
                                        self.showErrorMessage()
                if self["menulist"].getCurrent()[1] == 'wlanstatus':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
                                else:
                                        # Display Wlan not available Message
                                        self.showErrorMessage()
                if self["menulist"].getCurrent()[1] == 'wlanstatus':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus

-                               from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+                               from pythonwifi.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
                        except ImportError:
                                self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
                        else:   
                                ifobj = Wireless(self.iface) # a Wireless NIC Object

-                               self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse[0] != 19:
-                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+                               try:
+                                       self.wlanresponse = ifobj.getAPaddr()
+                               except IOError:
+                                       self.wlanresponse = ifobj.getStatistics()
+                               if self.wlanresponse:
+                                       if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+                                       else:
+                                               # Display Wlan not available Message
+                                               self.showErrorMessage()

                                else:
                                        # Display Wlan not available Message
                                        self.showErrorMessage()
                                else:
                                        # Display Wlan not available Message
                                        self.showErrorMessage()


@@ -793,7 +815,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                        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.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)
                if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
                        self.extended = self["menulist"].getCurrent()[1][2]
                        self.extended(self.session, self.iface)


@@ -820,15 +842,14 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self.loadDescription()
 
        def loadDescription(self):
                self.loadDescription()
 
        def loadDescription(self):

-               print self["menulist"].getCurrent()[1]

                if self["menulist"].getCurrent()[1] == 'edit':
                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':
                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':


@@ -839,16 +860,18 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                        self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
                
        def updateStatusbar(self, data = None):
                        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 self.iface in iNetwork.wlan_interfaces:

                        try:
                        try:

-                               from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+                               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:
                                iStatus.getDataForInterface(self.iface,self.getInfoCB)
                else:


@@ -870,7 +893,6 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                        callFnc = p.__call__["ifaceSupported"](self.iface)
                        if callFnc is not None:
                                self.extended = callFnc
                        callFnc = p.__call__["ifaceSupported"](self.iface)
                        if callFnc is not None:
                                self.extended = callFnc

-                               print p.__call__

                                if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
                                        menu.append((_("Scan Wireless Networks"), "scanwlan"))
                                        if iNetwork.getAdapterAttribute(self.iface, "up"):
                                if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
                                        menu.append((_("Scan Wireless Networks"), "scanwlan"))
                                        if iNetwork.getAdapterAttribute(self.iface, "up"):


@@ -894,45 +916,44 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
 
        def AdapterSetupClosed(self, *ret):
                if ret is not None and len(ret):
 
        def AdapterSetupClosed(self, *ret):
                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:
+                       if ret[0] == 'ok' and (self.iface in iNetwork.wlan_interfaces) and iNetwork.getAdapterAttribute(self.iface, "up") is True:

                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus

-                                       from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+                                       from pythonwifi.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
                                except ImportError:
                                        self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
                                else:   
                                        ifobj = Wireless(self.iface) # a Wireless NIC Object

-                                       self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse[0] != 19:
-                                               self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+                                       try:
+                                               self.wlanresponse = ifobj.getAPaddr()
+                                       except IOError:
+                                               self.wlanresponse = ifobj.getStatistics()
+                                       if self.wlanresponse:
+                                               if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+                                                       self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+                                               else:
+                                                       # Display Wlan not available Message
+                                                       self.showErrorMessage()

                                        else:
                                                # Display Wlan not available Message
                                                self.showErrorMessage()
                        else:
                                        else:
                                                # Display Wlan not available Message
                                                self.showErrorMessage()
                        else:

-                               self.mainmenu = self.genMainMenu()
-                               self["menulist"].l.setList(self.mainmenu)

                                self.updateStatusbar()
                else:
                                self.updateStatusbar()
                else:

-                       self.mainmenu = self.genMainMenu()
-                       self["menulist"].l.setList(self.mainmenu)

                        self.updateStatusbar()
 
        def WlanStatusClosed(self, *ret):
                if ret is not None and len(ret):
                        self.updateStatusbar()
 
        def WlanStatusClosed(self, *ret):
                if ret is not None and len(ret):

-                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus

                        iStatus.stopWlanConsole()
                        iStatus.stopWlanConsole()

-                       self.mainmenu = self.genMainMenu()
-                       self["menulist"].l.setList(self.mainmenu)

                        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:
                        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:

-                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus

                        iStatus.stopWlanConsole()
                        iStatus.stopWlanConsole()

-                       self.mainmenu = self.genMainMenu()
-                       self["menulist"].l.setList(self.mainmenu)

                        self.updateStatusbar()
                        
        def restartLan(self, ret = False):
                        self.updateStatusbar()
                        
        def restartLan(self, ret = False):


@@ -950,18 +971,23 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
 
        def restartfinishedCB(self,data):
                if data is 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):
                        self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
 
        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 )


@@ -969,22 +995,42 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDeactivateInterfaceConsole()
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDeactivateInterfaceConsole()

+               iNetwork.stopPingConsole()

                try:
                try:

-                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus

                except ImportError:
                        pass
                else:
                        iStatus.stopWlanConsole()
 
        def getInfoCB(self,data,status):
                except ImportError:
                        pass
                else:
                        iStatus.stopWlanConsole()
 
        def getInfoCB(self,data,status):

+               self.LinkState = None

                if data is not None:
                        if data is True:
                                if status is not None:
                                        if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
                if data is not None:
                        if data is True:
                                if status is not None:
                                        if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:

+                                               self.LinkState = False

                                                self["statuspic"].setPixmapNum(1)
                                                self["statuspic"].setPixmapNum(1)

+                                               self["statuspic"].show()

                                        else:
                                        else:

-                                               self["statuspic"].setPixmapNum(0)
-                                       self["statuspic"].show()
+                                               self.LinkState = True
+                                               iNetwork.checkNetworkState(self.checkNetworkCB)
+
+       def checkNetworkCB(self,data):
+               if iNetwork.getAdapterAttribute(self.iface, "up") is True:
+                       if self.LinkState is True:
+                               if data <= 2:
+                                       self["statuspic"].setPixmapNum(0)
+                               else:
+                                       self["statuspic"].setPixmapNum(1)
+                               self["statuspic"].show()        
+                       else:
+                               self["statuspic"].setPixmapNum(1)
+                               self["statuspic"].show()
+               else:
+                       self["statuspic"].setPixmapNum(1)
+                       self["statuspic"].show()
+

 
 class NetworkAdapterTest(Screen):      
        def __init__(self, session,iface):
 
 class NetworkAdapterTest(Screen):      
        def __init__(self, session,iface):


@@ -1049,7 +1095,7 @@ class NetworkAdapterTest(Screen):
                self["infoshortcuts"].setEnabled(False)
                self["InfoText"].hide()
                self["InfoTextBorder"].hide()
                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


@@ -1137,8 +1183,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["ButtonYellow_Check"].show()
-               self["ButtonYellowtext"].show()
+               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))


@@ -1188,8 +1233,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)
 


@@ -1210,8 +1255,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)
 


@@ -1222,27 +1267,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)
 


@@ -1251,13 +1296,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()


@@ -1268,8 +1313,7 @@ class NetworkAdapterTest(Screen):
                self["EditSettingsButton"].hide()
                self["InfoText"].hide()
                self["InfoTextBorder"].hide()
                self["EditSettingsButton"].hide()
                self["InfoText"].hide()
                self["InfoTextBorder"].hide()

-               self["ButtonYellow_Check"].hide()
-               self["ButtonYellowtext"].hide()
+               self["key_yellow"].setText("")

 
        def setLabels(self):
                self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))
 
        def setLabels(self):
                self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))


@@ -1278,7 +1322,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"))


@@ -1309,22 +1353,17 @@ 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 iStatus,Status
+                               from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus

                        except:
                                        self["Network"].setForegroundColorNum(1)
                                        self["Network"].setText(_("disconnected"))
                        except:
                                        self["Network"].setForegroundColorNum(1)
                                        self["Network"].setText(_("disconnected"))


@@ -1379,9 +1418,8 @@ class NetworkAdapterTest(Screen):
                self["EditSettingsButton"].setPixmapNum(1)
                self["EditSettings_Text"].setForegroundColorNum(2) # active
                self["EditSettingsButton"].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["key_yellow"].setText("")
+               self["key_green"].setText(_("Restart test"))

                self["shortcutsgreen"].setEnabled(False)
                self["shortcutsgreen_restart"].setEnabled(True)
                self["shortcutsyellow"].setEnabled(False)
                self["shortcutsgreen"].setEnabled(False)
                self["shortcutsgreen_restart"].setEnabled(True)
                self["shortcutsyellow"].setEnabled(False)


@@ -1407,9 +1445,9 @@ class NetworkAdapterTest(Screen):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDNSConsole()
                try:
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDNSConsole()
                try:

-                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus

                except ImportError:
                        pass
                else:
                        iStatus.stopWlanConsole()
                except ImportError:
                        pass
                else:
                        iStatus.stopWlanConsole()

-                       
+