git.cweiske.de / enigma2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Screens/NetworkSetup.py, SystemPlugins/WirelessLan,Networkwizard: dont use "hidden...
[enigma2.git] / lib / python / Screens / NetworkSetup.py
diff --git a/lib/python/Screens/NetworkSetup.py b/lib/python/Screens/NetworkSetup.py
index 3e9354ead818872950be3067608a96ffb11a4db4..e7ba6071aee54deff0bbda40d5bb0bf800f6cad3 100755 (executable)
--- a/lib/python/Screens/NetworkSetup.py
+++ b/lib/python/Screens/NetworkSetup.py
@@ -7,10 +7,11 @@ from Screens.HelpMenu import HelpableScreen
 from Components.Network import iNetwork
 from Components.Sources.StaticText import StaticText
 from Components.Sources.Boolean import Boolean
 from Components.Network import iNetwork
 from Components.Sources.StaticText import StaticText
 from Components.Sources.Boolean import Boolean
+from Components.Sources.List import List
 from Components.Label import Label,MultiColorLabel
 from Components.Pixmap import Pixmap,MultiPixmap
 from Components.MenuList import MenuList
 from Components.Label import Label,MultiColorLabel
 from Components.Pixmap import Pixmap,MultiPixmap
 from Components.MenuList import MenuList
-from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing, ConfigBoolean
 from Components.ConfigList import ConfigListScreen
 from Components.PluginComponent import plugins
 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
 from Components.ConfigList import ConfigListScreen
 from Components.PluginComponent import plugins
 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
@@ -23,32 +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),
-               MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name)
-       ]
-       num_configured_if = len(iNetwork.getConfiguredAdapters())
-       if num_configured_if >= 2:
-               if default is True:
-                       png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
-               if default is False:
-                       png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
-               res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png))
-       if active is True:
-               png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
-       if active is False:
-               png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
-       res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2))
-       return res
-
-
 class NetworkAdapterSelection(Screen,HelpableScreen):
        def __init__(self, session):
                Screen.__init__(self, session)
 class NetworkAdapterSelection(Screen,HelpableScreen):
        def __init__(self, session):
                Screen.__init__(self, session)
@@ -64,13 +39,9 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                self["key_red"] = StaticText(_("Close"))
                self["key_green"] = StaticText(_("Select"))
                self["key_yellow"] = StaticText("")
                self["key_red"] = StaticText(_("Close"))
                self["key_green"] = StaticText(_("Select"))
                self["key_yellow"] = StaticText("")
+               self["key_blue"] = StaticText("")
                self["introduction"] = StaticText(self.edittext)
                
                self["introduction"] = StaticText(self.edittext)
                
