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
-from Components.Pixmap import Pixmap
-from Tools.LoadPixmap import LoadPixmap
+from Components.Sources.StaticText import StaticText
+from Components.Sources.Boolean import Boolean
+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, 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_CURRENT_SKIN
+from Tools.LoadPixmap import LoadPixmap
from Plugins.Plugin import PluginDescriptor
-#from Plugins.SystemPlugins.WirelessLan.plugin import *
-#from Plugins.SystemPlugins.WirelessLan.Wlan import *
-from enigma import eTimer, eConsoleAppContainer,gRGB
-import time, os, re
-
-
-Black = "#000000"
-Grey = "#8c8c93"
-Green = "1cff1c"
-nextstep = None
-activebutton = None
-
-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),
+ MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name)
+ ]
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ if default is True:
+ png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
+ if default is False:
+ png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
+ res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png))
+ if active is True:
+ png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
+ if active is False:
+ png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
+ res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2))
+ return res
+
+
+class NetworkAdapterSelection(Screen,HelpableScreen):
def __init__(self, session):
Screen.__init__(self, session)
-
+ HelpableScreen.__init__(self)
+
+ self.wlan_errortext = _("No working wireless network adapter found.\nPlease verify that you have attached a compatible WLAN device and your network is configured correctly.")
+ self.lan_errortext = _("No working local network adapter found.\nPlease verify that you have attached a network cable and your network is configured correctly.")
+ self.oktext = _("Press OK on your remote control to continue.")
+ self.edittext = _("Press OK to edit the settings.")
+ self.defaulttext = _("Press yellow to set this interface as default interface.")
+ self.restartLanRef = None
+
+ self["key_red"] = StaticText(_("Close"))
+ self["key_green"] = StaticText(_("Select"))
+ self["key_yellow"] = StaticText("")
+ self["key_blue"] = StaticText("")
+ self["introduction"] = StaticText(self.edittext)
+
self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
- if len(self.adapters) == 0:
- #Reset Network to defaults if network broken
- iNetwork.resetNetworkConfig('lan')
+
+ if not self.adapters:
+ 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 network interface list")),
+ "ok": (self.okbuttonClick, _("select interface")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.close, _("exit network interface list")),
+ "green": (self.okbuttonClick, _("select interface")),
+ "blue": (self.openNetworkWizard, _("Use the Networkwizard to configure selected network adapter")),
+ })
+
+ self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions",
+ {
+ "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than 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):
+ self.list = []
+ default_gw = None
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ self["key_yellow"].setText(_("Default"))
+ self["introduction"].setText(self.defaulttext)
+ self["DefaultInterfaceAction"].setEnabled(True)
+ else:
+ self["key_yellow"].setText("")
+ self["introduction"].setText(self.edittext)
+ self["DefaultInterfaceAction"].setEnabled(False)
+
+ if num_configured_if < 2 and os_path.exists("/etc/default_gw"):
+ 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 ))
+
+ if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
+ self["key_blue"].setText(_("NetworkWizard"))
+ 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):
- if len(self.adapters) == 1: # just one network adapter.. close selection
+ if len(self.adapters) == 1:
self.close()
+ else:
+ self.updateList()
-class NameserverSetup(Screen, ConfigListScreen):
+ 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()
+ iNetwork.stopGetInterfacesConsole()
+
+ 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)
+
+ def openNetworkWizard(self):
+ if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
+ try:
+ from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
+ except ImportError:
+ self.session.open(MessageBox, _("The NetworkWizard extension is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ selection = self["list"].getCurrent()
+ if selection is not None:
+ self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, selection[0])
+
+
+class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
def __init__(self, session):
Screen.__init__(self, session)
+ HelpableScreen.__init__(self)
self.backupNameserverList = iNetwork.getNameserverList()[:]
print "backup-list:", self.backupNameserverList
+
+ self["key_red"] = StaticText(_("Cancel"))
+ self["key_green"] = StaticText(_("Add"))
+ self["key_yellow"] = StaticText(_("Delete"))
- self["ButtonGreentext"] = Label(_("Add"))
- self["ButtonYellowtext"] = Label(_("Delete"))
- self["ButtonRedtext"] = Label(_("Close"))
+ self["introduction"] = StaticText(_("Press OK to activate the settings."))
self.createConfig()
- self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
+ 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["actions"] = NumberActionMap(["SetupActions"],
{
"ok": self.ok,
- "cancel": self.cancel,
- "red": self.cancel,
- "green": self.add,
- "yellow": self.remove
}, -2)
self.list = []
def createConfig(self):
self.nameservers = iNetwork.getNameserverList()
- self.nameserverEntries = []
-
- for nameserver in self.nameservers:
- self.nameserverEntries.append(NoSave(ConfigIP(default=nameserver)))
+ self.nameserverEntries = [ NoSave(ConfigIP(default=nameserver)) for nameserver in self.nameservers]
def createSetup(self):
self.list = []
- for i in range(len(self.nameserverEntries)):
- self.list.append(getConfigListEntry(_("Nameserver %d") % (i + 1), self.nameserverEntries[i]))
+ i = 1
+ for x in self.nameserverEntries:
+ self.list.append(getConfigListEntry(_("Nameserver %d") % (i), x))
+ i += 1
self["config"].list = self.list
self["config"].l.setList(self.list)
iNetwork.writeNameserverConfig()
self.close()
+ def run(self):
+ self.ok()
+
def cancel(self):
iNetwork.clearNameservers()
print "backup-list:", self.backupNameserverList
def remove(self):
print "currentIndex:", self["config"].getCurrentIndex()
-
index = self["config"].getCurrentIndex()
if index < len(self.nameservers):
iNetwork.removeNameserver(self.nameservers[index])
self.createSetup()
-class AdapterSetup(Screen, ConfigListScreen):
- def __init__(self, session, iface):
+class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
+ def __init__(self, session, networkinfo, essid=None, aplist=None):
Screen.__init__(self, session)
+ HelpableScreen.__init__(self)
self.session = session
- ## FIXME , workaround against current wizzard not able to send arguments
- if iface == 0:
- self.iface = "eth0"
- elif iface == 1:
- self.iface = "wlan0"
+ if isinstance(networkinfo, (list, tuple)):
+ self.iface = networkinfo[0]
+ self.essid = networkinfo[1]
+ self.aplist = networkinfo[2]
else:
- self.iface = iface
+ self.iface = networkinfo
+ 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")
- if self.iface == 'wlan0':
- from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant
- self.ws = wpaSupplicant()
- list = []
- list.append(_("WEP"))
- list.append(_("WPA"))
- list.append(_("WPA2"))
+ self.createConfig()
- config.plugins.wlan.essid = NoSave(ConfigText(default = "home", fixed_size = False))
- 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["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.keyCancel, _("exit network adapter configuration")),
+ "ok": (self.keySave, _("activate network adapter configuration")),
+ })
- 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["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.keyCancel, _("exit network adapter configuration")),
+ "blue": (self.KeyBlue, _("open nameserver configuration")),
+ })
- self["actions"] = ActionMap(["SetupActions","ShortcutActions"],
+ self["actions"] = NumberActionMap(["SetupActions"],
{
- "ok": self.ok,
- "cancel": self.cancel,
- "red": self.cancel,
- "blue": self.KeyBlue,
+ "ok": self.keySave,
}, -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"] = StaticText(_("Primary DNS"))
+ self["DNS2text"] = StaticText(_("Secondary DNS"))
+ self["DNS1"] = StaticText()
+ self["DNS2"] = StaticText()
+ self["introduction"] = StaticText(_("Current settings:"))
+
+ self["IPtext"] = StaticText(_("IP Address"))
+ self["Netmasktext"] = StaticText(_("Netmask"))
+ self["Gatewaytext"] = StaticText(_("Gateway"))
+
+ self["IP"] = StaticText()
+ self["Mask"] = StaticText()
+ self["Gateway"] = StaticText()
+
+ self["Adaptertext"] = StaticText(_("Network:"))
+ self["Adapter"] = StaticText()
+ self["introduction2"] = StaticText(_("Press OK to activate the settings."))
+ self["key_red"] = StaticText(_("Cancel"))
+ self["key_blue"] = StaticText(_("Edit DNS"))
+
+ self["VKeyIcon"] = Boolean(False)
+ self["HelpWindow"] = Pixmap()
+ self["HelpWindow"].hide()
- 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"))
-
def layoutFinished(self):
self["DNS1"].setText(self.primaryDNS.getText())
self["DNS2"].setText(self.secondaryDNS.getText())
- self["IP"].setText(self.ipConfigEntry.getText())
- self["Mask"].setText(self.netmaskConfigEntry.getText())
- self["Gateway"].setText(self.gatewayConfigEntry.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["Gatewaytext"].setText(_("Gateway"))
+ self["Gateway"].setText(_("N/A"))
+ else:
+ self["Gatewaytext"].setText(_("Gateway"))
+ self["Gateway"].setText(self.gatewayConfigEntry.getText())
+ else:
+ self["Gateway"].setText("")
+ self["Gatewaytext"].setText("")
self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
-
- def createSetup(self):
- self.list = []
- 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))
+ 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:
+ for ap in self.aps:
+ a = self.aps[ap]
+ if a['active']:
+ if a['essid'] != '':
+ self.nwlist.append((a['essid'],a['essid']))
+ self.nwlist.sort(key = lambda x: x[0])
+ except:
+ self.nwlist.append(("No Networks found",_("No Networks found")))
+
+ self.wsconfig = self.ws.loadConfig()
+ if self.essid is not None: # ssid from wlan scan
+ self.default = self.essid
+ else:
+ self.default = self.wsconfig['ssid']
- self.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
+ if "hidden..." not in self.nwlist:
+ self.nwlist.append(("hidden...",_("enter hidden network SSID")))
+ if self.default not in self.nwlist:
+ self.nwlist.append((self.default,self.default))
+ config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
+ config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
- 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))
+ 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)
def KeyBlue(self):
- self.session.open(NameserverSetup)
+ self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
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 keySave(self):
+ self.hideInputHelp()
+ if self["config"].isChanged():
+ self.session.openWithCallback(self.keySaveConfirm, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) )
+ else:
+ if self.finished_cb:
+ self.finished_cb()
+ else:
+ self.close('cancel')
+
+ def keySaveConfirm(self, ret = False):
+ if (ret == True):
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 1:
+ if num_configured_if == 1 and self.iface in iNetwork.getConfiguredAdapters():
+ self.applyConfig(True)
+ else:
+ self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("A second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = True)
+ else:
+ self.applyConfig(True)
+ else:
+ self.keyCancel()
- def ok(self):
- selection = self["config"].getCurrent()
- if selection == self.extendedSetup:
- self.extended(self.session, self.iface)
+ def secondIfaceFoundCB(self,data):
+ if data is False:
+ self.applyConfig(True)
else:
+ configuredInterfaces = iNetwork.getConfiguredAdapters()
+ for interface in configuredInterfaces:
+ if interface == self.iface:
+ continue
+ iNetwork.setAdapterAttribute(interface, "up", False)
+ iNetwork.deactivateInterface(interface)
+ self.applyConfig(True)
+
+ def applyConfig(self, ret = False):
+ if (ret == True):
+ 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()
-
- iNetwork.deactivateNetworkConfig()
+ if self.activateInterfaceEntry.value is False:
+ iNetwork.deactivateInterface(self.iface)
iNetwork.writeNetworkConfig()
- iNetwork.activateNetworkConfig()
- #if self.iface == 'wlan0':
- # iNetwork.restartNetwork()
- self.close()
+ iNetwork.restartNetwork(self.applyConfigDataAvail)
+ self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+ else:
+ self.keyCancel()
- def cancel(self):
- iNetwork.getInterfaces()
- self.close()
+ def applyConfigDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
- def run(self):
- self.ok()
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.applyConfigRef.close(True)
+ def applyConfigfinishedCB(self,data):
+ if data is True:
+ if self.finished_cb:
+ self.session.openWithCallback(lambda x : self.finished_cb(), MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+ else:
+ self.session.openWithCallback(self.ConfigfinishedCB, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
+
+ def ConfigfinishedCB(self,data):
+ if data is not None:
+ if data is True:
+ self.close('ok')
+
+ def keyCancelConfirm(self, result):
+ if not result:
+ return
+ if self.oldInterfaceState is False:
+ iNetwork.deactivateInterface(self.iface,self.keyCancelCB)
+ else:
+ self.close('cancel')
-class AdapterSetupConfiguration(Screen):
-
+ def keyCancel(self):
+ self.hideInputHelp()
+ if self["config"].isChanged():
+ self.session.openWithCallback(self.keyCancelConfirm, MessageBox, _("Really close without saving settings?"))
+ else:
+ self.close('cancel')
+
+ def keyCancelCB(self,data):
+ if data is not None:
+ if data is True:
+ self.close('cancel')
+
+ def runAsync(self, finished_cb):
+ self.finished_cb = finished_cb
+ self.keySave()
+
+ 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()
+
+ def hideInputHelp(self):
+ current = self["config"].getCurrent()
+ if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+ elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+
+
+class AdapterSetupConfiguration(Screen, HelpableScreen):
def __init__(self, session,iface):
Screen.__init__(self, session)
- self.iface = iface
+ HelpableScreen.__init__(self)
self.session = session
- #self.ethtool_bin = "/usr/sbin/ethtool"
- #self.output = None
- #self.container = eConsoleAppContainer()
+ self.iface = iface
+ self.restartLanRef = None
+ self.LinkState = 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_active"] = Pixmap()
- self["statuspic_active"].hide()
- self["statuspic_inactive"] = Pixmap()
- self["statuspic_inactive"].hide()
- self["BottomBG"] = Pixmap()
- self["ButtonRed"] = Pixmap()
- self["ButtonRedtext"] = Label(_("Close"))
-
+ self["key_red"] = StaticText(_("Close"))
+ self["description"] = StaticText()
+ self["IFtext"] = StaticText()
+ self["IF"] = StaticText()
+ self["Statustext"] = StaticText()
+ self["statuspic"] = MultiPixmap()
+ self["statuspic"].hide()
+
self.oktext = _("Press OK on your remote control to continue.")
self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
+ self.errortext = _("No working wireless network interface found.\n Please verify that you have attached a compatible WLAN device or enable your local network interface.")
+
+ self["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,
"down": self.down,
"red": self.close,
"left": self.left,
- "right": self.right,
+ "right": self.right,
}, -2)
-
- iNetwork.getInterfaces()
- self.onLayoutFinish.append(self.layoutFinished)
+
self.updateStatusbar()
+ self.onLayoutFinish.append(self.layoutFinished)
+ self.onClose.append(self.cleanup)
def ok(self):
+ self.cleanup()
if self["menulist"].getCurrent()[1] == 'edit':
- 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:
+ 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':
- from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
- self.session.open(WlanScan,self.iface)
+ 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':
- from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
- self.session.open(WlanStatus,self.iface)
+ 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] == '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") + self.reboottext ) )
- if self["menulist"].getCurrent()[1] == 'resetconfig':
- self.session.openWithCallback(self.resetconfig, MessageBox, (_("Are you sure you want to reset \nyour network configuration to defaults?\n\n") + self.reboottext ) )
-
+ if self["menulist"].getCurrent()[1] == 'openwizard':
+ from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
+ self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, self.iface)
+ if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
+ self.extended = self["menulist"].getCurrent()[1][2]
+ self.extended(self.session, self.iface)
+
def up(self):
self["menulist"].up()
self.loadDescription()
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] == 'resetconfig':
- self["description"].setText(_("Reset the network configuration of your Dreambox.\n\n" ) + self.reboottext )
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 )
+ self["description"].setText(_("Scan your network for wireless Access Points and connect to them using your selected wireless device.\n" ) + self.oktext )
if self["menulist"].getCurrent()[1] == 'wlanstatus':
self["description"].setText(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext )
if self["menulist"].getCurrent()[1] == 'lanrestart':
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 )
-
-
- def updateStatusbar(self):
+ 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.mainmenu = self.genMainMenu()
+ self["menulist"].l.setList(self.mainmenu)
self["IFtext"].setText(_("Network:"))
self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
self["Statustext"].setText(_("Link:"))
-
- if self.iface == 'wlan0':
- 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_active"].hide()
- self["statuspic_inactive"].show()
+
+ if self.iface == 'wlan0' or self.iface == 'ath0':
+ try:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+ except:
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
else:
- self["statuspic_active"].show()
- self["statuspic_inactive"].hide()
+ iStatus.getDataForInterface(self.iface,self.getInfoCB)
else:
- self.getLinkState(self.iface)
-
+ 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"));
- menu.append((_("Reset configuration"), "resetconfig"));
+ 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
+ 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"));
- if callFnc is None and iNetwork.ifaces.has_key('wlan0') is False:
- menu.append((_("Enable WLAN Support"), "enablewlan"));
+ self.extended = callFnc
+ 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 enablewlan(self, ret = False):
- if (ret == True):
- iNetwork.resetNetworkConfig('wlan')
- TryQuitMainloop(self.session,2)
-
- def resetconfig(self, ret = False):
- if (ret == True):
- iNetwork.resetNetworkConfig('lan')
- TryQuitMainloop(self.session,2)
+ 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.updateStatusbar()
+ else:
+ 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.updateStatusbar()
+
+ def WlanScanClosed(self,*ret):
+ if ret[0] is not None:
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
+ else:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ iStatus.stopWlanConsole()
+ self.updateStatusbar()
+
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 getLinkState(self,iface):
- iNetwork.getLinkState(iface,self.dataAvail)
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.restartLanRef.close(True)
+
+ def restartfinishedCB(self,data):
+ if data is True:
+ self.updateStatusbar()
+ self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
def dataAvail(self,data):
- self.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_active"].show()
- self["statuspic_inactive"].hide()
+ self.LinkState = None
+ for line in data.splitlines():
+ line = line.strip()
+ if 'Link detected:' in line:
+ if "yes" in line:
+ self.LinkState = True
+ else:
+ self.LinkState = False
+ if self.LinkState == True:
+ iNetwork.checkNetworkState(self.checkNetworkCB)
+ else:
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
+
+ def showErrorMessage(self):
+ self.session.open(MessageBox, self.errortext, type = MessageBox.TYPE_INFO,timeout = 10 )
+
+ def cleanup(self):
+ iNetwork.stopLinkStateConsole()
+ iNetwork.stopDeactivateInterfaceConsole()
+ iNetwork.stopPingConsole()
+ try:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+ except ImportError:
+ pass
+ else:
+ iStatus.stopWlanConsole()
+
+ def getInfoCB(self,data,status):
+ self.LinkState = None
+ if data is not None:
+ if data is True:
+ if status is not None:
+ if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
+ self.LinkState = False
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
+ else:
+ self.LinkState = True
+ iNetwork.checkNetworkState(self.checkNetworkCB)
+
+ def checkNetworkCB(self,data):
+ if iNetwork.getAdapterAttribute(self.iface, "up") is True:
+ if self.LinkState is True:
+ if data <= 2:
+ self["statuspic"].setPixmapNum(0)
+ else:
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
else:
- self["statuspic_active"].hide()
- self["statuspic_inactive"].show()
-
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
+ else:
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
-class NetworkAdapterTest(Screen):
+class NetworkAdapterTest(Screen):
def __init__(self, session,iface):
Screen.__init__(self, session)
self.iface = iface
-
+ self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
self.setLabels()
-
- self["updown_actions"] = NumberActionMap(["WizardActions"],
+ 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.close,
- "back": self.close,
+ "red": self.cancel,
+ "back": self.cancel,
}, -2)
self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
{
{
"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
- global nextstep
- nextstep = 0
- global activebutton
- activebutton = 0
+ 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"))
-
+ self["key_red"].setText(_("Close"))
+
def delTimer(self):
del self.steptimer
del self.nextStepTimer
def nextStepTimerFire(self):
- global nextstep
- self.nextstep= nextstep
self.nextStepTimer.stop()
self.steptimer = False
- self.runTest(self.nextstep)
+ self.runTest()
def updownhandler(self,direction):
- global activebutton
if direction == 'up':
- if activebutton >=2:
- activebutton = activebutton -1
- self.setActiveButton(activebutton)
+ if self.activebutton >=2:
+ self.activebutton -= 1
+ else:
+ self.activebutton = 6
+ self.setActiveButton(self.activebutton)
if direction == 'down':
- if activebutton <=5:
- activebutton = activebutton +1
- self.setActiveButton(activebutton)
+ if self.activebutton <=5:
+ self.activebutton += 1
+ else:
+ self.activebutton = 1
+ self.setActiveButton(self.activebutton)
def setActiveButton(self,button):
if button == 1:
- self["NetworkInfo"].show()
- self["NetworkInfo_selected"].hide()
- self["AdapterInfo"].hide()
- self["AdapterInfo_selected"].show()
+ 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"].show()
- self["AdapterInfo_selected"].hide()
- self["DhcpInfo"].show()
- self["DhcpInfo_selected"].hide()
- self["NetworkInfo"].hide()
- self["NetworkInfo_selected"].show()
+ 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"].show()
- self["NetworkInfo_selected"].hide()
- self["IPInfo"].show()
- self["IPInfo_selected"].hide()
- self["DhcpInfo"].hide()
- self["DhcpInfo_selected"].show()
+ 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"].show()
- self["DhcpInfo_selected"].hide()
- self["DNSInfo"].show()
- self["DNSInfo_selected"].hide()
- self["IPInfo"].hide()
- self["IPInfo_selected"].show()
+ 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"].show()
- self["IPInfo_selected"].hide()
- self["EditSettingsButton"].show()
- self["EditSettingsButton_selected"].hide()
- self["DNSInfo"].hide()
- self["DNSInfo_selected"].show()
+ 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"].show()
- self["DNSInfo_selected"].hide()
- self["EditSettingsButton"].hide()
- self["EditSettingsButton_selected"].show()
+ 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):
- global nextstep
+ def runTest(self):
+ next = self.nextstep
if next == 0:
- nextstep = next + 1
self.doStep1()
- if next == 1:
- nextstep = next + 1
- self.doStep2()
- if next == 2:
- nextstep = next + 1
+ elif next == 1:
+ self.doStep2()
+ elif next == 2:
self.doStep3()
- if next == 3:
- nextstep = next + 1
+ elif next == 3:
self.doStep4()
- if next == 4:
- nextstep = next + 1
+ elif next == 4:
self.doStep5()
- if next == 5:
- nextstep = next + 1
- self.doStep6()
-
+ elif next == 5:
+ self.doStep6()
+ self.nextstep += 1
+
def doStep1(self):
self.steptimer = True
self.nextStepTimer.start(3000)
+ self["key_yellow"].setText(_("Stop test"))
def doStep2(self):
self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
- self["Adapter"].instance.setForegroundColor(getColor(Green))
- self["AdapterInfo_Text"].instance.setForegroundColor(getColor(Black))
- self["AdapterInfo_OK"].show()
+ self["Adapter"].setForegroundColorNum(2)
+ self["Adaptertext"].setForegroundColorNum(1)
+ self["AdapterInfo_Text"].setForegroundColorNum(1)
+ self["AdapterInfo_OK"].show()
self.steptimer = True
- self.nextStepTimer.start(3000)
+ self.nextStepTimer.start(3000)
def doStep3(self):
+ self["Networktext"].setForegroundColorNum(1)
+ self["Network"].setText(_("Please wait..."))
self.getLinkState(self.iface)
- self["NetworkInfo_Text"].instance.setForegroundColor(getColor(Black))
+ self["NetworkInfo_Text"].setForegroundColorNum(1)
self.steptimer = True
- self.nextStepTimer.start(3000)
+ self.nextStepTimer.start(3000)
def doStep4(self):
+ self["Dhcptext"].setForegroundColorNum(1)
if iNetwork.getAdapterAttribute(self.iface, 'dhcp') is True:
- self["Dhcp"].instance.setForegroundColor(getColor(Green))
+ self["Dhcp"].setForegroundColorNum(2)
self["Dhcp"].setText(_("enabled"))
- self["DhcpInfo_OK"].show()
- self["DhcpInfo_NOK"].hide()
+ self["DhcpInfo_Check"].setPixmapNum(0)
else:
- self["Dhcp"].instance.setForegroundColor(getColor(Grey))
- self["Dhcp"].setText(_("disabled"))
- self["DhcpInfo_NOK"].show()
- self["DhcpInfo_OK"].hide()
- self["DhcpInfo_Text"].instance.setForegroundColor(getColor(Black))
+ 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):
- if len(iNetwork.getAdapterAttribute(self.iface,'ip')) != 0:
- self["IP"].instance.setForegroundColor(getColor(Green))
- self["IP"].setText(_("confirmed"))
- self["IPInfo_OK"].show()
- self["IPInfo_NOK"].hide()
- else:
- self["IP"].instance.setForegroundColor(getColor(Grey))
- self["IP"].setText(_("unconfirmed"))
- self["IPInfo_NOK"].show()
- self["IPInfo_OK"].hide()
- self["IPInfo_Text"].instance.setForegroundColor(getColor(Black))
- self.steptimer = True
- self.nextStepTimer.start(3000)
+ self["IPtext"].setForegroundColorNum(1)
+ self["IP"].setText(_("Please wait..."))
+ iNetwork.checkNetworkState(self.NetworkStatedataAvail)
def doStep6(self):
self.steptimer = False
self.nextStepTimer.stop()
- if len (iNetwork.getNameserverList()) != 0:
- self["DNS"].instance.setForegroundColor(getColor(Green))
- self["DNS"].setText(_("confirmed"))
- self["DNSInfo_OK"].show()
- self["DNSInfo_NOK"].hide()
- else:
- self["DNS"].instance.setForegroundColor(getColor(Grey))
- self["DNS"].setText(_("unconfirmed"))
- self["DNSInfo_NOK"].show()
- self["DNSInfo_OK"].hide()
-
- self["DNSInfo_Text"].instance.setForegroundColor(getColor(Black))
- self["EditSettings_Text"].show()
- self["EditSettingsButton_selected"].show()
- self["ButtonYellow_off"].show()
- self["ButtonYellow"].hide()
- self["ButtonGreentext"].setText(_("Restart test"))
- self["ButtonGreen"].show()
- self["ButtonGreen_off"].hide()
- self["shortcutsgreen"].setEnabled(False)
- self["shortcutsgreen_restart"].setEnabled(True)
- self["shortcutsyellow"].setEnabled(False)
- self["updown_actions"].setEnabled(True)
- global activebutton
- activebutton = 6
-
+ 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_off"].hide()
- self["ButtonYellow"].show()
- self["ButtonGreen"].hide()
- self["ButtonGreen_off"].show()
+ self["key_yellow"].setText("")
+ self["key_green"].setText("")
self.steptimer = True
self.nextStepTimer.start(1000)
def KeyGreenRestart(self):
- global nextstep
- nextstep = 0
+ self.nextstep = 0
self.layoutFinished()
self["Adapter"].setText((""))
self["Network"].setText((""))
self["Dhcp"].setText((""))
self["IP"].setText((""))
self["DNS"].setText((""))
- self["AdapterInfo_Text"].instance.setForegroundColor(getColor(Grey))
- self["NetworkInfo_Text"].instance.setForegroundColor(getColor(Grey))
- self["DhcpInfo_Text"].instance.setForegroundColor(getColor(Grey))
- self["IPInfo_Text"].instance.setForegroundColor(getColor(Grey))
- self["DNSInfo_Text"].instance.setForegroundColor(getColor(Grey))
+ 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_off"].hide()
- self["ButtonYellow"].show()
- self["ButtonGreen"].hide()
- self["ButtonGreen_off"].show()
+ self["key_yellow"].setText("")
+ self["key_green"].setText("")
self.steptimer = True
self.nextStepTimer.start(1000)
-
+
def KeyOK(self):
- global activebutton
self["infoshortcuts"].setEnabled(True)
self["shortcuts"].setEnabled(False)
- if activebutton == 1: # Adapter Check
+ 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 activebutton == 2: #LAN Check
+ self["key_red"].setText(_("Back"))
+ if self.activebutton == 2: #LAN Check
self["InfoText"].setText(_("This test checks whether a network cable is connected to your LAN-Adapter.\nIf you get a \"disconnected\" message:\n- verify that a network cable is attached\n- verify that the cable is not broken"))
self["InfoTextBorder"].show()
self["InfoText"].show()
- self["ButtonRedtext"].setText(_("Back"))
- if activebutton == 3: #DHCP Check
+ self["key_red"].setText(_("Back"))
+ if self.activebutton == 3: #DHCP Check
self["InfoText"].setText(_("This test checks whether your LAN Adapter is set up for automatic IP Address configuration with DHCP.\nIf you get a \"disabled\" message:\n - then your LAN Adapter is configured for manual IP Setup\n- verify thay you have entered correct IP informations in the AdapterSetup dialog.\nIf you get an \"enabeld\" message:\n-verify that you have a configured and working DHCP Server in your network."))
self["InfoTextBorder"].show()
self["InfoText"].show()
- self["ButtonRedtext"].setText(_("Back"))
- if activebutton == 4: # IP Check
+ self["key_red"].setText(_("Back"))
+ if self.activebutton == 4: # IP Check
self["InfoText"].setText(_("This test checks whether a valid IP Address is found for your LAN Adapter.\nIf you get a \"unconfirmed\" message:\n- no valid IP Address was found\n- please check your DHCP, cabling and adapter setup"))
self["InfoTextBorder"].show()
self["InfoText"].show()
- self["ButtonRedtext"].setText(_("Back"))
- if activebutton == 5: # DNS Check
+ self["key_red"].setText(_("Back"))
+ if self.activebutton == 5: # DNS Check
self["InfoText"].setText(_("This test checks for configured Nameservers.\nIf you get a \"unconfirmed\" message:\n- please check your DHCP, cabling and Adapter setup\n- if you configured your Nameservers manually please verify your entries in the \"Nameserver\" Configuration"))
self["InfoTextBorder"].show()
self["InfoText"].show()
- self["ButtonRedtext"].setText(_("Back"))
- if activebutton == 6: # Edit Settings
+ self["key_red"].setText(_("Back"))
+ if self.activebutton == 6: # Edit Settings
self.session.open(AdapterSetup,self.iface)
def KeyYellow(self):
- global nextstep
- nextstep = 0
+ self.nextstep = 0
self["shortcutsgreen_restart"].setEnabled(True)
self["shortcutsgreen"].setEnabled(False)
self["shortcutsyellow"].setEnabled(False)
- self["ButtonGreentext"].setText(_("Restart test"))
- self["ButtonYellow_off"].show()
- self["ButtonYellow"].hide()
- self["ButtonGreen"].show()
- self["ButtonGreen_off"].hide()
+ self["key_green"].setText(_("Restart test"))
+ self["key_yellow"].setText("")
self.steptimer = False
self.nextStepTimer.stop()
-
+
def layoutFinished(self):
self["shortcutsyellow"].setEnabled(False)
- self["AdapterInfo_selected"].hide()
self["AdapterInfo_OK"].hide()
-
- self["NetworkInfo_selected"].hide()
- self["NetworkInfo_OK"].hide()
- self["NetworkInfo_NOK"].hide()
-
- self["DhcpInfo_selected"].hide()
- self["DhcpInfo_OK"].hide()
- self["DhcpInfo_NOK"].hide()
-
- self["IPInfo_selected"].hide()
- self["IPInfo_OK"].hide()
- self["IPInfo_NOK"].hide()
-
- self["DNSInfo_selected"].hide()
- self["DNSInfo_OK"].hide()
- self["DNSInfo_NOK"].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["EditSettingsButton_selected"].hide()
- self["ButtonYellow"].hide()
- self["ButtonGreen_off"].hide()
self["InfoText"].hide()
self["InfoTextBorder"].hide()
-
+ self["key_yellow"].setText("")
+
def setLabels(self):
- self["Adaptertext"] = Label(_("LAN Adapter"))
- self["Adapter"] = Label()
- self["AdapterInfo"] = Pixmap()
- self["AdapterInfo_selected"] = Pixmap()
- self["AdapterInfo_Text"] = Label(_("Show Info"))
+ 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':
- self["Networktext"] = Label(_("Wireless Network"))
+ if self.iface == 'wlan0' or self.iface == 'ath0':
+ self["Networktext"] = MultiColorLabel(_("Wireless Network"))
else:
- self["Networktext"] = Label(_("Local Network"))
+ self["Networktext"] = MultiColorLabel(_("Local Network"))
- self["Network"] = Label()
- self["NetworkInfo"] = Pixmap()
- self["NetworkInfo_selected"] = Pixmap()
- self["NetworkInfo_Text"] = Label(_("Show Info"))
- self["NetworkInfo_OK"] = Pixmap()
- self["NetworkInfo_NOK"] = Pixmap()
+ self["Network"] = MultiColorLabel()
+ self["NetworkInfo"] = MultiPixmap()
+ self["NetworkInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["NetworkInfo_Check"] = MultiPixmap()
- self["Dhcptext"] = Label(_("DHCP"))
- self["Dhcp"] = Label()
- self["DhcpInfo"] = Pixmap()
- self["DhcpInfo_selected"] = Pixmap()
- self["DhcpInfo_Text"] = Label(_("Show Info"))
- self["DhcpInfo_OK"] = Pixmap()
- self["DhcpInfo_NOK"] = Pixmap()
+ self["Dhcptext"] = MultiColorLabel(_("DHCP"))
+ self["Dhcp"] = MultiColorLabel()
+ self["DhcpInfo"] = MultiPixmap()
+ self["DhcpInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["DhcpInfo_Check"] = MultiPixmap()
- self["IPtext"] = Label(_("IP Address"))
- self["IP"] = Label()
- self["IPInfo"] = Pixmap()
- self["IPInfo_selected"] = Pixmap()
- self["IPInfo_Text"] = Label(_("Show Info"))
- self["IPInfo_OK"] = Pixmap()
- self["IPInfo_NOK"] = Pixmap()
+ self["IPtext"] = MultiColorLabel(_("IP Address"))
+ self["IP"] = MultiColorLabel()
+ self["IPInfo"] = MultiPixmap()
+ self["IPInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["IPInfo_Check"] = MultiPixmap()
- self["DNStext"] = Label(_("Nameserver"))
- self["DNS"] = Label()
- self["DNSInfo"] = Pixmap()
- self["DNSInfo_selected"] = Pixmap()
- self["DNSInfo_Text"] = Label(_("Show Info"))
- self["DNSInfo_OK"] = Pixmap()
- self["DNSInfo_NOK"] = Pixmap()
+ self["DNStext"] = MultiColorLabel(_("Nameserver"))
+ self["DNS"] = MultiColorLabel()
+ self["DNSInfo"] = MultiPixmap()
+ self["DNSInfo_Text"] = MultiColorLabel(_("Show Info"))
+ self["DNSInfo_Check"] = MultiPixmap()
- self["EditSettings_Text"] = Label(_("Edit settings"))
- self["EditSettingsButton"] = Pixmap()
- self["EditSettingsButton_selected"] = Pixmap()
+ self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
+ self["EditSettingsButton"] = MultiPixmap()
- self["ButtonRedtext"] = Label(_("Close"))
- self["ButtonRed"] = Pixmap()
- self["ButtonGreentext"] = Label(_("Start test"))
- self["ButtonGreen"] = Pixmap()
- self["ButtonGreen_off"] = Pixmap()
- self["ButtonYellowtext"] = Label(_("Stop test"))
- self["ButtonYellow"] = Pixmap()
- self["ButtonYellow_off"] = Pixmap()
+ self["key_red"] = StaticText(_("Close"))
+ self["key_green"] = StaticText(_("Start test"))
+ self["key_yellow"] = StaticText(_("Stop test"))
self["InfoTextBorder"] = Pixmap()
self["InfoText"] = Label()
def getLinkState(self,iface):
- iNetwork.getLinkState(iface,self.dataAvail)
+ 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 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):
- self["Network"].instance.setForegroundColor(getColor(Green))
+ if re_search(pattern, item):
+ self["Network"].setForegroundColorNum(2)
self["Network"].setText(_("connected"))
- self["NetworkInfo_OK"].show()
- self["NetworkInfo_NOK"].hide()
+ self["NetworkInfo_Check"].setPixmapNum(0)
else:
- self["Network"].instance.setForegroundColor(getColor(Grey))
+ self["Network"].setForegroundColorNum(1)
self["Network"].setText(_("disconnected"))
- self["NetworkInfo_OK"].hide()
- self["NetworkInfo_NOK"].show()
+ 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["key_yellow"].setText("")
+ self["key_green"].setText(_("Restart test"))
+ 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()
git.cweiske.de / enigma2.git / blobdiff