from Screen import Screen
-from Components.ActionMap import ActionMap,NumberActionMap
from Screens.MessageBox import MessageBox
+from Screens.InputBox import InputBox
from Screens.Standby import *
-from Components.ConfigList import ConfigListScreen
-from Components.config import config, getConfigListEntry
+from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Screens.HelpMenu import HelpableScreen
from Components.Network import iNetwork
-from Tools.Directories import resolveFilename, SCOPE_SKIN_IMAGE
from Components.Label import Label,MultiColorLabel
from Components.Pixmap import Pixmap,MultiPixmap
-from Tools.LoadPixmap import LoadPixmap
from Components.MenuList import MenuList
-from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigNothing, ConfigSubsection, ConfigText, ConfigSelection, getConfigListEntry
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing
+from Components.ConfigList import ConfigListScreen
from Components.PluginComponent import plugins
+from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
+from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap
+from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_SKIN_IMAGE
+from Tools.LoadPixmap import LoadPixmap
from Plugins.Plugin import PluginDescriptor
-from enigma import eTimer, eConsoleAppContainer,gRGB
-import time, os, re
-from Tools.Directories import resolveFilename, SCOPE_PLUGINS
-
-def getColor(str):
- return gRGB(int(str[1:], 0x10))
-
-class NetworkAdapterSelection(Screen):
+from enigma import eTimer, ePoint, eSize, RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont
+from os import path as os_path, system as os_system, unlink
+from re import compile as re_compile, search as re_search
+
+
+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)
- iNetwork.getInterfaces()
+ HelpableScreen.__init__(self)
+
self.wlan_errortext = _("No working wireless networkadapter found.\nPlease verify that you have attached a compatible WLAN USB Stick and your Network is configured correctly.")
self.lan_errortext = _("No working local networkadapter found.\nPlease verify that you have attached a network cable and your Network is configured correctly.")
+ self.oktext = _("Press OK on your remote control to continue.")
+ 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.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
+
if len(self.adapters) == 0:
self.onFirstExecBegin.append(self.NetworkFallback)
- self["adapterlist"] = MenuList(self.adapters)
- self["actions"] = ActionMap(["OkCancelActions"],
- {
- "ok": self.okbuttonClick,
- "cancel": self.close
- })
-
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.close, _("exit networkinterface list")),
+ "ok": (self.okbuttonClick, _("select interface")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.close, _("exit networkinterface list")),
+ })
+
+ self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions",
+ {
+ "blue": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more then one interface is active.")] ),
+ })
+
+ self.list = []
+ self["list"] = InterfaceList(self.list)
+ self.updateList()
+
if len(self.adapters) == 1:
self.onFirstExecBegin.append(self.okbuttonClick)
+ self.onClose.append(self.cleanup)
+
+ def updateList(self):
+ iNetwork.getInterfaces()
+ self.list = []
+ default_gw = None
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ self["ButtonBlue"].show()
+ self["ButtonBluetext"].show()
+ self["DefaultInterfaceAction"].setEnabled(True)
+ else:
+ self["ButtonBlue"].hide()
+ self["ButtonBluetext"].hide()
+ self["DefaultInterfaceAction"].setEnabled(False)
+
+ if num_configured_if < 2 and os_path.exists("/etc/default_gw"):
+ unlink("/etc/default_gw")
+
+ if os_path.exists("/etc/default_gw"):
+ fp = file('/etc/default_gw', 'r')
+ result = fp.read()
+ fp.close()
+ default_gw = result
+
+ if len(self.adapters) == 0: # no interface available => display only eth0
+ self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
+ else:
+ for x in self.adapters:
+ if x[1] == default_gw:
+ default_int = True
+ else:
+ default_int = False
+ if iNetwork.getAdapterAttribute(x[1], 'up') is True:
+ active_int = True
+ else:
+ active_int = False
+ self.list.append(InterfaceEntryComponent(index = x[1],name = _(x[0]),default=default_int,active=active_int ))
+ self["list"].l.setList(self.list)
+
+ def setDefaultInterface(self):
+ selection = self["list"].getCurrent()
+ num_if = len(self.list)
+ old_default_gw = None
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if os_path.exists("/etc/default_gw"):
+ fp = open('/etc/default_gw', 'r')
+ old_default_gw = fp.read()
+ fp.close()
+ if num_configured_if > 1 and (not old_default_gw or old_default_gw != selection[0]):
+ fp = open('/etc/default_gw', 'w+')
+ fp.write(selection[0])
+ fp.close()
+ self.restartLan()
+ elif old_default_gw and num_configured_if < 2:
+ unlink("/etc/default_gw")
+ self.restartLan()
def okbuttonClick(self):
- selection = self["adapterlist"].getCurrent()
+ selection = self["list"].getCurrent()
if selection is not None:
- self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[1])
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0])
def AdapterSetupClosed(self, *ret):
- self.close()
+ if len(self.adapters) == 1:
+ self.close()
+ else:
+ self.updateList()
def NetworkFallback(self):
- if iNetwork.configuredInterfaces.has_key('wlan0') is True:
+ if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
+ self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
+ 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.configuredInterfaces.has_key('wlan0') is True:
+ 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')
-class NameserverSetup(Screen, ConfigListScreen):
+ def cleanup(self):
+ iNetwork.stopLinkStateConsole()
+ iNetwork.stopRestartConsole()
+
+ def restartLan(self):
+ iNetwork.restartNetwork(self.restartLanDataAvail)
+ self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while we configure your network..."), type = MessageBox.TYPE_INFO, enable_input = False)
+
+ def restartLanDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.restartLanRef.close(True)
+
+ def restartfinishedCB(self,data):
+ if data is True:
+ self.updateList()
+ self.session.open(MessageBox, _("Finished configuring your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
+
+
+class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
def __init__(self, session):
Screen.__init__(self, session)
- iNetwork.getInterfaces()
+ HelpableScreen.__init__(self)
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.createConfig()
- self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
- {
- "ok": self.ok,
- "cancel": self.cancel,
- "red": self.cancel,
- "green": self.add,
- "yellow": self.remove
- }, -2)
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.cancel, _("exit nameserver configuration")),
+ "ok": (self.ok, _("activate current configuration")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.cancel, _("exit nameserver configuration")),
+ "green": (self.add, _("add a nameserver entry")),
+ "yellow": (self.remove, _("remove a nameserver entry")),
+ })
+
self.list = []
ConfigListScreen.__init__(self, self.list)
iNetwork.writeNameserverConfig()
self.close()
+ def run(self):
+ self.ok()
+
def cancel(self):
iNetwork.clearNameservers()
print "backup-list:", self.backupNameserverList
iNetwork.removeNameserver(self.nameservers[index])
self.createConfig()
self.createSetup()
-
-class AdapterSetup(Screen, ConfigListScreen):
- def __init__(self, session, iface):
+
+class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
+ def __init__(self, session, iface,essid=None, aplist=None):
Screen.__init__(self, session)
+ HelpableScreen.__init__(self)
self.session = session
- iNetwork.getInterfaces()
- ## FIXME , workaround against current wizzard not able to send arguments
- if iface == 0:
- self.iface = "eth0"
- elif iface == 1:
- self.iface = "wlan0"
- else:
- self.iface = iface
-
- if self.iface == 'wlan0':
- from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
- self.ws = wpaSupplicant()
- list = []
- list.append(_("WEP"))
- list.append(_("WPA"))
- list.append(_("WPA2"))
- if iNetwork.getAdapterAttribute('wlan0', 'up') is True:
- try:
- self.w = Wlan('wlan0')
- aps = self.w.getNetworkList()
- nwlist = []
- if aps is not None:
- print "[Wlan.py] got Accespoints!"
- for ap in aps:
- a = aps[ap]
- if a['active']:
- if a['essid'] == "":
- a['essid'] = a['bssid']
- nwlist.append( a['essid'])
- nwlist.sort(key = lambda x: x[0])
- except:
- nwlist = []
- nwlist.append("No Networks found")
-
- if nwlist is None:
- nwlist = []
- nwlist.append("No Networks found")
-
- config.plugins.wlan.essid = NoSave(ConfigSelection(nwlist, default = nwlist[0]))
- config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = False))
- config.plugins.wlan.encryption.type = NoSave(ConfigSelection(list, default = _("WPA")))
- config.plugins.wlan.encryption.psk = NoSave(ConfigText(default = "mysecurewlan", fixed_size = False))
- self.ws.loadConfig()
-
- self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
- self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=True))
- self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])
- self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask") or [255,0,0,0]))
- self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway") or [0,0,0,0]))
- nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
- self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
- self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
+ self.iface = iface
+ self.essid = essid
+ self.aplist = aplist
+ self.extended = None
+ self.applyConfigRef = None
+ self.finished_cb = None
+ self.oktext = _("Press OK on your remote control to continue.")
+ self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
+ #iNetwork.getInterfaces()
- self["actions"] = ActionMap(["SetupActions","ShortcutActions"],
+ self.createConfig()
+
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.close, _("exit networkadapter setup menu")),
+ "ok": (self.ok, _("select menu entry")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.cancel, _("exit networkadapter configuration")),
+ "blue": (self.KeyBlue, _("open nameserver configuration")),
+ })
+
+ self["VirtualKB"] = HelpableActionMap(self, "ColorActions",
+ {
+ "green": (self.KeyGreen, [_("open virtual keyboard input help"),_("* Only available when entering hidden ssid or network key")] ),
+ })
+
+ self["actions"] = NumberActionMap(["SetupActions"],
{
"ok": self.ok,
- "cancel": self.cancel,
- "red": self.cancel,
- "blue": self.KeyBlue,
}, -2)
+
self.list = []
- ConfigListScreen.__init__(self, 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["ButtonRedtext"] = Label(_("Close"))
self["ButtonBlue"] = Pixmap()
self["ButtonBluetext"] = Label(_("Edit DNS"))
+ self["ButtonGreen"] = Pixmap()
+ self["VKeyIcon"] = Pixmap()
+ self["HelpWindow"] = Pixmap()
def layoutFinished(self):
self["DNS1"].setText(self.primaryDNS.getText())
self["DNS2"].setText(self.secondaryDNS.getText())
if self.ipConfigEntry.getText() is not None:
- self["IP"].setText(self.ipConfigEntry.getText())
+ if self.ipConfigEntry.getText() == "0.0.0.0":
+ self["IP"].setText(_("N/A"))
+ else:
+ self["IP"].setText(self.ipConfigEntry.getText())
else:
- self["IP"].setText([0,0,0,0])
- self["Mask"].setText(self.netmaskConfigEntry.getText())
- self["Gateway"].setText(self.gatewayConfigEntry.getText())
+ self["IP"].setText(_("N/A"))
+ if self.netmaskConfigEntry.getText() is not None:
+ if self.netmaskConfigEntry.getText() == "0.0.0.0":
+ self["Mask"].setText(_("N/A"))
+ else:
+ self["Mask"].setText(self.netmaskConfigEntry.getText())
+ else:
+ self["IP"].setText(_("N/A"))
+ if iNetwork.getAdapterAttribute(self.iface, "gateway"):
+ if self.gatewayConfigEntry.getText() == "0.0.0.0":
+ self["Gateway"].setText(_("N/A"))
+ else:
+ self["Gateway"].setText(self.gatewayConfigEntry.getText())
+ else:
+ self["Gateway"].hide()
+ self["Gatewaytext"].hide()
self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
+ self["ButtonGreen"].hide()
+ self["VKeyIcon"].hide()
+ self["VirtualKB"].setEnabled(False)
+ self["HelpWindow"].hide()
+
+ def createConfig(self):
+ self.InterfaceEntry = None
+ self.dhcpEntry = None
+ self.gatewayEntry = None
+ self.hiddenSSID = None
+ self.wlanSSID = None
+ self.encryptionEnabled = None
+ self.encryptionKey = None
+ self.encryptionType = None
+ self.nwlist = None
+ self.encryptionlist = None
+ self.weplist = None
+ self.wsconfig = None
+ self.default = None
+
+ if self.iface == "wlan0" or self.iface == "ath0" :
+ from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
+ self.w = Wlan(self.iface)
+ self.ws = wpaSupplicant()
+ self.encryptionlist = []
+ self.encryptionlist.append(("WEP", _("WEP")))
+ self.encryptionlist.append(("WPA", _("WPA")))
+ self.encryptionlist.append(("WPA2", _("WPA2")))
+ self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+ self.weplist = []
+ self.weplist.append("ASCII")
+ self.weplist.append("HEX")
+ if self.aplist is not None:
+ self.nwlist = self.aplist
+ self.nwlist.sort(key = lambda x: x[0])
+ else:
+ self.nwlist = []
+ self.aps = None
+ try:
+ self.aps = self.w.getNetworkList()
+ if self.aps is not None:
+ print "[NetworkSetup.py] got Accespoints!"
+ print self.aps
+ for ap in self.aps:
+ a = self.aps[ap]
+ if a['active']:
+ if a['essid'] == "":
+ a['essid'] = a['bssid']
+ self.nwlist.append( a['essid'])
+ self.nwlist.sort(key = lambda x: x[0])
+ except:
+ self.nwlist.append("No Networks found")
+
+ self.wsconfig = self.ws.loadConfig()
+ if self.essid is not None: # ssid from wlan scan
+ self.default = self.essid
+ else:
+ self.default = self.wsconfig['ssid']
+
+ if "hidden..." not in self.nwlist:
+ self.nwlist.append("hidden...")
+ if self.default not in self.nwlist:
+ self.nwlist.append(self.default)
+
+ config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
+ config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
+
+ config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
+ config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
+ config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
+ config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
+
+ self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
+ self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
+ self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])
+ self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask") or [255,0,0,0]))
+ if iNetwork.getAdapterAttribute(self.iface, "gateway"):
+ self.dhcpdefault=True
+ else:
+ self.dhcpdefault=False
+ self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=self.dhcpdefault or False))
+ self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway") or [0,0,0,0]))
+ nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
+ self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
+ self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
def createSetup(self):
self.list = []
+ self.InterfaceEntry = getConfigListEntry(_("Use Interface"), self.activateInterfaceEntry)
- self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
- self.list.append(self.dhcpEntry)
- if not self.dhcpConfigEntry.value:
- self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
- self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
- self.list.append(getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry))
- if self.hasGatewayConfigEntry.value:
- self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
-
- self.extended = None
- self.extendedSetup = None
- for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
- callFnc = p.__call__["ifaceSupported"](self.iface)
- if callFnc is not None:
- self.extended = callFnc
- print p.__call__
- if p.__call__.has_key("configStrings"):
- self.configStrings = p.__call__["configStrings"]
- else:
- self.configStrings = None
-
- self.list.append(getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid))
- self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
- self.list.append(self.encryptionEnabled)
-
- if config.plugins.wlan.encryption.enabled.value:
- self.list.append(getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type))
- self.list.append(getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk))
+ self.list.append(self.InterfaceEntry)
+ if self.activateInterfaceEntry.value:
+ self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
+ self.list.append(self.dhcpEntry)
+ if not self.dhcpConfigEntry.value:
+ self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
+ self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
+ self.gatewayEntry = getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry)
+ self.list.append(self.gatewayEntry)
+ if self.hasGatewayConfigEntry.value:
+ self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
+
+ self.extended = None
+ for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
+ callFnc = p.__call__["ifaceSupported"](self.iface)
+ if callFnc is not None:
+ if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
+ self.extended = callFnc
+ if p.__call__.has_key("configStrings"):
+ self.configStrings = p.__call__["configStrings"]
+ else:
+ self.configStrings = None
+ if config.plugins.wlan.essid.value == 'hidden...':
+ self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
+ self.list.append(self.wlanSSID)
+ self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid)
+ self.list.append(self.hiddenSSID)
+ else:
+ self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
+ self.list.append(self.wlanSSID)
+ self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
+ self.list.append(self.encryptionEnabled)
+
+ if config.plugins.wlan.encryption.enabled.value:
+ self.encryptionType = getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type)
+ self.list.append(self.encryptionType)
+ if config.plugins.wlan.encryption.type.value == 'WEP':
+ self.list.append(getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.encryption.wepkeytype))
+ self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
+ self.list.append(self.encryptionKey)
+ else:
+ self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
+ self.list.append(self.encryptionKey)
+
self["config"].list = self.list
self["config"].l.setList(self.list)
+ if not self.selectionChanged in self["config"].onSelectionChanged:
+ self["config"].onSelectionChanged.append(self.selectionChanged)
def KeyBlue(self):
- self.session.open(NameserverSetup)
+ self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
+ def KeyGreen(self):
+ if self.iface == "wlan0" or self.iface == "ath0" :
+ if self["config"].getCurrent() == self.hiddenSSID:
+ if config.plugins.wlan.essid.value == 'hidden...':
+ self.session.openWithCallback(self.VirtualKeyBoardSSIDCallback, VirtualKeyBoard, title = (_("Enter WLAN networkname/SSID:")), text = config.plugins.wlan.essid.value)
+ if self["config"].getCurrent() == self.encryptionKey:
+ self.session.openWithCallback(self.VirtualKeyBoardKeyCallback, VirtualKeyBoard, title = (_("Enter WLAN passphrase/key:")), text = config.plugins.wlan.encryption.psk.value)
+
+ def VirtualKeyBoardSSIDCallback(self, callback = None):
+ if callback is not None and len(callback):
+ config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = callback, visible_width = 50, fixed_size = False))
+ self.createSetup()
+
+ def VirtualKeyBoardKeyCallback(self, callback = None):
+ if callback is not None and len(callback):
+ config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = callback, visible_width = 50, fixed_size = False))
+ self.createSetup()
+
def newConfig(self):
- print self["config"].getCurrent()
+ if self["config"].getCurrent() == self.InterfaceEntry:
+ self.createSetup()
if self["config"].getCurrent() == self.dhcpEntry:
self.createSetup()
-
+ if self["config"].getCurrent() == self.gatewayEntry:
+ self.createSetup()
+ if self.iface == "wlan0" or self.iface == "ath0" :
+ if self["config"].getCurrent() == self.wlanSSID:
+ self.createSetup()
+ if self["config"].getCurrent() == self.encryptionEnabled:
+ self.createSetup()
+ if self["config"].getCurrent() == self.encryptionType:
+ self.createSetup()
def keyLeft(self):
ConfigListScreen.keyLeft(self)
- self.createSetup()
+ self.newConfig()
def keyRight(self):
ConfigListScreen.keyRight(self)
- self.createSetup()
+ self.newConfig()
+
+ def selectionChanged(self):
+ current = self["config"].getCurrent()
+ if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+ helpwindowpos = self["HelpWindow"].getPosition()
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+ self["ButtonGreen"].show()
+ self["VKeyIcon"].show()
+ self["VirtualKB"].setEnabled(True)
+ elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+ helpwindowpos = self["HelpWindow"].getPosition()
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+ self["ButtonGreen"].show()
+ self["VKeyIcon"].show()
+ self["VirtualKB"].setEnabled(True)
+ else:
+ self["ButtonGreen"].hide()
+ self["VKeyIcon"].hide()
+ self["VirtualKB"].setEnabled(False)
def ok(self):
- selection = self["config"].getCurrent()
- if selection == self.extendedSetup:
- self.extended(self.session, self.iface)
- else:
+ current = self["config"].getCurrent()
+ if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+ elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+ self.session.openWithCallback(self.applyConfig, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) )
+
+ def applyConfig(self, ret = False):
+ if (ret == True):
+ iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
else:
iNetwork.removeAdapterAttribute(self.iface, "gateway")
-
if self.extended is not None and self.configStrings is not None:
iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
self.ws.writeConfig()
+ if self.activateInterfaceEntry.value is False:
+ iNetwork.deactivateInterface(self.iface)
+ iNetwork.writeNetworkConfig()
+ iNetwork.restartNetwork(self.applyConfigDataAvail)
+ self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait while activating your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+ else:
+ self.cancel()
- iNetwork.deactivateNetworkConfig()
- iNetwork.writeNetworkConfig()
- iNetwork.activateNetworkConfig()
- self.close()
+ def applyConfigDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.applyConfigRef.close(True)
+
+ def applyConfigfinishedCB(self,data):
+ if data is True:
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("Your network configuration has been activated.\nA second configured interface has been found.\n\nDo you want to disable the second networkinterface?"), default = True)
+ else:
+ if self.finished_cb:
+ self.session.openWithCallback(self.finished_cb, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+ else:
+ self.session.openWithCallback(self.ConfigfinishedCB, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+
+ def secondIfaceFoundCB(self,data):
+ if data is False:
+ self.close('ok')
+ else:
+ configuredInterfaces = configuredNetworkAdapters
+ for interface in configuredInterfaces:
+ if interface == self.iface:
+ continue
+ iNetwork.setAdapterAttribute(interface, "up", False)
+ iNetwork.deactivateInterface(interface)
+ self.applyConfig(True)
+
+ def ConfigfinishedCB(self,data):
+ if data is True:
+ self.close('ok')
def cancel(self):
+ iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
+ self.activateInterfaceEntry.value = self.oldInterfaceState
+ if self.activateInterfaceEntry.value is False:
+ iNetwork.deactivateInterface(self.iface)
iNetwork.getInterfaces()
- self.close()
+ self.close('cancel')
- def run(self):
+ def runAsync(self, finished_cb):
+ self.finished_cb = finished_cb
self.ok()
+
+ def NameserverSetupClosed(self, *ret):
+ iNetwork.loadNameserverConfig()
+ nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
+ self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
+ self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
+ self.createSetup()
+ self.layoutFinished()
+
+ def cleanup(self):
+ iNetwork.stopLinkStateConsole()
+ iNetwork.stopRestartConsole()
-
-class AdapterSetupConfiguration(Screen):
+class AdapterSetupConfiguration(Screen, HelpableScreen):
def __init__(self, session,iface):
Screen.__init__(self, session)
- self.iface = iface
+ HelpableScreen.__init__(self)
self.session = session
+ self.iface = iface
+ self.restartLanRef = None
self.mainmenu = self.genMainMenu()
self["menulist"] = MenuList(self.mainmenu)
self["description"] = Label()
self.oktext = _("Press OK on your remote control to continue.")
self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
- self.errortext = _("No working wireless interface found.\n Please verify that you have attached a compatible WLAN USB Stick or enable you local network interface.")
+ self.errortext = _("No working wireless interface found.\n Please verify that you have attached a compatible WLAN device or enable you local network interface.")
+
+ self["WizardActions"] = HelpableActionMap(self, "WizardActions",
+ {
+ "up": (self.up, _("move up to previous entry")),
+ "down": (self.down, _("move down to next entry")),
+ "left": (self.left, _("move up to first entry")),
+ "right": (self.right, _("move down to last entry")),
+ })
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.close, _("exit networkadapter setup menu")),
+ "ok": (self.ok, _("select menu entry")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.close, _("exit networkadapter setup menu")),
+ })
+
self["actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
{
"ok": self.ok,
"right": self.right,
}, -2)
- iNetwork.getInterfaces()
+ iNetwork.getInterfaces(self.updateStatusbar)
self.onLayoutFinish.append(self.layoutFinished)
- self.updateStatusbar()
+ self.onClose.append(self.cleanup)
+ self.onHide.append(self.cleanup)
def ok(self):
if self["menulist"].getCurrent()[1] == 'edit':
- if self.iface == 'wlan0':
- from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
- ifobj = Wireless(self.iface) # a Wireless NIC Object
- self.wlanresponse = ifobj.getStatistics()
- if self.wlanresponse[0] != 19: # Wlan Interface found.
- self.session.open(AdapterSetup,self.iface)
+ if self.iface == 'wlan0' or self.iface == 'ath0':
+ try:
+ from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
+ from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
else:
- # Display Wlan not available Message
- self.showErrorMessage()
+ 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)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
else:
- self.session.open(AdapterSetup,self.iface)
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
if self["menulist"].getCurrent()[1] == 'test':
self.session.open(NetworkAdapterTest,self.iface)
if self["menulist"].getCurrent()[1] == 'dns':
self.session.open(NameserverSetup)
if self["menulist"].getCurrent()[1] == 'scanwlan':
- from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
- ifobj = Wireless(self.iface) # a Wireless NIC Object
- self.wlanresponse = ifobj.getStatistics()
- if self.wlanresponse[0] != 19:
+ try:
from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
- self.session.open(WlanScan,self.iface)
+ from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
else:
- # Display Wlan not available Message
- self.showErrorMessage()
+ 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)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
if self["menulist"].getCurrent()[1] == 'wlanstatus':
- from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
- ifobj = Wireless(self.iface) # a Wireless NIC Object
- self.wlanresponse = ifobj.getStatistics()
- if self.wlanresponse[0] != 19:
+ try:
from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
- self.session.open(WlanStatus,self.iface)
- else:
- # Display Wlan not available Message
- self.showErrorMessage()
+ from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ ifobj = Wireless(self.iface) # a Wireless NIC Object
+ self.wlanresponse = ifobj.getStatistics()
+ if self.wlanresponse[0] != 19:
+ self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
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] == 'enablewlan':
- self.session.openWithCallback(self.enableWlan, MessageBox, _("Are you sure you want to enable WLAN support?\nConnect your Wlan USB Stick to your Dreambox and press OK.\n\n") )
- if self["menulist"].getCurrent()[1] == 'enablelan':
- self.session.openWithCallback(self.enableLan, MessageBox, (_("Are you sure you want to enable your local network?\n\n") + self.oktext ) )
if self["menulist"].getCurrent()[1] == 'openwizard':
from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard)
+ if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
+ self.extended = self["menulist"].getCurrent()[1][2]
+ self.extended(self.session, self.iface)
def up(self):
self["menulist"].up()
self.loadDescription()
def loadDescription(self):
+ print self["menulist"].getCurrent()[1]
if self["menulist"].getCurrent()[1] == 'edit':
self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext )
if self["menulist"].getCurrent()[1] == 'test':
self["description"].setText(_("Test the network configuration of your Dreambox.\n" ) + self.oktext )
- if self["menulist"].getCurrent()[1] == 'enablelan':
- self["description"].setText(_("Enable the local network of your Dreambox.\n\n" ) + self.oktext )
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(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext )
if self["menulist"].getCurrent()[1] == 'lanrestart':
self["description"].setText(_("Restart your network connection and interfaces.\n" ) + self.oktext )
- if self["menulist"].getCurrent()[1] == 'enablewlan':
- self["description"].setText(_("Pressing OK enables the built in wireless LAN support of your Dreambox.\nWlan USB Sticks with Zydas ZD1211B and RAlink RT73 Chipset are supported.\nConnect your Wlan USB Stick to your Dreambox before pressing OK.\n\n" ) + self.reboottext )
if self["menulist"].getCurrent()[1] == 'openwizard':
self["description"].setText(_("Use the Networkwizard to configure your Network\n" ) + self.oktext )
-
- def updateStatusbar(self):
+ if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
+ self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
+
+ def updateStatusbar(self, data = None):
self["IFtext"].setText(_("Network:"))
self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
self["Statustext"].setText(_("Link:"))
- if self.iface == 'wlan0':
+ if self.iface == 'wlan0' or self.iface == 'ath0':
try:
- from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan, WlanList, wpaSupplicant
- w = Wlan(self.iface)
- stats = w.getStatus()
- if stats['BSSID'] == "00:00:00:00:00:00":
- self["statuspic"].setPixmapNum(1)
- else:
- self["statuspic"].setPixmapNum(0)
- self["statuspic"].show()
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
except:
self["statuspic"].setPixmapNum(1)
self["statuspic"].show()
+ else:
+ iStatus.getDataForInterface(self.iface,self.getInfoCB)
else:
- self.getLinkState(self.iface)
+ iNetwork.getLinkState(self.iface,self.dataAvail)
def doNothing(self):
pass
menu.append((_("Nameserver settings"), "dns"))
menu.append((_("Network test"), "test"))
menu.append((_("Restart network"), "lanrestart"))
-
+
self.extended = None
- self.extendedSetup = None
+ self.extendedSetup = None
for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
callFnc = p.__call__["ifaceSupported"](self.iface)
if callFnc is not None:
- menu.append((_("Scan Wireless Networks"), "scanwlan"))
- menu.append((_("Show WLAN Status"), "wlanstatus"))
- menu.append((_("Enable LAN"), "enablelan"))
- if callFnc is None and iNetwork.ifaces.has_key('wlan0') is False:
- menu.append((_("Enable WLAN"), "enablewlan"))
- if callFnc is None and iNetwork.ifaces.has_key('wlan0') is True:
- menu.append((_("Enable LAN"), "enablelan"))
-
- if os.path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
- menu.append((_("NetworkWizard"), "openwizard"));
+ 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"):
+ menu.append((_("Show WLAN Status"), "wlanstatus"))
+ else:
+ if p.__call__.has_key("menuEntryName"):
+ menuEntryName = p.__call__["menuEntryName"](self.iface)
+ else:
+ menuEntryName = _('Extended Setup...')
+ if p.__call__.has_key("menuEntryDescription"):
+ menuEntryDescription = p.__call__["menuEntryDescription"](self.iface)
+ else:
+ menuEntryDescription = _('Extended Networksetup Plugin...')
+ self.extendedSetup = ('extendedSetup',menuEntryDescription, self.extended)
+ menu.append((menuEntryName,self.extendedSetup))
+
+ if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
+ menu.append((_("NetworkWizard"), "openwizard"))
+
return menu
def AdapterSetupClosed(self, *ret):
- self.mainmenu = self.genMainMenu()
- self["menulist"].l.setList(self.mainmenu)
-
- def enableWlan(self, ret = False):
- if (ret == True):
- iNetwork.resetNetworkConfig('wlan')
- iNetwork.getInterfaces()
- if iNetwork.getAdapterAttribute('wlan0', 'up') is True:
- self.iface = 'wlan0'
- self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, 'wlan0')
- else:
- self.session.openWithCallback(self.restartDreambox, MessageBox, _("Your wireless LAN Adapter could not be started.\nDo you want to reboot your Dreambox to apply the new configuration?\n"))
-
- def enableLan(self, ret = False):
- if (ret == True):
- iNetwork.resetNetworkConfig('lan')
- iNetwork.getInterfaces()
- if iNetwork.getAdapterAttribute('eth0', 'up') is True:
- self.iface = 'eth0'
- self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, 'eth0')
+ if ret is not None and len(ret):
+ if ret[0] == 'ok' and (self.iface == 'wlan0' or self.iface == 'ath0') and iNetwork.getAdapterAttribute(self.iface, "up") is True:
+ try:
+ from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
+ from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ ifobj = Wireless(self.iface) # a Wireless NIC Object
+ self.wlanresponse = ifobj.getStatistics()
+ if self.wlanresponse[0] != 19:
+ self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
else:
- self.session.openWithCallback(self.restartDreambox, MessageBox, _("Your wired LAN Adapter could not be started.\nDo you want to reboot your Dreambox to apply the new configuration?\n"))
+ self.mainmenu = self.genMainMenu()
+ self["menulist"].l.setList(self.mainmenu)
+ iNetwork.getInterfaces(self.updateStatusbar)
+ else:
+ self.mainmenu = self.genMainMenu()
+ self["menulist"].l.setList(self.mainmenu)
+ iNetwork.getInterfaces(self.updateStatusbar)
+
+ def WlanStatusClosed(self, *ret):
+ if ret is not None and len(ret):
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ iStatus.stopWlanConsole()
+ self.mainmenu = self.genMainMenu()
+ self["menulist"].l.setList(self.mainmenu)
+ iNetwork.getInterfaces(self.updateStatusbar)
+
+ def WlanScanClosed(self,*ret):
+ if ret[0] is not None:
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
+ else:
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,None,None)
def restartLan(self, ret = False):
if (ret == True):
- iNetwork.restartNetwork()
+ iNetwork.restartNetwork(self.restartLanDataAvail)
+ self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while your network is restarting..."), type = MessageBox.TYPE_INFO, enable_input = False)
+
+ def restartLanDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
- def restartDreambox(self, ret = False):
- if (ret == True):
- TryQuitMainloop(self.session,2)
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.restartLanRef.close(True)
- def getLinkState(self,iface):
- iNetwork.getLinkState(iface,self.dataAvail)
+ def restartfinishedCB(self,data):
+ if data is True:
+ self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
def dataAvail(self,data):
self.output = data.strip()
result = self.output.split('\n')
- pattern = re.compile("Link detected: yes")
+ pattern = re_compile("Link detected: yes")
for item in result:
- if re.search(pattern, item):
- self["statuspic"].setPixmapNum(0)
- else:
+ if re_search(pattern, item):
self["statuspic"].setPixmapNum(1)
+ else:
+ self["statuspic"].setPixmapNum(0)
self["statuspic"].show()
def showErrorMessage(self):
self.session.open(MessageBox, self.errortext, type = MessageBox.TYPE_INFO,timeout = 10 )
-
+
+ def cleanup(self):
+ iNetwork.stopLinkStateConsole()
+ try:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ except ImportError:
+ pass
+ else:
+ iStatus.stopWlanConsole()
+
+ def getInfoCB(self,data,status):
+ print "im getInfoCB"
+ if data is not None:
+ if data is True:
+ if status is not None:
+ print "im getInfoCB status"
+ print "acesspoint",status[self.iface]["acesspoint"]
+ if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+ print "setting statuspix 1"
+ self["statuspic"].setPixmapNum(1)
+ else:
+ self["statuspic"].setPixmapNum(0)
+ print "setting statuspix 0"
+ self["statuspic"].show()
class NetworkAdapterTest(Screen):
def __init__(self, session,iface):
Screen.__init__(self, session)
self.iface = iface
+ self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
iNetwork.getInterfaces()
self.setLabels()
+ self.onClose.append(self.cleanup)
+ self.onHide.append(self.cleanup)
self["updown_actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
{
self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
{
- "red": self.close,
- "back": self.close,
+ "red": self.cancel,
+ "back": self.cancel,
}, -2)
self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
{
self.nextStepTimer = eTimer()
self.nextStepTimer.callback.append(self.nextStepTimerFire)
+ def cancel(self):
+ if self.oldInterfaceState is False:
+ iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
+ iNetwork.deactivateInterface(self.iface)
+ self.close()
+
def closeInfo(self):
self["shortcuts"].setEnabled(True)
self["infoshortcuts"].setEnabled(False)
def setActiveButton(self,button):
if button == 1:
self["EditSettingsButton"].setPixmapNum(0)
+ self["EditSettings_Text"].setForegroundColorNum(0)
self["NetworkInfo"].setPixmapNum(0)
- self["AdapterInfo"].setPixmapNum(1)
+ self["NetworkInfo_Text"].setForegroundColorNum(1)
+ self["AdapterInfo"].setPixmapNum(1) # active
+ self["AdapterInfo_Text"].setForegroundColorNum(2) # active
if button == 2:
+ self["AdapterInfo_Text"].setForegroundColorNum(1)
self["AdapterInfo"].setPixmapNum(0)
self["DhcpInfo"].setPixmapNum(0)
- self["NetworkInfo"].setPixmapNum(1)
+ self["DhcpInfo_Text"].setForegroundColorNum(1)
+ self["NetworkInfo"].setPixmapNum(1) # active
+ self["NetworkInfo_Text"].setForegroundColorNum(2) # active
if button == 3:
self["NetworkInfo"].setPixmapNum(0)
+ self["NetworkInfo_Text"].setForegroundColorNum(1)
self["IPInfo"].setPixmapNum(0)
- self["DhcpInfo"].setPixmapNum(1)
+ self["IPInfo_Text"].setForegroundColorNum(1)
+ self["DhcpInfo"].setPixmapNum(1) # active
+ self["DhcpInfo_Text"].setForegroundColorNum(2) # active
if button == 4:
self["DhcpInfo"].setPixmapNum(0)
+ self["DhcpInfo_Text"].setForegroundColorNum(1)
self["DNSInfo"].setPixmapNum(0)
- self["IPInfo"].setPixmapNum(1)
+ self["DNSInfo_Text"].setForegroundColorNum(1)
+ self["IPInfo"].setPixmapNum(1) # active
+ self["IPInfo_Text"].setForegroundColorNum(2) # active
if button == 5:
self["IPInfo"].setPixmapNum(0)
+ self["IPInfo_Text"].setForegroundColorNum(1)
self["EditSettingsButton"].setPixmapNum(0)
- self["DNSInfo"].setPixmapNum(1)
+ self["EditSettings_Text"].setForegroundColorNum(0)
+ self["DNSInfo"].setPixmapNum(1) # active
+ self["DNSInfo_Text"].setForegroundColorNum(2) # active
if button == 6:
self["DNSInfo"].setPixmapNum(0)
- self["EditSettingsButton"].setPixmapNum(1)
+ self["DNSInfo_Text"].setForegroundColorNum(1)
+ self["EditSettingsButton"].setPixmapNum(1) # active
+ self["EditSettings_Text"].setForegroundColorNum(2) # active
self["AdapterInfo"].setPixmapNum(0)
-
+ self["AdapterInfo_Text"].setForegroundColorNum(1)
+
def runTest(self):
- self.nextstep += 1
+ next = self.nextstep
if next == 0:
self.doStep1()
elif next == 1:
self.doStep5()
elif next == 5:
self.doStep6()
+ self.nextstep += 1
def doStep1(self):
self.steptimer = True
self.nextStepTimer.start(3000)
+ self["ButtonYellow_Check"].show()
+ self["ButtonYellowtext"].show()
def doStep2(self):
self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
def doStep3(self):
self["Networktext"].setForegroundColorNum(1)
+ self["Network"].setText(_("Please wait..."))
self.getLinkState(self.iface)
self["NetworkInfo_Text"].setForegroundColorNum(1)
self.steptimer = True
def doStep5(self):
self["IPtext"].setForegroundColorNum(1)
- ret = iNetwork.checkNetworkState()
- if ret == True:
- self["IP"].setForegroundColorNum(2)
- self["IP"].setText(_("confirmed"))
- self["IPInfo_Check"].setPixmapNum(0)
- else:
- self["IP"].setForegroundColorNum(1)
- self["IP"].setText(_("unconfirmed"))
- self["IPInfo_Check"].setPixmapNum(1)
- self["IPInfo_Check"].show()
- self["IPInfo_Text"].setForegroundColorNum(1)
- self.steptimer = True
- self.nextStepTimer.start(3000)
+ self["IP"].setText(_("Please wait..."))
+ iNetwork.checkNetworkState(self.NetworkStatedataAvail)
def doStep6(self):
self.steptimer = False
self.nextStepTimer.stop()
self["DNStext"].setForegroundColorNum(1)
- ret = iNetwork.checkDNSLookup()
- if ret == True:
- self["DNS"].setForegroundColorNum(2)
- self["DNS"].setText(_("confirmed"))
- self["DNSInfo_Check"].setPixmapNum(0)
- else:
- self["DNS"].setForegroundColorNum(1)
- self["DNS"].setText(_("unconfirmed"))
- self["DNSInfo_Check"].setPixmapNum(1)
- self["DNSInfo_Check"].show()
- self["DNSInfo_Text"].setForegroundColorNum(1)
-
- self["EditSettings_Text"].show()
- self["EditSettingsButton"].setPixmapNum(1)
- self["EditSettingsButton"].show()
- self["ButtonYellow_Check"].setPixmapNum(1)
- self["ButtonGreentext"].setText(_("Restart test"))
- self["ButtonGreen_Check"].setPixmapNum(0)
- self["shortcutsgreen"].setEnabled(False)
- self["shortcutsgreen_restart"].setEnabled(True)
- self["shortcutsyellow"].setEnabled(False)
- self["updown_actions"].setEnabled(True)
- self.activebutton = 6
+ self["DNS"].setText(_("Please wait..."))
+ iNetwork.checkDNSLookup(self.DNSLookupdataAvail)
def KeyGreen(self):
self["shortcutsgreen"].setEnabled(False)
self["EditSettingsButton"].hide()
self["InfoText"].hide()
self["InfoTextBorder"].hide()
+ self["ButtonYellow_Check"].hide()
+ self["ButtonYellowtext"].hide()
def setLabels(self):
self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))
self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info"))
self["AdapterInfo_OK"] = Pixmap()
- if self.iface == 'wlan0':
+ if self.iface == 'wlan0' or self.iface == 'ath0':
self["Networktext"] = MultiColorLabel(_("Wireless Network"))
else:
self["Networktext"] = MultiColorLabel(_("Local Network"))
self["DNSInfo_Text"] = MultiColorLabel(_("Show Info"))
self["DNSInfo_Check"] = MultiPixmap()
- self["EditSettings_Text"] = Label(_("Edit settings"))
+ self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
self["EditSettingsButton"] = MultiPixmap()
self["ButtonRedtext"] = Label(_("Close"))
self["InfoText"] = Label()
def getLinkState(self,iface):
- if iface == 'wlan0':
+ if iface == 'wlan0' or iface == 'ath0':
try:
- from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
- w = Wlan(iface)
- stats = w.getStatus()
- if stats['BSSID'] == "00:00:00:00:00:00":
- self["Network"].setForegroundColorNum(1)
- self["Network"].setText(_("disconnected"))
- self["NetworkInfo_Check"].setPixmapNum(1)
- self["NetworkInfo_Check"].show()
- else:
- self["Network"].setForegroundColorNum(2)
- self["Network"].setText(_("connected"))
- self["NetworkInfo_Check"].setPixmapNum(0)
- self["NetworkInfo_Check"].show()
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
except:
self["Network"].setForegroundColorNum(1)
self["Network"].setText(_("disconnected"))
self["NetworkInfo_Check"].setPixmapNum(1)
self["NetworkInfo_Check"].show()
+ else:
+ iStatus.getDataForInterface(self.iface,self.getInfoCB)
else:
- iNetwork.getLinkState(iface,self.dataAvail)
+ iNetwork.getLinkState(iface,self.LinkStatedataAvail)
- def dataAvail(self,data):
+ def LinkStatedataAvail(self,data):
self.output = data.strip()
result = self.output.split('\n')
- pattern = re.compile("Link detected: yes")
+ pattern = re_compile("Link detected: yes")
for item in result:
- if re.search(pattern, item):
+ if re_search(pattern, item):
self["Network"].setForegroundColorNum(2)
self["Network"].setText(_("connected"))
self["NetworkInfo_Check"].setPixmapNum(0)
self["NetworkInfo_Check"].setPixmapNum(1)
self["NetworkInfo_Check"].show()
+ def NetworkStatedataAvail(self,data):
+ if data <= 2:
+ self["IP"].setForegroundColorNum(2)
+ self["IP"].setText(_("confirmed"))
+ self["IPInfo_Check"].setPixmapNum(0)
+ else:
+ self["IP"].setForegroundColorNum(1)
+ self["IP"].setText(_("unconfirmed"))
+ self["IPInfo_Check"].setPixmapNum(1)
+ self["IPInfo_Check"].show()
+ self["IPInfo_Text"].setForegroundColorNum(1)
+ self.steptimer = True
+ self.nextStepTimer.start(3000)
+
+ def DNSLookupdataAvail(self,data):
+ if data <= 2:
+ self["DNS"].setForegroundColorNum(2)
+ self["DNS"].setText(_("confirmed"))
+ self["DNSInfo_Check"].setPixmapNum(0)
+ else:
+ self["DNS"].setForegroundColorNum(1)
+ self["DNS"].setText(_("unconfirmed"))
+ self["DNSInfo_Check"].setPixmapNum(1)
+ self["DNSInfo_Check"].show()
+ self["DNSInfo_Text"].setForegroundColorNum(1)
+ self["EditSettings_Text"].show()
+ self["EditSettingsButton"].setPixmapNum(1)
+ self["EditSettings_Text"].setForegroundColorNum(2) # active
+ self["EditSettingsButton"].show()
+ self["ButtonYellow_Check"].setPixmapNum(1)
+ self["ButtonGreentext"].setText(_("Restart test"))
+ self["ButtonGreen_Check"].setPixmapNum(0)
+ self["shortcutsgreen"].setEnabled(False)
+ self["shortcutsgreen_restart"].setEnabled(True)
+ self["shortcutsyellow"].setEnabled(False)
+ self["updown_actions"].setEnabled(True)
+ self.activebutton = 6
+ def getInfoCB(self,data,status):
+ if data is not None:
+ if data is True:
+ if status is not None:
+ if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+ self["Network"].setForegroundColorNum(1)
+ self["Network"].setText(_("disconnected"))
+ self["NetworkInfo_Check"].setPixmapNum(1)
+ self["NetworkInfo_Check"].show()
+ else:
+ self["Network"].setForegroundColorNum(2)
+ self["Network"].setText(_("connected"))
+ self["NetworkInfo_Check"].setPixmapNum(0)
+ self["NetworkInfo_Check"].show()
+
+ def cleanup(self):
+ iNetwork.stopLinkStateConsole()
+ iNetwork.stopDNSConsole()
+ try:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ except ImportError:
+ pass
+ else:
+ iStatus.stopWlanConsole()
\ No newline at end of file
git.cweiske.de / enigma2.git / blobdiff