from Screen import Screen
-from Components.ActionMap import NumberActionMap
-from Components.ConfigList import ConfigList
-from Components.config import config
-from Components.config import getConfigListEntry
+from Screens.MessageBox import MessageBox
+from Screens.InputBox import InputBox
+from Screens.Standby import *
+from Screens.VirtualKeyBoard import VirtualKeyBoard
+from Screens.HelpMenu import HelpableScreen
from Components.Network import iNetwork
-from Components.Label import Label
-
-class NetworkSetup(Screen):
- def __init__(self, session):
- Screen.__init__(self, session)
-
- self["actions"] = NumberActionMap(["SetupActions"],
- {
- "ok": self.keySave,
- "cancel": self.keyCancel,
- "left": self.keyLeft,
- "right": self.keyRight,
- "1": self.keyNumberGlobal,
- "2": self.keyNumberGlobal,
- "3": self.keyNumberGlobal,
- "4": self.keyNumberGlobal,
- "5": self.keyNumberGlobal,
- "6": self.keyNumberGlobal,
- "7": self.keyNumberGlobal,
- "8": self.keyNumberGlobal,
- "9": self.keyNumberGlobal,
- "0": self.keyNumberGlobal
- }, -1)
-
- self.list = []
- self["config"] = ConfigList(self.list)
- self.createSetup()
-
- self["introduction"] = Label("Press OK to activate the settings.")
-
- def createSetup(self):
- self.list = []
-
- self.list.append(getConfigListEntry("Use DHCP", config.network.dhcp))
- if (config.network.dhcp.value == 0):
- self.list.append(getConfigListEntry(_('IP Address'), config.network.ip))
- self.list.append(getConfigListEntry(_('Netmask'), config.network.netmask))
- self.list.append(getConfigListEntry(_('Gateway'), config.network.gateway))
- self.list.append(getConfigListEntry(_('Nameserver'), config.network.dns))
-
- self["config"].list = self.list
- self["config"].l.setList(self.list)
-
- def newConfig(self):
- print self["config"].getCurrent()
- if self["config"].getCurrent()[0] == "Use DHCP":
- self.createSetup()
-
- def keyLeft(self):
- self["config"].handleKey(config.key["prevElement"])
- self.newConfig()
-
- def keyRight(self):
- self["config"].handleKey(config.key["nextElement"])
- self.newConfig()
-
- def keyNumberGlobal(self, number):
- print "You pressed number " + str(number)
- if (self["config"].getCurrent()[1].parent.enabled == True):
- self["config"].handleKey(config.key[str(number)])
-
- def keySave(self):
- #for x in self["config"].list:
- #x[1].save()
-
- iNetwork.writeNetworkConfig()
- iNetwork.activateNetworkConfig()
- self.close()
-
- def keyCancel(self):
- for x in self["config"].list:
- x[1].cancel()
- iNetwork.loadNetworkConfig()
- self.close()
\ No newline at end of file
+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.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, 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)
+ 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["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["list"].getCurrent()
+ if selection is not None:
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0])
+
+ def AdapterSetupClosed(self, *ret):
+ if len(self.adapters) == 1:
+ self.close()
+ 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 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)
+ 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["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.cancel, _("exit nameserver configuration")),
+ "ok": (self.ok, _("activate current configuration")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.cancel, _("exit nameserver configuration")),
+ "green": (self.add, _("add a nameserver entry")),
+ "yellow": (self.remove, _("remove a nameserver entry")),
+ })
+
+
+ self.list = []
+ ConfigListScreen.__init__(self, self.list)
+ self.createSetup()
+
+ def createConfig(self):
+ self.nameservers = iNetwork.getNameserverList()
+ self.nameserverEntries = []
+
+ for nameserver in self.nameservers:
+ self.nameserverEntries.append(NoSave(ConfigIP(default=nameserver)))
+
+ def createSetup(self):
+ self.list = []
+
+ for i in range(len(self.nameserverEntries)):
+ self.list.append(getConfigListEntry(_("Nameserver %d") % (i + 1), self.nameserverEntries[i]))
+
+ self["config"].list = self.list
+ self["config"].l.setList(self.list)
+
+ def ok(self):
+ iNetwork.clearNameservers()
+ for nameserver in self.nameserverEntries:
+ iNetwork.addNameserver(nameserver.value)
+ iNetwork.writeNameserverConfig()
+ self.close()
+
+ def run(self):
+ self.ok()
+
+ def cancel(self):
+ iNetwork.clearNameservers()
+ print "backup-list:", self.backupNameserverList
+ for nameserver in self.backupNameserverList:
+ iNetwork.addNameserver(nameserver)
+ self.close()
+
+ def add(self):
+ iNetwork.addNameserver([0,0,0,0])
+ self.createConfig()
+ self.createSetup()
+
+ def remove(self):
+ print "currentIndex:", self["config"].getCurrentIndex()
+
+ index = self["config"].getCurrentIndex()
+ if index < len(self.nameservers):
+ iNetwork.removeNameserver(self.nameservers[index])
+ self.createConfig()
+ self.createSetup()
+
+class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
+ def __init__(self, session, iface,essid=None, aplist=None):
+ Screen.__init__(self, session)
+ HelpableScreen.__init__(self)
+ self.session = session
+ self.iface = iface
+ self.essid = essid
+ self.aplist = aplist
+ self.extended = None
+ self.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.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,
+ }, -2)
+
+
+ self.list = []
+ ConfigListScreen.__init__(self, self.list,session = self.session)
+ self.createSetup()
+ self.onLayoutFinish.append(self.layoutFinished)
+ self.onClose.append(self.cleanup)
+
+ self["DNS1text"] = Label(_("Primary DNS"))
+ self["DNS2text"] = Label(_("Secondary DNS"))
+ self["DNS1"] = Label()
+ self["DNS2"] = Label()
+
+ self["introduction"] = Label(_("Current settings:"))
+
+ self["IPtext"] = Label(_("IP Address"))
+ self["Netmasktext"] = Label(_("Netmask"))
+ self["Gatewaytext"] = Label(_("Gateway"))
+
+ self["IP"] = Label()
+ self["Mask"] = Label()
+ self["Gateway"] = Label()
+
+ self["BottomBG"] = Pixmap()
+ self["Adaptertext"] = Label(_("Network:"))
+ self["Adapter"] = Label()
+ self["introduction2"] = Label(_("Press OK to activate the settings."))
+ self["ButtonRed"] = Pixmap()
+ self["ButtonRedtext"] = Label(_("Close"))
+ self["ButtonBlue"] = Pixmap()
+ self["ButtonBluetext"] = Label(_("Edit DNS"))
+ self["ButtonGreen"] = Pixmap()
+ self["VKeyIcon"] = Pixmap()
+ self["HelpWindow"] = Pixmap()
+
+ def layoutFinished(self):
+ self["DNS1"].setText(self.primaryDNS.getText())
+ self["DNS2"].setText(self.secondaryDNS.getText())
+ if self.ipConfigEntry.getText() is not None:
+ if self.ipConfigEntry.getText() == "0.0.0.0":
+ self["IP"].setText(_("N/A"))
+ else:
+ self["IP"].setText(self.ipConfigEntry.getText())
+ else:
+ self["IP"].setText(_("N/A"))
+ if self.netmaskConfigEntry.getText() is not None:
+ if self.netmaskConfigEntry.getText() == "0.0.0.0":
+ self["Mask"].setText(_("N/A"))
+ else:
+ self["Mask"].setText(self.netmaskConfigEntry.getText())
+ else:
+ 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.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.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):
+ 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.newConfig()
+
+ def keyRight(self):
+ ConfigListScreen.keyRight(self)
+ self.newConfig()
+
+ def selectionChanged(self):
+ current = self["config"].getCurrent()
+ if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+ helpwindowpos = self["HelpWindow"].getPosition()
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+ self["ButtonGreen"].show()
+ self["VKeyIcon"].show()
+ self["VirtualKB"].setEnabled(True)
+ elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+ helpwindowpos = self["HelpWindow"].getPosition()
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+ self["ButtonGreen"].show()
+ self["VKeyIcon"].show()
+ self["VirtualKB"].setEnabled(True)
+ else:
+ self["ButtonGreen"].hide()
+ self["VKeyIcon"].hide()
+ self["VirtualKB"].setEnabled(False)
+
+ def ok(self):
+ current = self["config"].getCurrent()
+ if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+ elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+ self.session.openWithCallback(self.applyConfig, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) )
+
+ def applyConfig(self, ret = False):
+ if (ret == True):
+ iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
+ iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
+ iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
+ iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
+ if self.hasGatewayConfigEntry.value:
+ iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
+ else:
+ iNetwork.removeAdapterAttribute(self.iface, "gateway")
+ if self.extended is not None and self.configStrings is not None:
+ iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
+ self.ws.writeConfig()
+ if self.activateInterfaceEntry.value is False:
+ iNetwork.deactivateInterface(self.iface)
+ iNetwork.writeNetworkConfig()
+ iNetwork.restartNetwork(self.applyConfigDataAvail)
+ self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait while activating your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+ else:
+ self.cancel()
+
+ def applyConfigDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.applyConfigRef.close(True)
+
+ def applyConfigfinishedCB(self,data):
+ if data is True:
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("Your network configuration has been activated.\nA second configured interface has been found.\n\nDo you want to disable the second networkinterface?"), default = True)
+ else:
+ if self.finished_cb:
+ self.session.openWithCallback(self.finished_cb, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+ else:
+ self.session.openWithCallback(self.ConfigfinishedCB, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+
+ def secondIfaceFoundCB(self,data):
+ if data is False:
+ self.close('ok')
+ else:
+ configuredInterfaces = configuredNetworkAdapters
+ for interface in configuredInterfaces:
+ if interface == self.iface:
+ continue
+ iNetwork.setAdapterAttribute(interface, "up", False)
+ iNetwork.deactivateInterface(interface)
+ self.applyConfig(True)
+
+ def ConfigfinishedCB(self,data):
+ if data is True:
+ self.close('ok')
+
+ def cancel(self):
+ iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
+ self.activateInterfaceEntry.value = self.oldInterfaceState
+ if self.activateInterfaceEntry.value is False:
+ iNetwork.deactivateInterface(self.iface)
+ iNetwork.getInterfaces()
+ self.close('cancel')
+
+ 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, HelpableScreen):
+ def __init__(self, session,iface):
+ Screen.__init__(self, session)
+ 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["IFtext"] = Label()
+ self["IF"] = Label()
+ self["BottomBG"] = Label()
+ self["Statustext"] = Label()
+ self["statuspic"] = MultiPixmap()
+ self["statuspic"].hide()
+ self["BottomBG"] = Pixmap()
+ self["ButtonRed"] = Pixmap()
+ self["ButtonRedtext"] = Label(_("Close"))
+
+ self.oktext = _("Press OK on your remote control to continue.")
+ self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
+ self.errortext = _("No working wireless interface found.\n Please verify that you have attached a compatible WLAN device or enable you local network interface.")
+
+ self["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,
+ "back": self.close,
+ "up": self.up,
+ "down": self.down,
+ "red": self.close,
+ "left": self.left,
+ "right": self.right,
+ }, -2)
+
+ iNetwork.getInterfaces(self.updateStatusbar)
+ self.onLayoutFinish.append(self.layoutFinished)
+ self.onClose.append(self.cleanup)
+ self.onHide.append(self.cleanup)
+
+ def ok(self):
+ if self["menulist"].getCurrent()[1] == 'edit':
+ 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:
+ 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.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':
+ 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:
+ 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':
+ 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()
+ 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)
+ 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 down(self):
+ self["menulist"].down()
+ self.loadDescription()
+
+ def left(self):
+ self["menulist"].pageUp()
+ self.loadDescription()
+
+ def right(self):
+ self["menulist"].pageDown()
+ self.loadDescription()
+
+ def layoutFinished(self):
+ idx = 0
+ self["menulist"].moveToIndex(idx)
+ 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] == '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 WLAN USB Stick\n" ) + self.oktext )
+ if self["menulist"].getCurrent()[1] == 'wlanstatus':
+ self["description"].setText(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext )
+ if self["menulist"].getCurrent()[1] == 'lanrestart':
+ self["description"].setText(_("Restart your network connection and interfaces.\n" ) + self.oktext )
+ if self["menulist"].getCurrent()[1] == 'openwizard':
+ self["description"].setText(_("Use the Networkwizard to configure your Network\n" ) + self.oktext )
+ if self["menulist"].getCurrent()[1][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' or self.iface == 'ath0':
+ try:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ except:
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
+ else:
+ iStatus.getDataForInterface(self.iface,self.getInfoCB)
+ else:
+ iNetwork.getLinkState(self.iface,self.dataAvail)
+
+ def doNothing(self):
+ pass
+
+ def genMainMenu(self):
+ menu = []
+ menu.append((_("Adapter settings"), "edit"))
+ menu.append((_("Nameserver settings"), "dns"))
+ menu.append((_("Network test"), "test"))
+ menu.append((_("Restart network"), "lanrestart"))
+
+ self.extended = None
+ self.extendedSetup = None
+ for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
+ callFnc = p.__call__["ifaceSupported"](self.iface)
+ if callFnc is not None:
+ 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):
+ 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.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(self.restartLanDataAvail)
+ self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while your network is restarting..."), type = MessageBox.TYPE_INFO, enable_input = False)
+
+ def restartLanDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.restartLanRef.close(True)
+
+ def restartfinishedCB(self,data):
+ if data is True:
+ self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
+
+ def dataAvail(self,data):
+ self.output = data.strip()
+ result = self.output.split('\n')
+ pattern = re_compile("Link detected: yes")
+ for item in result:
+ if re_search(pattern, item):
+ self["statuspic"].setPixmapNum(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):
+ 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["statuspic"].setPixmapNum(1)
+ else:
+ self["statuspic"].setPixmapNum(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"],
+ {
+ "ok": self.KeyOK,
+ "blue": self.KeyOK,
+ "up": lambda: self.updownhandler('up'),
+ "down": lambda: self.updownhandler('down'),
+
+ }, -2)
+
+ self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
+ {
+ "red": self.cancel,
+ "back": self.cancel,
+ }, -2)
+ self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
+ {
+ "red": self.closeInfo,
+ "back": self.closeInfo,
+ }, -2)
+ self["shortcutsgreen"] = ActionMap(["ShortcutActions"],
+ {
+ "green": self.KeyGreen,
+ }, -2)
+ self["shortcutsgreen_restart"] = ActionMap(["ShortcutActions"],
+ {
+ "green": self.KeyGreenRestart,
+ }, -2)
+ self["shortcutsyellow"] = ActionMap(["ShortcutActions"],
+ {
+ "yellow": self.KeyYellow,
+ }, -2)
+
+ self["shortcutsgreen_restart"].setEnabled(False)
+ self["updown_actions"].setEnabled(False)
+ self["infoshortcuts"].setEnabled(False)
+ self.onClose.append(self.delTimer)
+ self.onLayoutFinish.append(self.layoutFinished)
+ self.steptimer = False
+ self.nextstep = 0
+ self.activebutton = 0
+ self.nextStepTimer = eTimer()
+ self.nextStepTimer.callback.append(self.nextStepTimerFire)
+
+ def cancel(self):
+ if self.oldInterfaceState is False:
+ iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
+ iNetwork.deactivateInterface(self.iface)
+ self.close()
+
+ def closeInfo(self):
+ self["shortcuts"].setEnabled(True)
+ self["infoshortcuts"].setEnabled(False)
+ self["InfoText"].hide()
+ self["InfoTextBorder"].hide()
+ self["ButtonRedtext"].setText(_("Close"))
+
+ def delTimer(self):
+ del self.steptimer
+ del self.nextStepTimer
+
+ def nextStepTimerFire(self):
+ self.nextStepTimer.stop()
+ self.steptimer = False
+ self.runTest()
+
+ def updownhandler(self,direction):
+ if direction == 'up':
+ if self.activebutton >=2:
+ self.activebutton -= 1
+ else:
+ self.activebutton = 6
+ self.setActiveButton(self.activebutton)
+ if direction == 'down':
+ if self.activebutton <=5:
+ self.activebutton += 1
+ else:
+ self.activebutton = 1
+ self.setActiveButton(self.activebutton)
+
+ def setActiveButton(self,button):
+ if button == 1:
+ self["EditSettingsButton"].setPixmapNum(0)
+ self["EditSettings_Text"].setForegroundColorNum(0)
+ self["NetworkInfo"].setPixmapNum(0)
+ 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["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["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["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["EditSettings_Text"].setForegroundColorNum(0)
+ self["DNSInfo"].setPixmapNum(1) # active
+ self["DNSInfo_Text"].setForegroundColorNum(2) # active
+ if button == 6:
+ self["DNSInfo"].setPixmapNum(0)
+ 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):
+ next = self.nextstep
+ if next == 0:
+ self.doStep1()
+ elif next == 1:
+ self.doStep2()
+ elif next == 2:
+ self.doStep3()
+ elif next == 3:
+ self.doStep4()
+ elif next == 4:
+ 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))
+ self["Adapter"].setForegroundColorNum(2)
+ self["Adaptertext"].setForegroundColorNum(1)
+ self["AdapterInfo_Text"].setForegroundColorNum(1)
+ self["AdapterInfo_OK"].show()
+ self.steptimer = True
+ self.nextStepTimer.start(3000)
+
+ def doStep3(self):
+ self["Networktext"].setForegroundColorNum(1)
+ self["Network"].setText(_("Please wait..."))
+ self.getLinkState(self.iface)
+ self["NetworkInfo_Text"].setForegroundColorNum(1)
+ self.steptimer = True
+ self.nextStepTimer.start(3000)
+
+ def doStep4(self):
+ self["Dhcptext"].setForegroundColorNum(1)
+ if iNetwork.getAdapterAttribute(self.iface, 'dhcp') is True:
+ self["Dhcp"].setForegroundColorNum(2)
+ self["Dhcp"].setText(_("enabled"))
+ self["DhcpInfo_Check"].setPixmapNum(0)
+ else:
+ self["Dhcp"].setForegroundColorNum(1)
+ self["Dhcp"].setText(_("disabled"))
+ self["DhcpInfo_Check"].setPixmapNum(1)
+ self["DhcpInfo_Check"].show()
+ self["DhcpInfo_Text"].setForegroundColorNum(1)
+ self.steptimer = True
+ self.nextStepTimer.start(3000)
+
+ def doStep5(self):
+ self["IPtext"].setForegroundColorNum(1)
+ self["IP"].setText(_("Please wait..."))
+ iNetwork.checkNetworkState(self.NetworkStatedataAvail)
+
+ def doStep6(self):
+ self.steptimer = False
+ self.nextStepTimer.stop()
+ self["DNStext"].setForegroundColorNum(1)
+ self["DNS"].setText(_("Please wait..."))
+ iNetwork.checkDNSLookup(self.DNSLookupdataAvail)
+
+ def KeyGreen(self):
+ self["shortcutsgreen"].setEnabled(False)
+ self["shortcutsyellow"].setEnabled(True)
+ self["updown_actions"].setEnabled(False)
+ self["ButtonYellow_Check"].setPixmapNum(0)
+ self["ButtonGreen_Check"].setPixmapNum(1)
+ self.steptimer = True
+ self.nextStepTimer.start(1000)
+
+ def KeyGreenRestart(self):
+ self.nextstep = 0
+ self.layoutFinished()
+ self["Adapter"].setText((""))
+ self["Network"].setText((""))
+ self["Dhcp"].setText((""))
+ self["IP"].setText((""))
+ self["DNS"].setText((""))
+ self["AdapterInfo_Text"].setForegroundColorNum(0)
+ self["NetworkInfo_Text"].setForegroundColorNum(0)
+ self["DhcpInfo_Text"].setForegroundColorNum(0)
+ self["IPInfo_Text"].setForegroundColorNum(0)
+ self["DNSInfo_Text"].setForegroundColorNum(0)
+ self["shortcutsgreen_restart"].setEnabled(False)
+ self["shortcutsgreen"].setEnabled(False)
+ self["shortcutsyellow"].setEnabled(True)
+ self["updown_actions"].setEnabled(False)
+ self["ButtonYellow_Check"].setPixmapNum(0)
+ self["ButtonGreen_Check"].setPixmapNum(1)
+ self.steptimer = True
+ self.nextStepTimer.start(1000)
+
+ def KeyOK(self):
+ self["infoshortcuts"].setEnabled(True)
+ self["shortcuts"].setEnabled(False)
+ if self.activebutton == 1: # Adapter Check
+ self["InfoText"].setText(_("This test detects your configured LAN-Adapter."))
+ self["InfoTextBorder"].show()
+ self["InfoText"].show()
+ self["ButtonRedtext"].setText(_("Back"))
+ if self.activebutton == 2: #LAN Check
+ self["InfoText"].setText(_("This test checks whether a network cable is connected to your LAN-Adapter.\nIf you get a \"disconnected\" message:\n- verify that a network cable is attached\n- verify that the cable is not broken"))
+ self["InfoTextBorder"].show()
+ self["InfoText"].show()
+ self["ButtonRedtext"].setText(_("Back"))
+ if self.activebutton == 3: #DHCP Check
+ self["InfoText"].setText(_("This test checks whether your LAN Adapter is set up for automatic IP Address configuration with DHCP.\nIf you get a \"disabled\" message:\n - then your LAN Adapter is configured for manual IP Setup\n- verify thay you have entered correct IP informations in the AdapterSetup dialog.\nIf you get an \"enabeld\" message:\n-verify that you have a configured and working DHCP Server in your network."))
+ self["InfoTextBorder"].show()
+ self["InfoText"].show()
+ self["ButtonRedtext"].setText(_("Back"))
+ if self.activebutton == 4: # IP Check
+ self["InfoText"].setText(_("This test checks whether a valid IP Address is found for your LAN Adapter.\nIf you get a \"unconfirmed\" message:\n- no valid IP Address was found\n- please check your DHCP, cabling and adapter setup"))
+ self["InfoTextBorder"].show()
+ self["InfoText"].show()
+ self["ButtonRedtext"].setText(_("Back"))
+ if self.activebutton == 5: # DNS Check
+ self["InfoText"].setText(_("This test checks for configured Nameservers.\nIf you get a \"unconfirmed\" message:\n- please check your DHCP, cabling and Adapter setup\n- if you configured your Nameservers manually please verify your entries in the \"Nameserver\" Configuration"))
+ self["InfoTextBorder"].show()
+ self["InfoText"].show()
+ self["ButtonRedtext"].setText(_("Back"))
+ if self.activebutton == 6: # Edit Settings
+ self.session.open(AdapterSetup,self.iface)
+
+ def KeyYellow(self):
+ self.nextstep = 0
+ self["shortcutsgreen_restart"].setEnabled(True)
+ self["shortcutsgreen"].setEnabled(False)
+ self["shortcutsyellow"].setEnabled(False)
+ self["ButtonGreentext"].setText(_("Restart test"))
+ self["ButtonYellow_Check"].setPixmapNum(1)
+ self["ButtonGreen_Check"].setPixmapNum(0)
+ self.steptimer = False
+ self.nextStepTimer.stop()
+
+ def layoutFinished(self):
+ self["shortcutsyellow"].setEnabled(False)
+ self["AdapterInfo_OK"].hide()
+ self["NetworkInfo_Check"].hide()
+ self["DhcpInfo_Check"].hide()
+ self["IPInfo_Check"].hide()
+ self["DNSInfo_Check"].hide()
+ self["EditSettings_Text"].hide()
+ 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["Adapter"] = MultiColorLabel()
+ self["AdapterInfo"] = MultiPixmap()
+ self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["AdapterInfo_OK"] = Pixmap()
+
+ if self.iface == 'wlan0' or self.iface == 'ath0':
+ self["Networktext"] = MultiColorLabel(_("Wireless Network"))
+ else:
+ self["Networktext"] = MultiColorLabel(_("Local Network"))
+
+ self["Network"] = MultiColorLabel()
+ self["NetworkInfo"] = MultiPixmap()
+ self["NetworkInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["NetworkInfo_Check"] = MultiPixmap()
+
+ self["Dhcptext"] = MultiColorLabel(_("DHCP"))
+ self["Dhcp"] = MultiColorLabel()
+ self["DhcpInfo"] = MultiPixmap()
+ self["DhcpInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["DhcpInfo_Check"] = MultiPixmap()
+
+ self["IPtext"] = MultiColorLabel(_("IP Address"))
+ self["IP"] = MultiColorLabel()
+ self["IPInfo"] = MultiPixmap()
+ self["IPInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["IPInfo_Check"] = MultiPixmap()
+
+ self["DNStext"] = MultiColorLabel(_("Nameserver"))
+ self["DNS"] = MultiColorLabel()
+ self["DNSInfo"] = MultiPixmap()
+ self["DNSInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["DNSInfo_Check"] = MultiPixmap()
+
+ self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
+ self["EditSettingsButton"] = MultiPixmap()
+
+ self["ButtonRedtext"] = Label(_("Close"))
+ self["ButtonRed"] = Pixmap()
+
+ self["ButtonGreentext"] = Label(_("Start test"))
+ self["ButtonGreen_Check"] = MultiPixmap()
+
+ self["ButtonYellowtext"] = Label(_("Stop test"))
+ self["ButtonYellow_Check"] = MultiPixmap()
+
+ self["InfoTextBorder"] = Pixmap()
+ self["InfoText"] = Label()
+
+ def getLinkState(self,iface):
+ if iface == 'wlan0' or iface == 'ath0':
+ try:
+ 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.LinkStatedataAvail)
+
+ def LinkStatedataAvail(self,data):
+ self.output = data.strip()
+ result = self.output.split('\n')
+ pattern = re_compile("Link detected: yes")
+ for item in result:
+ if re_search(pattern, item):
+ self["Network"].setForegroundColorNum(2)
+ self["Network"].setText(_("connected"))
+ self["NetworkInfo_Check"].setPixmapNum(0)
+ else:
+ self["Network"].setForegroundColorNum(1)
+ self["Network"].setText(_("disconnected"))
+ 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