from Screen import Screen
-from Components.ActionMap import ActionMap
-from Components.ConfigList import ConfigList, ConfigListScreen
-from Components.config import config, 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
+from Components.Sources.StaticText import StaticText
+from Components.Sources.Boolean import Boolean
+from Components.Sources.List import List
+from Components.Label import Label,MultiColorLabel
+from Components.Pixmap import Pixmap,MultiPixmap
from Components.MenuList import MenuList
-from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigSubsection, ConfigNothing
+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 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 NetworkAdapterSelection(Screen):
+class NetworkAdapterSelection(Screen,HelpableScreen):
def __init__(self, session):
Screen.__init__(self, session)
+ HelpableScreen.__init__(self)
- self["adapterlist"] = MenuList(iNetwork.getAdapterList())
+ 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["actions"] = ActionMap(["OkCancelActions"],
- {
- "ok": self.okbuttonClick ,
- "cancel": self.close
- })
+ 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 not self.adapters:
+ self.onFirstExecBegin.append(self.NetworkFallback)
+
+ 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"] = List(self.list)
+ self.updateList()
+
+ if len(self.adapters) == 1:
+ self.onFirstExecBegin.append(self.okbuttonClick)
+ self.onClose.append(self.cleanup)
+
+ def buildInterfaceList(self,iface,name,default,active ):
+ divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
+ defaultpng = None
+ activepng = None
+ description = None
+ interfacepng = None
+
+ if iface in iNetwork.lan_interfaces:
+ if active is True:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-active.png"))
+ elif active is False:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-inactive.png"))
+ else:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired.png"))
+ elif iface in iNetwork.wlan_interfaces:
+ if active is True:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-active.png"))
+ elif active is False:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-inactive.png"))
+ else:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless.png"))
+
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ if default is True:
+ defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
+ elif default is False:
+ defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
+ if active is True:
+ activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
+ elif active is False:
+ activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
+
+ description = iNetwork.getFriendlyAdapterDescription(iface)
+
+ return((iface, name, description, interfacepng, defaultpng, activepng, divpng))
+
+ def updateList(self):
+ self.list = []
+ default_gw = None
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ 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(self.buildInterfaceList("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(self.buildInterfaceList(x[1],_(x[0]),default_int,active_int ))
+
+ if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
+ self["key_blue"].setText(_("NetworkWizard"))
+ self["list"].setList(self.list)
+
+ def setDefaultInterface(self):
+ selection = self["list"].getCurrent()
+ 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()
- print "selection:", selection
+ selection = self["list"].getCurrent()
if selection is not None:
- self.session.open(AdapterSetup, selection)
+ 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()
+ 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)
-class NameserverSetup(Screen, ConfigListScreen):
+ 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["red"] = Label(_("Delete"))
- self["green"] = Label(_("Add"))
-
+ self["key_red"] = StaticText(_("Cancel"))
+ self["key_green"] = StaticText(_("Add"))
+ self["key_yellow"] = StaticText(_("Delete"))
+
+ self["introduction"] = StaticText(_("Press OK to activate the settings."))
self.createConfig()
-
- self["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,
- "green": self.add,
- "red": 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 = []
- #self.nameserverConfigEntries = []
- 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.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):
- def __init__(self, session, iface):
+
+class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
+ def __init__(self, session, networkinfo, essid=None, aplist=None):
Screen.__init__(self, session)
-
- self.iface = iface
+ HelpableScreen.__init__(self)
+ self.session = session
+ if isinstance(networkinfo, (list, tuple)):
+ self.iface = networkinfo[0]
+ self.essid = networkinfo[1]
+ self.aplist = networkinfo[2]
+ else:
+ 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")
+
+ self.createConfig()
+
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.keyCancel, _("exit network adapter configuration")),
+ "ok": (self.keySave, _("activate network adapter configuration")),
+ })
- print iNetwork.getAdapterAttribute(self.iface, "dhcp")
- self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp")))
- self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=True))
- self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")))
- self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask")))
- self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway")))
-
- self["iface"] = Label(iNetwork.getAdapterName(self.iface))
-
- self["actions"] = ActionMap(["SetupActions"],
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.keyCancel, _("exit network adapter configuration")),
+ "blue": (self.KeyBlue, _("open nameserver configuration")),
+ })
+
+ self["actions"] = NumberActionMap(["SetupActions"],
{
- "ok": self.ok,
- "cancel": self.cancel,
+ "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()
+
+ 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["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 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 in iNetwork.wlan_interfaces:
+ 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']
+
+ 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["introduction"] = Label(_("Press OK to activate the settings."))
+ config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
+ config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
+ config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
+ config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
+
+ self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
+ self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
+ self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])
+ self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask") or [255,0,0,0]))
+ if iNetwork.getAdapterAttribute(self.iface, "gateway"):
+ self.dhcpdefault=True
+ else:
+ self.dhcpdefault=False
+ self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=self.dhcpdefault or False))
+ self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway") or [0,0,0,0]))
+ nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
+ self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
+ self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
def createSetup(self):
self.list = []
+ self.InterfaceEntry = getConfigListEntry(_("Use Interface"), self.activateInterfaceEntry)
- self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
- self.list.append(self.dhcpEntry)
- if not self.dhcpConfigEntry.value:
- self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
- self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
- self.list.append(getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry))
- if self.hasGatewayConfigEntry.value:
- self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
-
- self.extended = None
- self.extendedSetup = None
- for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
- callFnc = p.__call__["ifaceSupported"](self.iface)
- if callFnc is not None:
- self.extended = callFnc
- print p.__call__
- if p.__call__.has_key("configStrings"):
- self.configStrings = p.__call__["configStrings"]
- else:
- self.configStrings = None
-
- if p.__call__.has_key("menuEntryName"):
- menuEntryName = p.__call__["menuEntryName"](self.iface)
- else:
- menuEntryName = _('Extended Setup...')
- self.extendedSetup = getConfigListEntry(menuEntryName, NoSave(ConfigNothing()))
- self.list.append(self.extendedSetup)
+ 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.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 in iNetwork.wlan_interfaces:
+ if self["config"].getCurrent() == self.wlanSSID:
+ self.createSetup()
+ if self["config"].getCurrent() == self.encryptionEnabled:
+ self.createSetup()
+ if self["config"].getCurrent() == self.encryptionType:
+ 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 ok(self):
- selection = self["config"].getCurrent()
- if selection == self.extendedSetup:
- self.extended(self.session, self.iface)
+ 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 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()
+ if self.activateInterfaceEntry.value is False:
+ iNetwork.deactivateInterface(self.iface)
+ iNetwork.writeNetworkConfig()
+ iNetwork.restartNetwork(self.applyConfigDataAvail)
+ self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+ else:
+ self.keyCancel()
- iNetwork.deactivateNetworkConfig()
- iNetwork.writeNetworkConfig()
- iNetwork.activateNetworkConfig()
- self.close()
+ def applyConfigDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+ def getInterfacesDataAvail(self, data):
+ if data is True:
+ self.applyConfigRef.close(True)
+
+ def applyConfigfinishedCB(self,data):
+ if data is True:
+ 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')
+
+ 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)
+ HelpableScreen.__init__(self)
+ self.session = session
+ self.iface = iface
+ self.restartLanRef = None
+ self.LinkState = None
+ self.mainmenu = self.genMainMenu()
+ self["menulist"] = MenuList(self.mainmenu)
+ 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,
+ "back": self.close,
+ "up": self.up,
+ "down": self.down,
+ "red": self.close,
+ "left": self.left,
+ "right": self.right,
+ }, -2)
+
+ self.updateStatusbar()
+ self.onLayoutFinish.append(self.layoutFinished)
+ self.onClose.append(self.cleanup)
+
+ def ok(self):
+ self.cleanup()
+ if self["menulist"].getCurrent()[1] == 'edit':
+ if self.iface in iNetwork.wlan_interfaces:
+ try:
+ from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
+ from pythonwifi.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ ifobj = Wireless(self.iface) # a Wireless NIC Object
+ try:
+ self.wlanresponse = ifobj.getAPaddr()
+ except IOError:
+ self.wlanresponse = ifobj.getStatistics()
+ if self.wlanresponse:
+ if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ else:
+ 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 pythonwifi.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ ifobj = Wireless(self.iface) # a Wireless NIC Object
+ try:
+ self.wlanresponse = ifobj.getAPaddr()
+ except IOError:
+ self.wlanresponse = ifobj.getStatistics()
+ if self.wlanresponse:
+ if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+ self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ if self["menulist"].getCurrent()[1] == 'wlanstatus':
+ try:
+ from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
+ from pythonwifi.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ ifobj = Wireless(self.iface) # a Wireless NIC Object
+ try:
+ self.wlanresponse = ifobj.getAPaddr()
+ except IOError:
+ self.wlanresponse = ifobj.getStatistics()
+ if self.wlanresponse:
+ if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+ self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ if self["menulist"].getCurrent()[1] == 'lanrestart':
+ self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
+ if self["menulist"].getCurrent()[1] == 'openwizard':
+ from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
+ self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, self.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()
+
+ 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):
+ 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 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] == '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 in iNetwork.wlan_interfaces:
+ try:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+ 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
+ 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 in iNetwork.wlan_interfaces) and iNetwork.getAdapterAttribute(self.iface, "up") is True:
+ try:
+ from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
+ from pythonwifi.iwlibs import Wireless
+ except ImportError:
+ self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ ifobj = Wireless(self.iface) # a Wireless NIC Object
+ try:
+ self.wlanresponse = ifobj.getAPaddr()
+ except IOError:
+ self.wlanresponse = ifobj.getStatistics()
+ if self.wlanresponse:
+ if self.wlanresponse[0] not in (19,95): # 19 = 'No such device', 95 = 'Operation not supported'
+ self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ else:
+ # Display Wlan not available Message
+ self.showErrorMessage()
+ else:
+ self.updateStatusbar()
+ else:
+ self.updateStatusbar()
+
+ def WlanStatusClosed(self, *ret):
+ if ret is not None and len(ret):
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+ 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
+ iStatus.stopWlanConsole()
+ self.updateStatusbar()
+
+ 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.updateStatusbar()
+ self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
+
+ def dataAvail(self,data):
+ 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"].setPixmapNum(1)
+ self["statuspic"].show()
+ else:
+ self["statuspic"].setPixmapNum(1)
+ 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")
+ 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):
- iNetwork.getInterfaces()
+ 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["key_red"].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["key_yellow"].setText(_("Stop test"))
+
+ 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["key_yellow"].setText("")
+ self["key_green"].setText("")
+ 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["key_yellow"].setText("")
+ self["key_green"].setText("")
+ 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["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["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["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["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["key_red"].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["key_green"].setText(_("Restart test"))
+ self["key_yellow"].setText("")
+ self.steptimer = False
+ self.nextStepTimer.stop()
+
+ def layoutFinished(self):
+ self.setTitle(_("Network test: ") + iNetwork.getFriendlyAdapterName(self.iface) )
+ self["shortcutsyellow"].setEnabled(False)
+ self["AdapterInfo_OK"].hide()
+ self["NetworkInfo_Check"].hide()
+ self["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["key_yellow"].setText("")
+
+ 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 in iNetwork.wlan_interfaces:
+ 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["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):
+ if iface in iNetwork.wlan_interfaces:
+ try:
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+ 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["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
+ except ImportError:
+ pass
+ else:
+ iStatus.stopWlanConsole()
+
git.cweiske.de / enigma2.git / blobdiff