-               self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
-               
-               if not self.adapters:
-                       self.onFirstExecBegin.append(self.NetworkFallback)
-                       
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {
                        "cancel": (self.close, _("exit network interface list")),
                self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
                        {
                        "cancel": (self.close, _("exit network interface list")),
@@ -81,6 +52,7 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        {
                        "red": (self.close, _("exit network interface list")),
                        "green": (self.okbuttonClick, _("select interface")),
                        {
                        "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",
@@ -88,14 +60,58 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        "yellow": (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.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
+
+               if not self.adapters:
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getConfiguredAdapters()]
+
+               if len(self.adapters) == 0:
+                       self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getInstalledAdapters()]
+
                self.list = []
                self.list = []
-               self["list"] = InterfaceList(self.list)
+               self["list"] = List(self.list)
                self.updateList()
 
                if len(self.adapters) == 1:
                        self.onFirstExecBegin.append(self.okbuttonClick)
                self.onClose.append(self.cleanup)
 
                self.updateList()
 
                if len(self.adapters) == 1:
                        self.onFirstExecBegin.append(self.okbuttonClick)
                self.onClose.append(self.cleanup)
 
+       def buildInterfaceList(self,iface,name,default,active ):
+               divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
+               defaultpng = None
+               activepng = None
+               description = None
+               interfacepng = None
+
+               if not iNetwork.isWirelessInterface(iface):
+                       if active is True:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-active.png"))
+                       elif active is False:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-inactive.png"))
+                       else:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired.png"))
+               elif iNetwork.isWirelessInterface(iface):
+                       if active is True:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-active.png"))
+                       elif active is False:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-inactive.png"))
+                       else:
+                               interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless.png"))
+
+               num_configured_if = len(iNetwork.getConfiguredAdapters())
+               if num_configured_if >= 2:
+                       if default is True:
+                               defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
+                       elif default is False:
+                               defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
+               if active is True:
+                       activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
+               elif active is False:
+                       activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
+               
+               description = iNetwork.getFriendlyAdapterDescription(iface)
+
+               return((iface, name, description, interfacepng, defaultpng, activepng, divpng)) 
 
        def updateList(self):
                self.list = []
 
        def updateList(self):
                self.list = []
@@ -119,21 +135,20 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                        fp.close()
                        default_gw = result
                                        
                        fp.close()
                        default_gw = result
                                        
-               if len(self.adapters) == 0: # no interface available => display only eth0
-                       self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
-               else:
-                       for x in self.adapters:
-                               if x[1] == default_gw:
-                                       default_int = True
-                               else:
-                                       default_int = False
-                               if iNetwork.getAdapterAttribute(x[1], 'up') is True:
-                                       active_int = True
-                               else:
-                                       active_int = False
-                               self.list.append(InterfaceEntryComponent(index = x[1],name = _(x[0]),default=default_int,active=active_int ))
-
-               self["list"].l.setList(self.list)
+               for x in self.adapters:
+                       if x[1] == default_gw:
+                               default_int = True
+                       else:
+                               default_int = False
+                       if iNetwork.getAdapterAttribute(x[1], 'up') is True:
+                               active_int = True
+                       else:
+                               active_int = False
+                       self.list.append(self.buildInterfaceList(x[1],_(x[0]),default_int,active_int ))
+               
+               if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
+                       self["key_blue"].setText(_("NetworkWizard"))
+               self["list"].setList(self.list)
 
        def setDefaultInterface(self):
                selection = self["list"].getCurrent()
 
        def setDefaultInterface(self):
                selection = self["list"].getCurrent()
@@ -164,22 +179,6 @@ class NetworkAdapterSelection(Screen,HelpableScreen):
                else:
                        self.updateList()
 
                else:
                        self.updateList()
 
-       def NetworkFallback(self):
-               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               if iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-               else:
-                       self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
-
-       def ErrorMessageClosed(self, *ret):
-               if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
-               elif iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
-               else:
-                       self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
-
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopRestartConsole()
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopRestartConsole()
@@ -202,6 +201,16 @@ 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):
 
 
 class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
@@ -239,7 +248,7 @@ class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
                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()
                self.nameserverEntries = [ NoSave(ConfigIP(default=nameserver)) for nameserver in self.nameservers]
        def createConfig(self):
                self.nameservers = iNetwork.getNameserverList()
                self.nameserverEntries = [ NoSave(ConfigIP(default=nameserver)) for nameserver in self.nameservers]
@@ -299,6 +308,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                        self.iface = networkinfo
                        self.essid = essid
                        self.aplist = aplist
                        self.iface = networkinfo
                        self.essid = essid
                        self.aplist = aplist
+                       
                self.extended = None
                self.applyConfigRef = None
                self.finished_cb = None
                self.extended = None
                self.applyConfigRef = None
                self.finished_cb = None
@@ -397,10 +407,12 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                self.weplist = None
                self.wsconfig = None
                self.default = None
                self.weplist = None
                self.wsconfig = None
                self.default = None
+               self.hiddenNW = None
 
 
-               if self.iface == "wlan0" or self.iface == "ath0" :
-                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
-                       self.w = Wlan(self.iface)
+               if iNetwork.isWirelessInterface(self.iface):
+                       from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant, iWlan
+                       iWlan.setInterface(self.iface)
+                       self.w = iWlan.getInterface()
                        self.ws = wpaSupplicant()
                        self.encryptionlist = []
                        self.encryptionlist.append(("WEP", _("WEP")))
                        self.ws = wpaSupplicant()
                        self.encryptionlist = []
                        self.encryptionlist.append(("WEP", _("WEP")))
@@ -417,7 +429,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                self.nwlist = []
                                self.aps = None
                                try:
                                self.nwlist = []
                                self.aps = None
                                try:
-                                       self.aps = self.w.getNetworkList()
+                                       self.aps = iWlan.getNetworkList()
                                        if self.aps is not None:
                                                for ap in self.aps:
                                                        a = self.aps[ap]
                                        if self.aps is not None:
                                                for ap in self.aps:
                                                        a = self.aps[ap]
@@ -425,22 +437,29 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                                                if a['essid'] != '':
                                                                        self.nwlist.append((a['essid'],a['essid']))
                                        self.nwlist.sort(key = lambda x: x[0])
                                                                if a['essid'] != '':
                                                                        self.nwlist.append((a['essid'],a['essid']))
                                        self.nwlist.sort(key = lambda x: x[0])
+                                       iWlan.stopGetNetworkList()
                                except:
                                        self.nwlist.append(("No Networks found",_("No Networks found")))
 
                                except:
                                        self.nwlist.append(("No Networks found",_("No Networks found")))
 
-                       self.wsconfig = self.ws.loadConfig()
+                       self.wsconfig = self.ws.loadConfig(self.iface)
                        if self.essid is not None: # ssid from wlan scan
                                self.default = self.essid
                        if self.essid is not None: # ssid from wlan scan
                                self.default = self.essid
+                               self.hiddenNW = self.wsconfig['hiddenessid']
+                               if self.essid == '<hidden>':
+                                       self.hiddenNW = True
+                                       self.default = self.default = self.wsconfig['ssid']
                        else:
                        else:
+                               self.hiddenNW = self.wsconfig['hiddenessid']
                                self.default = self.wsconfig['ssid']
 
                                self.default = self.wsconfig['ssid']
 
-                       if "hidden..." not in self.nwlist:
-                               self.nwlist.append(("hidden...",_("enter hidden network SSID")))
-                       if self.default not in self.nwlist:
+                       if (self.default not in self.nwlist and self.default is not '<hidden>'):
                                self.nwlist.append((self.default,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.hiddenessid = NoSave(ConfigYesNo(default = self.hiddenNW))
+                       if config.plugins.wlan.hiddenessid.value is True:
+                               config.plugins.wlan.essid = NoSave(ConfigText(default = self.default, visible_width = 50, fixed_size = False))
+                       else:
+                               config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
                        config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
                        config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
                        config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
                        config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
                        config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
                        config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
@@ -477,6 +496,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                        self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
 
                        self.extended = None
                                        self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
 
                        self.extended = None
+                       self.configStrings = None
                        for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                callFnc = p.__call__["ifaceSupported"](self.iface)
                                if callFnc is not None:
                        for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
                                callFnc = p.__call__["ifaceSupported"](self.iface)
                                if callFnc is not None:
@@ -484,16 +504,17 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                                self.extended = callFnc
                                                if p.__call__.has_key("configStrings"):
                                                        self.configStrings = p.__call__["configStrings"]
                                                self.extended = callFnc
                                                if p.__call__.has_key("configStrings"):
                                                        self.configStrings = p.__call__["configStrings"]
+
+                                               self.hiddenSSID = getConfigListEntry(_("enter hidden network SSID"), config.plugins.wlan.hiddenessid)
+                                               self.list.append(self.hiddenSSID)
+
+                                               if config.plugins.wlan.hiddenessid.value is True:
+                                                       config.plugins.wlan.essid = NoSave(ConfigText(default = self.default, visible_width = 50, fixed_size = False))
+                                                       self.wlanSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.essid)
                                                else:
                                                else:
-                                                       self.configStrings = None
-                                               if config.plugins.wlan.essid.value == 'hidden...':
-                                                       self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
-                                                       self.list.append(self.wlanSSID)
-                                                       self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid)
-                                                       self.list.append(self.hiddenSSID)
-                                               else:
+                                                       config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
                                                        self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
                                                        self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
-                                                       self.list.append(self.wlanSSID)
+                                               self.list.append(self.wlanSSID)
                                                self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
                                                self.list.append(self.encryptionEnabled)
                                                
                                                self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
                                                self.list.append(self.encryptionEnabled)
                                                
@@ -521,8 +542,8 @@ 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["config"].getCurrent() == self.wlanSSID:
+               if iNetwork.isWirelessInterface(self.iface):
+                       if self["config"].getCurrent() == self.hiddenSSID:
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionEnabled:
                                self.createSetup()
                                self.createSetup()
                        if self["config"].getCurrent() == self.encryptionEnabled:
                                self.createSetup()
@@ -551,7 +572,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                if (ret == True):               
                        num_configured_if = len(iNetwork.getConfiguredAdapters())
                        if num_configured_if >= 1:
                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():
+                               if self.iface in iNetwork.getConfiguredAdapters():      
                                        self.applyConfig(True)
                                else:
                                        self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True)
                                        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)
