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, ConfigPassword, 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 re import compile as re_compile, search as re_search
-class InterfaceList(MenuList):
- def __init__(self, list, enableWrapAround=False):
- MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent)
- self.l.setFont(0, gFont("Regular", 20))
- self.l.setItemHeight(30)
-
-def InterfaceEntryComponent(index,name,default,active ):
- res = [
- (index),
- MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name)
- ]
- num_configured_if = len(iNetwork.getConfiguredAdapters())
- if num_configured_if >= 2:
- if default is True:
- png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
- if default is False:
- png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
- res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png))
- if active is True:
- png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
- if active is False:
- png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
- res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2))
- return res
-
-
class NetworkAdapterSelection(Screen,HelpableScreen):
def __init__(self, session):
Screen.__init__(self, session)
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")),
{
"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.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getInstalledAdapters()]
+
self.list = []
- self["list"] = InterfaceList(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 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):
self.list = []
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()
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()
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):
self.list = []
ConfigListScreen.__init__(self, self.list)
self.createSetup()
-
+
def createConfig(self):
self.nameservers = iNetwork.getNameserverList()
self.nameserverEntries = [ NoSave(ConfigIP(default=nameserver)) for nameserver in self.nameservers]
def remove(self):
print "currentIndex:", self["config"].getCurrentIndex()
-
index = self["config"].getCurrentIndex()
if index < len(self.nameservers):
iNetwork.removeNameserver(self.nameservers[index])
class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
- def __init__(self, session, networkinfo, essid=None, aplist=None):
+ def __init__(self, session, networkinfo, essid=None):
Screen.__init__(self, session)
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["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
- "cancel": (self.cancel, _("exit network adapter setup menu")),
- "ok": (self.ok, _("select menu entry")),
+ "cancel": (self.keyCancel, _("exit network adapter configuration")),
+ "ok": (self.keySave, _("activate network adapter configuration")),
})
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
- "red": (self.cancel, _("exit network adapter configuration")),
+ "red": (self.keyCancel, _("exit network adapter configuration")),
"blue": (self.KeyBlue, _("open nameserver configuration")),
})
self["actions"] = NumberActionMap(["SetupActions"],
{
- "ok": self.ok,
+ "ok": self.keySave,
}, -2)
self.list = []
self.gatewayEntry = None
self.hiddenSSID = None
self.wlanSSID = None
- self.encryptionEnabled = None
- self.encryptionKey = None
+ self.encryption = None
self.encryptionType = None
- self.nwlist = None
+ self.encryptionKey = None
self.encryptionlist = None
self.weplist = None
self.wsconfig = None
self.default = None
- if self.iface == "wlan0" or self.iface == "ath0" :
- from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
- self.w = Wlan(self.iface)
+ if iNetwork.isWirelessInterface(self.iface):
+ from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant
self.ws = wpaSupplicant()
self.encryptionlist = []
+ self.encryptionlist.append(("Unencrypted", _("Unencrypted")))
self.encryptionlist.append(("WEP", _("WEP")))
self.encryptionlist.append(("WPA", _("WPA")))
- self.encryptionlist.append(("WPA2", _("WPA2")))
self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
+ self.encryptionlist.append(("WPA2", _("WPA2")))
self.weplist = []
self.weplist.append("ASCII")
self.weplist.append("HEX")
- if self.aplist is not None:
- self.nwlist = self.aplist
- self.nwlist.sort(key = lambda x: x[0])
- else:
- self.nwlist = []
- self.aps = None
- try:
- self.aps = self.w.getNetworkList()
- if self.aps is not None:
- print "[NetworkSetup.py] got Accespoints!"
- 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...",_("hidden network")))
- 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.wsconfig = self.ws.loadConfig(self.iface)
+ if self.essid is None:
+ self.essid = self.wsconfig['ssid']
- 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))
+ 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.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
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
- 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.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.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.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)
self.createSetup()
if self["config"].getCurrent() == self.gatewayEntry:
self.createSetup()
- if self.iface == "wlan0" or self.iface == "ath0" :
- if self["config"].getCurrent() == self.wlanSSID:
- self.createSetup()
- if self["config"].getCurrent() == self.encryptionEnabled:
- self.createSetup()
- if self["config"].getCurrent() == self.encryptionType:
+ if iNetwork.isWirelessInterface(self.iface):
+ if self["config"].getCurrent() == self.encryption:
self.createSetup()
def keyLeft(self):
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 ok(self):
- current = self["config"].getCurrent()
- if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
- if current[1].help_window.instance is not None:
- current[1].help_window.instance.hide()
- elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
- if current[1].help_window.instance is not None:
- current[1].help_window.instance.hide()
- self.session.openWithCallback(self.applyConfig, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) )
+ def 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 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(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, "gateway", self.gatewayConfigEntry.value)
else:
iNetwork.removeAdapterAttribute(self.iface, "gateway")
- if self.extended is not None and self.configStrings is not None:
+
+ 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.ws.writeConfig(self.iface)
+
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)
+ 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.cancel()
+ self.keyCancel()
+
+ 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:
def applyConfigfinishedCB(self,data):
if data is True:
- num_configured_if = len(iNetwork.getConfiguredAdapters())
- if num_configured_if >= 2:
- self.session.openWithCallback(self.secondIfaceFoundCB, MessageBox, _("Your network configuration has been activated.\nA second configured interface has been found.\n\nDo you want to disable the second network interface?"), default = 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:
- 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 secondIfaceFoundCB(self,data):
- if data is False:
- self.close('ok')
- else:
- configuredInterfaces = iNetwork.getConfiguredAdapters()
- for interface in configuredInterfaces:
- if interface == self.iface:
- continue
- iNetwork.setAdapterAttribute(interface, "up", False)
- iNetwork.deactivateInterface(interface)
- self.applyConfig(True)
+ 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 cancel(self):
+ def keyCancelConfirm(self, result):
+ if not result:
+ return
if self.oldInterfaceState is False:
- iNetwork.deactivateInterface(self.iface,self.cancelCB)
+ 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 cancelCB(self,data):
+ 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.ok()
+ self.keySave()
def NameserverSetupClosed(self, *ret):
iNetwork.loadNameserverConfig()
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()
class AdapterSetupConfiguration(Screen, HelpableScreen):
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.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.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",
{
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.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)
self.loadDescription()
def loadDescription(self):
- print self["menulist"].getCurrent()[1]
if self["menulist"].getCurrent()[1] == 'edit':
self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext )
if self["menulist"].getCurrent()[1] == 'test':
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 )
+ 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(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
def updateStatusbar(self, data = None):
+ self.mainmenu = self.genMainMenu()
+ self["menulist"].l.setList(self.mainmenu)
self["IFtext"].setText(_("Network:"))
self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
self["Statustext"].setText(_("Link:"))
- if self.iface == 'wlan0' or self.iface == 'ath0':
+ if iNetwork.isWirelessInterface(self.iface):
try:
- from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ 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:
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"):
def AdapterSetupClosed(self, *ret):
if ret is not None and len(ret):
- if ret[0] == 'ok' and (self.iface == 'wlan0' or self.iface == 'ath0') and iNetwork.getAdapterAttribute(self.iface, "up") is True:
+ 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
- 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.WlanStatusClosed, WlanStatus,self.iface)
else:
- # Display Wlan not available Message
- self.showErrorMessage()
+ self.showErrorMessage() # Display Wlan not available Message
else:
- self.mainmenu = self.genMainMenu()
- self["menulist"].l.setList(self.mainmenu)
self.updateStatusbar()
else:
- self.mainmenu = self.genMainMenu()
- self["menulist"].l.setList(self.mainmenu)
self.updateStatusbar()
def WlanStatusClosed(self, *ret):
if ret is not None and len(ret):
- from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
iStatus.stopWlanConsole()
- self.mainmenu = self.genMainMenu()
- self["menulist"].l.setList(self.mainmenu)
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:
- from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
iStatus.stopWlanConsole()
- self.mainmenu = self.genMainMenu()
- self["menulist"].l.setList(self.mainmenu)
self.updateStatusbar()
def restartLan(self, ret = False):
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,Status
+ 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:
+ 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["statuspic"].setPixmapNum(0)
- self["statuspic"].show()
+ 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):
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["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["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 iStatus,Status
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
except:
self["Network"].setForegroundColorNum(1)
self["Network"].setText(_("disconnected"))
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):
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:
+ 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)
iNetwork.stopLinkStateConsole()
iNetwork.stopDNSConsole()
try:
- from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
+ from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
except ImportError:
pass
else:
iStatus.stopWlanConsole()
-
+
git.cweiske.de / enigma2.git / blobdiff