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 Screens.VirtualKeyBoard import VirtualKeyBoard
+from Screens.HelpMenu import HelpableScreen
from Components.Network import iNetwork
+from Components.Sources.StaticText import StaticText
+from Components.Sources.Boolean import Boolean
+from Components.Sources.List import List
from Components.Label import Label,MultiColorLabel
from Components.Pixmap import Pixmap,MultiPixmap
from Components.MenuList import MenuList
-from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigSelection, getConfigListEntry, ConfigNothing
+from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing, ConfigBoolean
from Components.ConfigList import ConfigListScreen
from Components.PluginComponent import plugins
from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
+from Components.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
+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
-from Tools.Directories import resolveFilename, SCOPE_PLUGINS
-from Tools.Directories import SCOPE_SKIN_IMAGE,SCOPE_PLUGINS, resolveFilename
-from Tools.LoadPixmap import LoadPixmap
-from enigma import RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont
-
-class InterfaceList(MenuList):
- def __init__(self, list, enableWrapAround=False):
- MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent)
- self.l.setFont(0, gFont("Regular", 20))
- self.l.setItemHeight(30)
-
-def InterfaceEntryComponent(index,name,default,active ):
- res = [ (index) ]
- res.append(MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name))
- if default is True:
- png = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/buttons/button_blue.png"))
- if default is False:
- png = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/buttons/button_blue_off.png"))
- res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png))
- if active is True:
- png2 = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/icons/lock_on.png"))
- if active is False:
- png2 = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, "skin_default/icons/lock_error.png"))
- res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2))
- return res
-
-
-class NetworkAdapterSelection(Screen):
+
+class NetworkAdapterSelection(Screen,HelpableScreen):
def __init__(self, session):
Screen.__init__(self, session)
-
- self.wlan_errortext = _("No working wireless networkadapter found.\nPlease verify that you have attached a compatible WLAN USB Stick and your Network is configured correctly.")
- self.lan_errortext = _("No working local networkadapter found.\nPlease verify that you have attached a network cable and your Network is configured correctly.")
+ HelpableScreen.__init__(self)
- self["ButtonBluetext"] = Label(_("Set as default Interface"))
- self["ButtonRedtext"] = Label(_("Close"))
- self["introduction"] = Label(_("Press OK to edit the settings."))
+ 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["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.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
+ if not self.adapters:
+ self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getConfiguredAdapters()]
+
if len(self.adapters) == 0:
- self.onFirstExecBegin.append(self.NetworkFallback)
+ self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getInstalledAdapters()]
self.list = []
- self["list"] = InterfaceList(self.list)
+ self["list"] = List(self.list)
self.updateList()
- self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
- {
- "ok": self.okbuttonClick,
- "cancel": self.close,
- "blue": self.setDefaultInterface,
- "red": self.close
- }, -2)
if len(self.adapters) == 1:
self.onFirstExecBegin.append(self.okbuttonClick)
+ self.onClose.append(self.cleanup)
+
+ def buildInterfaceList(self,iface,name,default,active ):
+ divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
+ defaultpng = None
+ activepng = None
+ description = None
+ interfacepng = None
+
+ if not iNetwork.isWirelessInterface(iface):
+ if active is True:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-active.png"))
+ elif active is False:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired-inactive.png"))
+ else:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wired.png"))
+ elif iNetwork.isWirelessInterface(iface):
+ if active is True:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-active.png"))
+ elif active is False:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless-inactive.png"))
+ else:
+ interfacepng = LoadPixmap(resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/network_wireless.png"))
+
+ num_configured_if = len(iNetwork.getConfiguredAdapters())
+ if num_configured_if >= 2:
+ if default is True:
+ defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
+ elif default is False:
+ defaultpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
+ if active is True:
+ activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
+ elif active is False:
+ activepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
+
+ description = iNetwork.getFriendlyAdapterDescription(iface)
+
+ return((iface, name, description, interfacepng, defaultpng, activepng, divpng))
def updateList(self):
- iNetwork.getInterfaces()
self.list = []
default_gw = None
- num_configured_if = len(iNetwork.configuredInterfaces)
+ 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")
result = fp.read()
fp.close()
default_gw = result
-
- if len(self.adapters) == 0: # no interface available => display only eth0
- self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
- else:
- for x in self.adapters:
- if x[1] == default_gw:
- default_int = True
- else:
- default_int = False
- if iNetwork.getAdapterAttribute(x[1], 'up') is True:
- active_int = True
- else:
- active_int = False
- self.list.append(InterfaceEntryComponent(index = x[1],name = _(x[0]),default=default_int,active=active_int ))
- self["list"].l.setList(self.list)
+
+ 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_if > 1 and (not old_default_gw or old_default_gw != selection[0]):
+ 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()
- iNetwork.restartNetwork()
- self.updateList()
- elif old_default_gw and num_if < 2:
+ self.restartLan()
+ elif old_default_gw and num_configured_if < 2:
unlink("/etc/default_gw")
- iNetwork.restartNetwork()
- self.updateList()
+ self.restartLan()
def okbuttonClick(self):
selection = self["list"].getCurrent()
- print "selection",selection
if selection is not None:
self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0])
else:
self.updateList()
- def NetworkFallback(self):
- if iNetwork.configuredInterfaces.has_key('wlan0') is True:
- self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
- if iNetwork.configuredInterfaces.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 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])
- def ErrorMessageClosed(self, *ret):
- if iNetwork.configuredInterfaces.has_key('wlan0') is True:
- self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
- elif iNetwork.configuredInterfaces.has_key('ath0') is True:
- self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
- else:
- self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
-class NameserverSetup(Screen, ConfigListScreen):
+class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
def __init__(self, session):
Screen.__init__(self, session)
- iNetwork.getInterfaces()
+ HelpableScreen.__init__(self)
self.backupNameserverList = iNetwork.getNameserverList()[:]
print "backup-list:", self.backupNameserverList
- self["ButtonGreentext"] = Label(_("Add"))
- self["ButtonYellowtext"] = Label(_("Delete"))
- self["ButtonRedtext"] = Label(_("Close"))
- self["introduction"] = Label(_("Press OK to activate the settings."))
+ self["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,
- "red": self.cancel,
- "green": self.add,
- "yellow": self.remove
}, -2)
-
+
self.list = []
ConfigListScreen.__init__(self, self.list)
self.createSetup()
-
+
def createConfig(self):
self.nameservers = iNetwork.getNameserverList()
- self.nameserverEntries = []
-
- for nameserver in self.nameservers:
- self.nameserverEntries.append(NoSave(ConfigIP(default=nameserver)))
+ 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)
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,essid=None, aplist=None):
+
+
+class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
+ def __init__(self, session, networkinfo, essid=None):
Screen.__init__(self, session)
+ HelpableScreen.__init__(self)
self.session = session
- self.iface = iface
- self.essid = essid
- self.aplist = aplist
+ if isinstance(networkinfo, (list, tuple)):
+ self.iface = networkinfo[0]
+ self.essid = networkinfo[1]
+ else:
+ self.iface = networkinfo
+ self.essid = essid
+
self.extended = None
+ self.applyConfigRef = None
+ self.finished_cb = None
+ self.oktext = _("Press OK on your remote control to continue.")
self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
- iNetwork.getInterfaces()
self.createConfig()
-
+
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.keyCancel, _("exit network adapter configuration")),
+ "ok": (self.keySave, _("activate network adapter configuration")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.keyCancel, _("exit network adapter configuration")),
+ })
+
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,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()
+
+ 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())
if self.ipConfigEntry.getText() is not None:
- self["IP"].setText(self.ipConfigEntry.getText())
+ if self.ipConfigEntry.getText() == "0.0.0.0":
+ self["IP"].setText(_("N/A"))
+ else:
+ self["IP"].setText(self.ipConfigEntry.getText())
else:
- self["IP"].setText([0,0,0,0])
- self["Mask"].setText(self.netmaskConfigEntry.getText())
+ self["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"):
- self["Gateway"].setText(self.gatewayConfigEntry.getText())
+ 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"].hide()
- self["Gatewaytext"].hide()
+ 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.SSIDscan = None
+ self.DNSConfigEntry = None
+ self.hiddenSSID = None
self.wlanSSID = None
- self.manualwlanSSID = None
- self.encryptionEnabled = None
+ self.encryption = None
+ self.encryptionType = None
self.encryptionKey = 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
+
+ if iNetwork.isWirelessInterface(self.iface):
+ from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant
self.ws = wpaSupplicant()
- list = []
- list.append(_("WEP"))
- list.append(_("WPA"))
- list.append(_("WPA2"))
- if self.aplist is not None:
- self.nwlist = self.aplist
- self.nwlist.sort(key = lambda x: x[0])
- else:
- self.nwlist = []
- self.w = None
- self.aps = None
- try:
- self.w = Wlan(self.iface)
- self.aps = self.w.getNetworkList()
- if self.aps is not None:
- print "[NetworkSetup.py] got Accespoints!"
- for ap in aps:
- a = aps[ap]
- if a['active']:
- if a['essid'] == "":
- a['essid'] = a['bssid']
- self.nwlist.append( a['essid'])
- self.nwlist.sort(key = lambda x: x[0])
- except:
- self.nwlist.append("No Networks found")
-
- self.wsconfig = self.ws.loadConfig()
- self.default = self.essid or self.wsconfig['ssid']
- if self.default not in self.nwlist:
- self.nwlist.append(self.default)
- config.plugins.wlan.essidscan = NoSave(ConfigYesNo(default = self.wsconfig['ssidscan']))
- if self.wsconfig['ssidscan'] is True:
- config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
- else:
- config.plugins.wlan.essid = NoSave(ConfigText(default = self.default, visible_width = 50, fixed_size = False))
- config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
- config.plugins.wlan.encryption.type = NoSave(ConfigSelection(list, default = self.wsconfig['encryption_type'] ))
- config.plugins.wlan.encryption.psk = NoSave(ConfigText(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
-
+ self.encryptionlist = []
+ self.encryptionlist.append(("Unencrypted", _("Unencrypted")))
+ self.encryptionlist.append(("WEP", _("WEP")))
+ self.encryptionlist.append(("WPA", _("WPA")))
+ self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+ self.encryptionlist.append(("WPA2", _("WPA2")))
+ self.weplist = []
+ self.weplist.append("ASCII")
+ self.weplist.append("HEX")
+
+ self.wsconfig = self.ws.loadConfig(self.iface)
+ if self.essid is None:
+ self.essid = self.wsconfig['ssid']
+
+ config.plugins.wlan.hiddenessid = NoSave(ConfigYesNo(default = self.wsconfig['hiddenessid']))
+ config.plugins.wlan.essid = NoSave(ConfigText(default = self.essid, visible_width = 50, fixed_size = False))
+ config.plugins.wlan.encryption = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption'] ))
+ config.plugins.wlan.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['wepkeytype'] ))
+ config.plugins.wlan.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.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]))
+ if iNetwork.getAdapterAttribute(self.iface, "dns-nameservers"):
+ self.dnsconfigdefault=True
+ else:
+ self.dnsconfigdefault=False
+ self.hasDNSConfigEntry = NoSave(ConfigYesNo(default=self.dnsconfigdefault or False))
+ manualNameservers = (iNetwork.getInterfacesNameserverList(self.iface) + [[0,0,0,0]] * 2)[0:2]
+ self.manualPrimaryDNS = NoSave(ConfigIP(default=manualNameservers[0]))
+ self.manualSecondaryDNS = NoSave(ConfigIP(default=manualNameservers[1]))
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.gatewayEntry)
if self.hasGatewayConfigEntry.value:
self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
-
- self.extended = None
+
+ self.DNSConfigEntry = getConfigListEntry(_("Use Manual dns-nameserver"), self.hasDNSConfigEntry)
+ if self.dhcpConfigEntry.value:
+ self.list.append(self.DNSConfigEntry)
+ if self.hasDNSConfigEntry.value or not self.dhcpConfigEntry.value:
+ self.list.append(getConfigListEntry(_('Primary DNS'), self.manualPrimaryDNS))
+ self.list.append(getConfigListEntry(_('Secondary DNS'), self.manualSecondaryDNS))
+
+ self.extended = None
+ self.configStrings = None
for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
callFnc = p.__call__["ifaceSupported"](self.iface)
if callFnc is not None:
self.extended = callFnc
if p.__call__.has_key("configStrings"):
self.configStrings = p.__call__["configStrings"]
- else:
- self.configStrings = None
- self.SSIDscan = getConfigListEntry(_("Automatic SSID lookup"), config.plugins.wlan.essidscan)
- self.list.append(self.SSIDscan)
- self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
+
+ self.hiddenSSID = getConfigListEntry(_("Hidden network"), config.plugins.wlan.hiddenessid)
+ self.list.append(self.hiddenSSID)
+ self.wlanSSID = getConfigListEntry(_("Networkname (SSID)"), config.plugins.wlan.essid)
self.list.append(self.wlanSSID)
- self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
- self.list.append(self.encryptionEnabled)
+ self.encryption = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption)
+ self.list.append(self.encryption)
+
+ self.encryptionType = getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.wepkeytype)
+ self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.psk)
- if config.plugins.wlan.encryption.enabled.value:
- self.list.append(getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type))
- self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
+ if config.plugins.wlan.encryption.value != "Unencrypted":
+ if config.plugins.wlan.encryption.value == 'WEP':
+ self.list.append(self.encryptionType)
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 == "wlan0" or self.iface == "ath0" :
- if self["config"].getCurrent() == self.SSIDscan:
- if config.plugins.wlan.essidscan.value is True:
- config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
- else:
- config.plugins.wlan.essid = NoSave(ConfigText(default = self.default, visible_width = 50, fixed_size = False))
- self.createSetup()
- if self["config"].getCurrent() == self.encryptionEnabled:
+ if self["config"].getCurrent() == self.DNSConfigEntry:
+ self.createSetup()
+ if iNetwork.isWirelessInterface(self.iface):
+ if self["config"].getCurrent() == self.encryption:
self.createSetup()
-
+
def keyLeft(self):
ConfigListScreen.keyLeft(self)
self.newConfig()
def keyRight(self):
ConfigListScreen.keyRight(self)
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 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):
- iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
- iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
- iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
- iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
- if self.hasGatewayConfigEntry.value:
- iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
+ def secondIfaceFoundCB(self,data):
+ if data is False:
+ self.applyConfig(True)
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.deactivateNetworkConfig()
- iNetwork.activateNetworkConfig()
- self.close()
+ configuredInterfaces = iNetwork.getConfiguredAdapters()
+ for interface in configuredInterfaces:
+ if interface == self.iface:
+ continue
+ iNetwork.setAdapterAttribute(interface, "up", False)
+ iNetwork.deactivateInterface(configuredInterfaces,self.deactivateSecondInterfaceCB)
+
+ def deactivateSecondInterfaceCB(self, data):
+ if data is True:
+ self.applyConfig(True)
+
+ def applyConfig(self, ret = False):
+ if (ret == True):
+ self.applyConfigRef = None
+ iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
+ iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
+ iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
+ iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
+ if self.hasGatewayConfigEntry.value:
+ iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
+ else:
+ iNetwork.removeAdapterAttribute(self.iface, "gateway")
- def cancel(self):
- iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
- self.activateInterfaceEntry.value = self.oldInterfaceState
- if self.activateInterfaceEntry.value is False:
- iNetwork.deactivateInterface(self.iface)
- iNetwork.getInterfaces()
- self.close()
+ if self.hasDNSConfigEntry.value or not self.dhcpConfigEntry.value:
+ interfacesDnsLines = self.makeLineDnsNameservers([self.manualPrimaryDNS.value, self.manualSecondaryDNS.value])
+ if interfacesDnsLines == "" :
+ interfacesDnsLines = False
+ iNetwork.setAdapterAttribute(self.iface, "dns-nameservers", interfacesDnsLines)
+ else:
+ iNetwork.setAdapterAttribute(self.iface, "dns-nameservers", False)
+
+ if (self.extended is not None and self.configStrings is not None):
+ iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
+ self.ws.writeConfig(self.iface)
+
+ if self.activateInterfaceEntry.value is False:
+ iNetwork.deactivateInterface(self.iface,self.deactivateInterfaceCB)
+ iNetwork.writeNetworkConfig()
+ self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+ else:
+ if self.oldInterfaceState is False:
+ iNetwork.activateInterface(self.iface,self.deactivateInterfaceCB)
+ else:
+ iNetwork.deactivateInterface(self.iface,self.activateInterfaceCB)
+ iNetwork.writeNetworkConfig()
+ self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
+ else:
+ self.keyCancel()
- def run(self):
- self.ok()
+ def deactivateInterfaceCB(self, data):
+ if data is True:
+ self.applyConfigDataAvail(True)
+
+ def activateInterfaceCB(self, data):
+ if data is True:
+ iNetwork.activateInterface(self.iface,self.applyConfigDataAvail)
+
+ def applyConfigDataAvail(self, data):
+ if data is True:
+ iNetwork.getInterfaces(self.getInterfacesDataAvail)
+
+ def 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()
self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
self.createSetup()
self.layoutFinished()
-
-class AdapterSetupConfiguration(Screen):
+ def cleanup(self):
+ iNetwork.stopLinkStateConsole()
+
+ def hideInputHelp(self):
+ current = self["config"].getCurrent()
+ if current == self.wlanSSID:
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+ elif current == self.encryptionKey and config.plugins.wlan.encryption.value is not "Unencrypted":
+ if current[1].help_window.instance is not None:
+ current[1].help_window.instance.hide()
+
+ def makeLineDnsNameservers(self, nameservers = []):
+ line = ""
+ entry = ' '.join([("%d.%d.%d.%d" % tuple(x)) for x in nameservers if x != [0, 0, 0, 0] ])
+ if len(entry):
+ line+="\tdns-nameservers %s\n" % entry
+ return line
+
+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["description"] = Label()
- self["IFtext"] = Label()
- self["IF"] = Label()
- self["BottomBG"] = Label()
- self["Statustext"] = Label()
+ self["key_red"] = StaticText(_("Close"))
+ self["description"] = StaticText()
+ self["IFtext"] = StaticText()
+ self["IF"] = StaticText()
+ self["Statustext"] = StaticText()
self["statuspic"] = MultiPixmap()
self["statuspic"].hide()
- self["BottomBG"] = Pixmap()
- self["ButtonRed"] = Pixmap()
- self["ButtonRedtext"] = Label(_("Close"))
self.oktext = _("Press OK on your remote control to continue.")
- self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
- self.errortext = _("No working wireless interface found.\n Please verify that you have attached a compatible WLAN device or enable you local network interface.")
+ self.reboottext = _("Your STB 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.missingwlanplugintxt = _("The wireless LAN plugin is not installed!\nPlease install it.")
+ self["WizardActions"] = HelpableActionMap(self, "WizardActions",
+ {
+ "up": (self.up, _("move up to previous entry")),
+ "down": (self.down, _("move down to next entry")),
+ "left": (self.left, _("move up to first entry")),
+ "right": (self.right, _("move down to last entry")),
+ })
+
+ self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
+ {
+ "cancel": (self.close, _("exit networkadapter setup menu")),
+ "ok": (self.ok, _("select menu entry")),
+ })
+
+ self["ColorActions"] = HelpableActionMap(self, "ColorActions",
+ {
+ "red": (self.close, _("exit networkadapter setup menu")),
+ })
+
self["actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
{
"ok": self.ok,
"right": self.right,
}, -2)
- iNetwork.getInterfaces()
- self.onLayoutFinish.append(self.layoutFinished)
self.updateStatusbar()
+ self.onLayoutFinish.append(self.layoutFinished)
+ self.onClose.append(self.cleanup)
+
+
+ def queryWirelessDevice(self,iface):
+ try:
+ from pythonwifi.iwlibs import Wireless
+ import errno
+ except ImportError:
+ return False
+ else:
+ try:
+ ifobj = Wireless(iface) # a Wireless NIC Object
+ wlanresponse = ifobj.getAPaddr()
+ except IOError, (error_no, error_str):
+ if error_no in (errno.EOPNOTSUPP, errno.ENODEV, errno.EPERM):
+ return False
+ else:
+ print "error: ",error_no,error_str
+ return True
+ else:
+ return True
def ok(self):
+ self.cleanup()
if self["menulist"].getCurrent()[1] == 'edit':
- if self.iface == 'wlan0' or self.iface == 'ath0':
+ if iNetwork.isWirelessInterface(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 )
+ self.session.open(MessageBox, self.missingwlanplugintxt, 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.
+ if self.queryWirelessDevice(self.iface):
self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
else:
- # Display Wlan not available Message
- self.showErrorMessage()
+ self.showErrorMessage() # Display Wlan not available Message
else:
self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
if self["menulist"].getCurrent()[1] == 'test':
if self["menulist"].getCurrent()[1] == 'scanwlan':
try:
from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
- from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
except ImportError:
- self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
+ self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
else:
- ifobj = Wireless(self.iface) # a Wireless NIC Object
- self.wlanresponse = ifobj.getStatistics()
- if self.wlanresponse[0] != 19:
+ if self.queryWirelessDevice(self.iface):
self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
else:
- # Display Wlan not available Message
- self.showErrorMessage()
+ self.showErrorMessage() # Display Wlan not available Message
if self["menulist"].getCurrent()[1] == 'wlanstatus':
try:
from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
- 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.AdapterSetupClosed, WlanStatus,self.iface)
- #self.session.open(WlanStatus,self.iface)
+ self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ if self.queryWirelessDevice(self.iface):
+ self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
else:
- # Display Wlan not available Message
- self.showErrorMessage()
+ self.showErrorMessage() # Display Wlan not available Message
if self["menulist"].getCurrent()[1] == 'lanrestart':
self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
if self["menulist"].getCurrent()[1] == 'openwizard':
from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
- self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard)
+ self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, self.iface)
if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
self.extended = self["menulist"].getCurrent()[1][2]
self.extended(self.session, self.iface)
def loadDescription(self):
if self["menulist"].getCurrent()[1] == 'edit':
- self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext )
+ self["description"].setText(_("Edit the network configuration of your STB.\n" ) + self.oktext )
if self["menulist"].getCurrent()[1] == 'test':
- self["description"].setText(_("Test the network configuration of your Dreambox.\n" ) + self.oktext )
+ self["description"].setText(_("Test the network configuration of your STB.\n" ) + self.oktext )
if self["menulist"].getCurrent()[1] == 'dns':
- self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext )
+ self["description"].setText(_("Edit the Nameserver configuration of your STB.\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':
if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
- def updateStatusbar(self):
+ 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' or self.iface == 'ath0':
+ if iNetwork.isWirelessInterface(self.iface):
try:
- from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
- w = Wlan(self.iface)
- stats = w.getStatus()
- if stats['BSSID'] == "00:00:00:00:00:00":
- self["statuspic"].setPixmapNum(1)
- else:
- self["statuspic"].setPixmapNum(0)
- self["statuspic"].show()
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
except:
- self["statuspic"].setPixmapNum(1)
- self["statuspic"].show()
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
+ else:
+ iStatus.getDataForInterface(self.iface,self.getInfoCB)
else:
- self.getLinkState(self.iface)
+ iNetwork.getLinkState(self.iface,self.dataAvail)
def doNothing(self):
pass
def genMainMenu(self):
menu = []
menu.append((_("Adapter settings"), "edit"))
- menu.append((_("Nameserver settings"), "dns"))
+# menu.append((_("Nameserver settings"), "dns"))
menu.append((_("Network test"), "test"))
menu.append((_("Restart network"), "lanrestart"))
callFnc = p.__call__["ifaceSupported"](self.iface)
if callFnc is not None:
self.extended = callFnc
- print p.__call__
if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
menu.append((_("Scan Wireless Networks"), "scanwlan"))
if iNetwork.getAdapterAttribute(self.iface, "up"):
return menu
def AdapterSetupClosed(self, *ret):
- self.mainmenu = self.genMainMenu()
- self["menulist"].l.setList(self.mainmenu)
- iNetwork.getInterfaces()
- self.updateStatusbar()
+ if ret is not None and len(ret):
+ if ret[0] == 'ok' and (iNetwork.isWirelessInterface(self.iface) and iNetwork.getAdapterAttribute(self.iface, "up") is True):
+ try:
+ from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
+ except ImportError:
+ self.session.open(MessageBox, self.missingwlanplugintxt, type = MessageBox.TYPE_INFO,timeout = 10 )
+ else:
+ if self.queryWirelessDevice(self.iface):
+ self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
+ else:
+ self.showErrorMessage() # Display Wlan not available Message
+ 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])
+ self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0])
else:
- self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,None,ret[0])
-
-
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+ 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"].setPixmapNum(0)
- else:
- self["statuspic"].setPixmapNum(1)
- self["statuspic"].show()
+ 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.stopActivateInterfaceConsole()
+ 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]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == False:
+ self.LinkState = False
+ self["statuspic"].setPixmapNum(1)
+ self["statuspic"].show()
+ else:
+ self.LinkState = True
+ iNetwork.checkNetworkState(self.checkNetworkCB)
+
+ def checkNetworkCB(self,data):
+ try:
+ 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()
+ except:
+ pass
class NetworkAdapterTest(Screen):
def __init__(self, session,iface):
Screen.__init__(self, session)
self.iface = iface
- iNetwork.getInterfaces()
+ 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"],
{
self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
{
- "red": self.close,
- "back": self.close,
+ "red": self.cancel,
+ "back": self.cancel,
}, -2)
self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
{
self.nextStepTimer = eTimer()
self.nextStepTimer.callback.append(self.nextStepTimerFire)
+ def cancel(self):
+ if self.oldInterfaceState is False:
+ iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
+ iNetwork.deactivateInterface(self.iface)
+ self.close()
+
def closeInfo(self):
self["shortcuts"].setEnabled(True)
self["infoshortcuts"].setEnabled(False)
self["InfoText"].hide()
self["InfoTextBorder"].hide()
- self["ButtonRedtext"].setText(_("Close"))
+ self["key_red"].setText(_("Close"))
def delTimer(self):
del self.steptimer
def doStep1(self):
self.steptimer = True
self.nextStepTimer.start(3000)
- self["ButtonYellow_Check"].show()
- self["ButtonYellowtext"].show()
+ self["key_yellow"].setText(_("Stop test"))
def doStep2(self):
self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
def doStep3(self):
self["Networktext"].setForegroundColorNum(1)
+ self["Network"].setText(_("Please wait..."))
self.getLinkState(self.iface)
self["NetworkInfo_Text"].setForegroundColorNum(1)
self.steptimer = True
def doStep5(self):
self["IPtext"].setForegroundColorNum(1)
- ret = iNetwork.checkNetworkState()
- if ret == True:
- self["IP"].setForegroundColorNum(2)
- self["IP"].setText(_("confirmed"))
- self["IPInfo_Check"].setPixmapNum(0)
- else:
- self["IP"].setForegroundColorNum(1)
- self["IP"].setText(_("unconfirmed"))
- self["IPInfo_Check"].setPixmapNum(1)
- self["IPInfo_Check"].show()
- self["IPInfo_Text"].setForegroundColorNum(1)
- self.steptimer = True
- self.nextStepTimer.start(3000)
+ self["IP"].setText(_("Please wait..."))
+ iNetwork.checkNetworkState(self.NetworkStatedataAvail)
def doStep6(self):
self.steptimer = False
self.nextStepTimer.stop()
self["DNStext"].setForegroundColorNum(1)
- ret = iNetwork.checkDNSLookup()
- if ret == True:
- self["DNS"].setForegroundColorNum(2)
- self["DNS"].setText(_("confirmed"))
- self["DNSInfo_Check"].setPixmapNum(0)
- else:
- self["DNS"].setForegroundColorNum(1)
- self["DNS"].setText(_("unconfirmed"))
- self["DNSInfo_Check"].setPixmapNum(1)
- self["DNSInfo_Check"].show()
- self["DNSInfo_Text"].setForegroundColorNum(1)
-
- self["EditSettings_Text"].show()
- self["EditSettingsButton"].setPixmapNum(1)
- self["EditSettings_Text"].setForegroundColorNum(2) # active
- self["EditSettingsButton"].show()
- self["ButtonYellow_Check"].setPixmapNum(1)
- self["ButtonGreentext"].setText(_("Restart test"))
- self["ButtonGreen_Check"].setPixmapNum(0)
- self["shortcutsgreen"].setEnabled(False)
- self["shortcutsgreen_restart"].setEnabled(True)
- self["shortcutsyellow"].setEnabled(False)
- self["updown_actions"].setEnabled(True)
- self.activebutton = 6
+ self["DNS"].setText(_("Please wait..."))
+ iNetwork.checkDNSLookup(self.DNSLookupdataAvail)
def KeyGreen(self):
self["shortcutsgreen"].setEnabled(False)
self["shortcutsyellow"].setEnabled(True)
self["updown_actions"].setEnabled(False)
- self["ButtonYellow_Check"].setPixmapNum(0)
- self["ButtonGreen_Check"].setPixmapNum(1)
+ self["key_yellow"].setText("")
+ self["key_green"].setText("")
self.steptimer = True
self.nextStepTimer.start(1000)
self["shortcutsgreen"].setEnabled(False)
self["shortcutsyellow"].setEnabled(True)
self["updown_actions"].setEnabled(False)
- self["ButtonYellow_Check"].setPixmapNum(0)
- self["ButtonGreen_Check"].setPixmapNum(1)
+ self["key_yellow"].setText("")
+ self["key_green"].setText("")
self.steptimer = True
self.nextStepTimer.start(1000)
self["InfoText"].setText(_("This test detects your configured LAN-Adapter."))
self["InfoTextBorder"].show()
self["InfoText"].show()
- self["ButtonRedtext"].setText(_("Back"))
+ 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"))
+ 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"))
+ 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"))
+ 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"))
+ self["key_red"].setText(_("Back"))
if self.activebutton == 6: # Edit Settings
self.session.open(AdapterSetup,self.iface)
self["shortcutsgreen_restart"].setEnabled(True)
self["shortcutsgreen"].setEnabled(False)
self["shortcutsyellow"].setEnabled(False)
- self["ButtonGreentext"].setText(_("Restart test"))
- self["ButtonYellow_Check"].setPixmapNum(1)
- self["ButtonGreen_Check"].setPixmapNum(0)
+ self["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["EditSettingsButton"].hide()
self["InfoText"].hide()
self["InfoTextBorder"].hide()
- self["ButtonYellow_Check"].hide()
- self["ButtonYellowtext"].hide()
+ self["key_yellow"].setText("")
def setLabels(self):
self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))
self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info"))
self["AdapterInfo_OK"] = Pixmap()
- if self.iface == 'wlan0' or self.iface == 'ath0':
+ if self.iface in iNetwork.wlan_interfaces:
self["Networktext"] = MultiColorLabel(_("Wireless Network"))
else:
self["Networktext"] = MultiColorLabel(_("Local Network"))
self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
self["EditSettingsButton"] = MultiPixmap()
- self["ButtonRedtext"] = Label(_("Close"))
- self["ButtonRed"] = Pixmap()
-
- self["ButtonGreentext"] = Label(_("Start test"))
- self["ButtonGreen_Check"] = MultiPixmap()
-
- self["ButtonYellowtext"] = Label(_("Stop test"))
- self["ButtonYellow_Check"] = MultiPixmap()
+ self["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 == 'wlan0' or iface == 'ath0':
+ if iface in iNetwork.wlan_interfaces:
try:
- from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
- w = Wlan(iface)
- stats = w.getStatus()
- if stats['BSSID'] == "00:00:00:00:00:00":
- self["Network"].setForegroundColorNum(1)
- self["Network"].setText(_("disconnected"))
- self["NetworkInfo_Check"].setPixmapNum(1)
- self["NetworkInfo_Check"].show()
- else:
- self["Network"].setForegroundColorNum(2)
- self["Network"].setText(_("connected"))
- self["NetworkInfo_Check"].setPixmapNum(0)
- self["NetworkInfo_Check"].show()
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
except:
self["Network"].setForegroundColorNum(1)
self["Network"].setText(_("disconnected"))
self["NetworkInfo_Check"].setPixmapNum(1)
self["NetworkInfo_Check"].show()
+ else:
+ iStatus.getDataForInterface(self.iface,self.getInfoCB)
else:
- iNetwork.getLinkState(iface,self.dataAvail)
+ iNetwork.getLinkState(iface,self.LinkStatedataAvail)
- def dataAvail(self,data):
+ def LinkStatedataAvail(self,data):
self.output = data.strip()
- result = self.output.split('\n')
+ result = self.output.splitlines()
pattern = re_compile("Link detected: yes")
for item in result:
if re_search(pattern, item):
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]["essid"] == "off" or status[self.iface]["accesspoint"] == "Not-Associated" or status[self.iface]["accesspoint"] == 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()
projects / vuplus_dvbapp / blobdiff