@@ -569,11 +590,15 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                if interface == self.iface:
                                        continue
                                iNetwork.setAdapterAttribute(interface, "up", False)
                                if interface == self.iface:
                                        continue
                                iNetwork.setAdapterAttribute(interface, "up", False)
-                               iNetwork.deactivateInterface(interface)
-                               self.applyConfig(True)
+                       iNetwork.deactivateInterface(configuredInterfaces,self.deactivateSecondInterfaceCB)
+
+       def deactivateSecondInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfig(True)
 
        def applyConfig(self, ret = False):
                if (ret == True):
 
        def applyConfig(self, ret = False):
                if (ret == True):
+                       self.applyConfigRef = None
                        iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
                        iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
@@ -584,15 +609,27 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                                iNetwork.removeAdapterAttribute(self.iface, "gateway")
                        if self.extended is not None and self.configStrings is not None:
                                iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
                                iNetwork.removeAdapterAttribute(self.iface, "gateway")
                        if self.extended is not None and self.configStrings is not None:
                                iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
-                               self.ws.writeConfig()
+                               self.ws.writeConfig(self.iface)
+
                        if self.activateInterfaceEntry.value is False:
                        if self.activateInterfaceEntry.value is False:
-                               iNetwork.deactivateInterface(self.iface)
-                       iNetwork.writeNetworkConfig()
-                       iNetwork.restartNetwork(self.applyConfigDataAvail)
-                       self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                               iNetwork.deactivateInterface(self.iface,self.deactivateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       else:
+                               iNetwork.deactivateInterface(self.iface,self.activateInterfaceCB)
+                               iNetwork.writeNetworkConfig()
+                               self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
                else:
                        self.keyCancel()
 
                else:
                        self.keyCancel()
 
+       def deactivateInterfaceCB(self, data):
+               if data is True:
+                       self.applyConfigDataAvail(True)
+
+       def activateInterfaceCB(self, data):
+               if data is True:
+                       iNetwork.activateInterface(self.iface,self.applyConfigDataAvail)
+
        def applyConfigDataAvail(self, data):
                if data is True:
                        iNetwork.getInterfaces(self.getInterfacesDataAvail)
        def applyConfigDataAvail(self, data):
                if data is True:
                        iNetwork.getInterfaces(self.getInterfacesDataAvail)
@@ -650,7 +687,7 @@ class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
                
        def hideInputHelp(self):
                current = self["config"].getCurrent()
                
        def hideInputHelp(self):
                current = self["config"].getCurrent()
-               if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+               if current == self.wlanSSID and config.plugins.wlan.hiddenessid.value:
                        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()
                elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
@@ -678,7 +715,8 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                
                self.oktext = _("Press OK on your remote control to continue.")
                self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
                
                self.oktext = _("Press OK on your remote control to continue.")
                self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
-               self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")      
+               self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")
+               self.missingwlanplugintxt = _("The wireless LAN plugin is not installed!\nPlease install it.")
                
                self["WizardActions"] = HelpableActionMap(self, "WizardActions",
                        {
                
                self["WizardActions"] = HelpableActionMap(self, "WizardActions",
                        {
@@ -714,23 +752,39 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self.onLayoutFinish.append(self.layoutFinished)
                self.onClose.append(self.cleanup)
 
                self.onLayoutFinish.append(self.layoutFinished)
                self.onClose.append(self.cleanup)
 
+
+       def queryWirelessDevice(self,iface):
+               try:
+                       from pythonwifi.iwlibs import Wireless
+                       import errno
+               except ImportError:
+                       return False
+               else:
+                       try:
+                               ifobj = Wireless(iface) # a Wireless NIC Object
+                               wlanresponse = ifobj.getAPaddr()
+                       except IOError, (error_no, error_str):
+                               if error_no in (errno.EOPNOTSUPP, errno.EINVAL, errno.ENODEV, errno.EPERM):
+                                       return False
+                               else:
+                                       print "error: ",error_no,error_str
+                                       return True
+                       else:
+                               return True
+
        def ok(self):
                self.cleanup()
                if self["menulist"].getCurrent()[1] == 'edit':
        def ok(self):
                self.cleanup()
                if self["menulist"].getCurrent()[1] == 'edit':
-                       if self.iface == 'wlan0' or self.iface == 'ath0':
+                       if iNetwork.isWirelessInterface(self.iface):
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
                                try:
                                        from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
-                                       from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
                                except ImportError:
                                except ImportError:
-                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                                else:
                                else:
-                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
-                                       self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse[0] != 19: # Wlan Interface found.
+                                       if self.queryWirelessDevice(self.iface):
                                                self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                                        else:
                                                self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                                        else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                                               self.showErrorMessage() # Display Wlan not available Message
                        else:
                                self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                if self["menulist"].getCurrent()[1] == 'test':
                        else:
                                self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
                if self["menulist"].getCurrent()[1] == 'test':
@@ -740,36 +794,28 @@ 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
                        except ImportError:
                        except ImportError:
-                               self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                        else:
                        else:
-                               ifobj = Wireless(self.iface) # a Wireless NIC Object
-                               self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse[0] != 19:
+                               if self.queryWirelessDevice(self.iface):
                                        self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
                                else:
                                        self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
                                else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                if self["menulist"].getCurrent()[1] == 'wlanstatus':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
                if self["menulist"].getCurrent()[1] == 'wlanstatus':
                        try:
                                from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
-                               from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
                        except ImportError:
                        except ImportError:
-                               self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
-                       else:   
-                               ifobj = Wireless(self.iface) # a Wireless NIC Object
-                               self.wlanresponse = ifobj.getStatistics()
-                               if self.wlanresponse[0] != 19:
+                               self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
+                       else:
+                               if self.queryWirelessDevice(self.iface):
                                        self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                else:
                                        self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                else:
-                                       # Display Wlan not available Message
-                                       self.showErrorMessage()
+                                       self.showErrorMessage() # Display Wlan not available Message
                if self["menulist"].getCurrent()[1] == 'lanrestart':
                        self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
                if self["menulist"].getCurrent()[1] == 'openwizard':
                        from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
                if self["menulist"].getCurrent()[1] == 'lanrestart':
                        self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
                if self["menulist"].getCurrent()[1] == 'openwizard':
                        from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
-                       self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard)
+                       self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, self.iface)
                if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
                        self.extended = self["menulist"].getCurrent()[1][2]
                        self.extended(self.session, self.iface)
                if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
                        self.extended = self["menulist"].getCurrent()[1][2]
                        self.extended(self.session, self.iface)
@@ -803,7 +849,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                if self["menulist"].getCurrent()[1] == 'dns':
                        self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext )
                if self["menulist"].getCurrent()[1] == 'scanwlan':
                if self["menulist"].getCurrent()[1] == 'dns':
                        self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext )
                if self["menulist"].getCurrent()[1] == 'scanwlan':
-                       self["description"].setText(_("Scan your network for wireless Access Points and connect to them using your selected wireless device.\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':
@@ -820,7 +866,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                self["Statustext"].setText(_("Link:"))
                
                self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
                self["Statustext"].setText(_("Link:"))
                
-               if self.iface == 'wlan0' or self.iface == 'ath0':
+               if iNetwork.isWirelessInterface(self.iface):
                        try:
                                from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        except:
                        try:
                                from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                        except:
@@ -870,20 +916,16 @@ 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 (iNetwork.isWirelessInterface(self.iface) 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
                                except ImportError:
                                except ImportError:
-                                       self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+                                       self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
                                else:   
                                else:   
-                                       ifobj = Wireless(self.iface) # a Wireless NIC Object
-                                       self.wlanresponse = ifobj.getStatistics()
-                                       if self.wlanresponse[0] != 19:
+                                       if self.queryWirelessDevice(self.iface):
                                                self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                        else:
                                                self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
                                        else:
-                                               # Display Wlan not available Message
-                                               self.showErrorMessage()
+                                               self.showErrorMessage() # Display Wlan not available Message
                        else:
                                self.updateStatusbar()
                else:
                        else:
                                self.updateStatusbar()
                else:
@@ -891,7 +933,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
 
        def WlanStatusClosed(self, *ret):
                if ret is not None and len(ret):
 
        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()
                        self.updateStatusbar()
 
                        iStatus.stopWlanConsole()
                        self.updateStatusbar()
 
@@ -899,7 +941,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
                if ret[0] is not None:
                        self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
                else:
                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()
                        self.updateStatusbar()
                        
                        iStatus.stopWlanConsole()
                        self.updateStatusbar()
                        
@@ -942,6 +984,7 @@ class AdapterSetupConfiguration(Screen, HelpableScreen):
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDeactivateInterfaceConsole()
        def cleanup(self):
                iNetwork.stopLinkStateConsole()
                iNetwork.stopDeactivateInterfaceConsole()
+               iNetwork.stopActivateInterfaceConsole()
                iNetwork.stopPingConsole()
                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
                iNetwork.stopPingConsole()
                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
@@ -1249,6 +1292,7 @@ class NetworkAdapterTest(Screen):
                self.nextStepTimer.stop()
 
        def layoutFinished(self):
                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,7 +1312,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"))
@@ -1307,9 +1351,9 @@ class NetworkAdapterTest(Screen):
                self["InfoText"] = Label()
 
        def getLinkState(self,iface):
                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"))
@@ -1322,7 +1366,7 @@ class NetworkAdapterTest(Screen):
 
        def LinkStatedataAvail(self,data):
                self.output = data.strip()
 
        def LinkStatedataAvail(self,data):
                self.output = data.strip()
-               result = self.output.split('\n')
+               result = self.output.splitlines()
                pattern = re_compile("Link detected: yes")
                for item in result:
                        if re_search(pattern, item):
                pattern = re_compile("Link detected: yes")
                for item in result:
                        if re_search(pattern, item):
@@ -1391,7 +1435,7 @@ 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:
                except ImportError:
                        pass
                else:
Clone of git://git.opendreambox.org/git/enigma2.git before dream multimedia removed all the engima2 sources