modify FactoryTest plugin.
[vuplus_dvbapp] / lib / python / Screens / NetworkSetup.py
1 from Screen import Screen
2 from Screens.MessageBox import MessageBox
3 from Screens.InputBox import InputBox
4 from Screens.Standby import *
5 from Screens.VirtualKeyBoard import VirtualKeyBoard
6 from Screens.HelpMenu import HelpableScreen
7 from Components.Network import iNetwork
8 from Components.Sources.StaticText import StaticText
9 from Components.Sources.Boolean import Boolean
10 from Components.Label import Label,MultiColorLabel
11 from Components.Pixmap import Pixmap,MultiPixmap
12 from Components.MenuList import MenuList
13 from Components.config import config, ConfigYesNo, ConfigIP, NoSave, ConfigText, ConfigPassword, ConfigSelection, getConfigListEntry, ConfigNothing
14 from Components.ConfigList import ConfigListScreen
15 from Components.PluginComponent import plugins
16 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
17 from Components.ActionMap import ActionMap, NumberActionMap, HelpableActionMap
18 from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_CURRENT_SKIN
19 from Tools.LoadPixmap import LoadPixmap
20 from Plugins.Plugin import PluginDescriptor
21 from enigma import eTimer, ePoint, eSize, RT_HALIGN_LEFT, eListboxPythonMultiContent, gFont
22 from os import path as os_path, system as os_system, unlink
23 from re import compile as re_compile, search as re_search
24
25
26 class InterfaceList(MenuList):
27         def __init__(self, list, enableWrapAround=False):
28                 MenuList.__init__(self, list, enableWrapAround, eListboxPythonMultiContent)
29                 self.l.setFont(0, gFont("Regular", 20))
30                 self.l.setItemHeight(30)
31
32 def InterfaceEntryComponent(index,name,default,active ):
33         res = [
34                 (index),
35                 MultiContentEntryText(pos=(80, 5), size=(430, 25), font=0, text=name)
36         ]
37         num_configured_if = len(iNetwork.getConfiguredAdapters())
38         if num_configured_if >= 2:
39                 if default is True:
40                         png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue.png"))
41                 if default is False:
42                         png = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/buttons/button_blue_off.png"))
43                 res.append(MultiContentEntryPixmapAlphaTest(pos=(10, 5), size=(25, 25), png = png))
44         if active is True:
45                 png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_on.png"))
46         if active is False:
47                 png2 = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/icons/lock_error.png"))
48         res.append(MultiContentEntryPixmapAlphaTest(pos=(40, 1), size=(25, 25), png = png2))
49         return res
50
51
52 class NetworkAdapterSelection(Screen,HelpableScreen):
53         def __init__(self, session):
54                 Screen.__init__(self, session)
55                 HelpableScreen.__init__(self)
56                 
57                 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.")
58                 self.lan_errortext = _("No working local network adapter found.\nPlease verify that you have attached a network cable and your network is configured correctly.")
59                 self.oktext = _("Press OK on your remote control to continue.")
60                 self.edittext = _("Press OK to edit the settings.")
61                 self.defaulttext = _("Press yellow to set this interface as default interface.")
62                 self.restartLanRef = None
63                 
64                 self["key_red"] = StaticText(_("Close"))
65                 self["key_green"] = StaticText(_("Select"))
66                 self["key_yellow"] = StaticText("")
67                 self["key_blue"] = StaticText("")
68                 self["introduction"] = StaticText(self.edittext)
69                 
70                 self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
71                 
72                 if not self.adapters:
73                         self.onFirstExecBegin.append(self.NetworkFallback)
74                         
75                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
76                         {
77                         "cancel": (self.close, _("exit network interface list")),
78                         "ok": (self.okbuttonClick, _("select interface")),
79                         })
80
81                 self["ColorActions"] = HelpableActionMap(self, "ColorActions",
82                         {
83                         "red": (self.close, _("exit network interface list")),
84                         "green": (self.okbuttonClick, _("select interface")),
85                         "blue": (self.openNetworkWizard, _("Use the Networkwizard to configure selected network adapter")),
86                         })
87                 
88                 self["DefaultInterfaceAction"] = HelpableActionMap(self, "ColorActions",
89                         {
90                         "yellow": (self.setDefaultInterface, [_("Set interface as default Interface"),_("* Only available if more than one interface is active.")] ),
91                         })
92
93                 self.list = []
94                 self["list"] = InterfaceList(self.list)
95                 self.updateList()
96
97                 if len(self.adapters) == 1:
98                         self.onFirstExecBegin.append(self.okbuttonClick)
99                 self.onClose.append(self.cleanup)
100
101
102         def updateList(self):
103                 self.list = []
104                 default_gw = None
105                 num_configured_if = len(iNetwork.getConfiguredAdapters())
106                 if num_configured_if >= 2:
107                         self["key_yellow"].setText(_("Default"))
108                         self["introduction"].setText(self.defaulttext)
109                         self["DefaultInterfaceAction"].setEnabled(True)
110                 else:
111                         self["key_yellow"].setText("")
112                         self["introduction"].setText(self.edittext)
113                         self["DefaultInterfaceAction"].setEnabled(False)
114
115                 if num_configured_if < 2 and os_path.exists("/etc/default_gw"):
116                         unlink("/etc/default_gw")
117                         
118                 if os_path.exists("/etc/default_gw"):
119                         fp = file('/etc/default_gw', 'r')
120                         result = fp.read()
121                         fp.close()
122                         default_gw = result
123                                         
124                 if len(self.adapters) == 0: # no interface available => display only eth0
125                         self.list.append(InterfaceEntryComponent("eth0",iNetwork.getFriendlyAdapterName('eth0'),True,True ))
126                 else:
127                         for x in self.adapters:
128                                 if x[1] == default_gw:
129                                         default_int = True
130                                 else:
131                                         default_int = False
132                                 if iNetwork.getAdapterAttribute(x[1], 'up') is True:
133                                         active_int = True
134                                 else:
135                                         active_int = False
136                                 self.list.append(InterfaceEntryComponent(index = x[1],name = _(x[0]),default=default_int,active=active_int ))
137                 
138                 if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
139                         self["key_blue"].setText(_("NetworkWizard"))
140                 self["list"].l.setList(self.list)
141
142         def setDefaultInterface(self):
143                 selection = self["list"].getCurrent()
144                 num_if = len(self.list)
145                 old_default_gw = None
146                 num_configured_if = len(iNetwork.getConfiguredAdapters())
147                 if os_path.exists("/etc/default_gw"):
148                         fp = open('/etc/default_gw', 'r')
149                         old_default_gw = fp.read()
150                         fp.close()
151                 if num_configured_if > 1 and (not old_default_gw or old_default_gw != selection[0]):
152                         fp = open('/etc/default_gw', 'w+')
153                         fp.write(selection[0])
154                         fp.close()
155                         self.restartLan()
156                 elif old_default_gw and num_configured_if < 2:
157                         unlink("/etc/default_gw")
158                         self.restartLan()
159
160         def okbuttonClick(self):
161                 selection = self["list"].getCurrent()
162                 if selection is not None:
163                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, selection[0])
164
165         def AdapterSetupClosed(self, *ret):
166                 if len(self.adapters) == 1:
167                         self.close()
168                 else:
169                         self.updateList()
170
171         def NetworkFallback(self):
172                 if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
173                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
174                 if iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
175                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.wlan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
176                 else:
177                         self.session.openWithCallback(self.ErrorMessageClosed, MessageBox, self.lan_errortext, type = MessageBox.TYPE_INFO,timeout = 10)
178
179         def ErrorMessageClosed(self, *ret):
180                 if iNetwork.configuredNetworkAdapters.has_key('wlan0') is True:
181                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'wlan0')
182                 elif iNetwork.configuredNetworkAdapters.has_key('ath0') is True:
183                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'ath0')
184                 else:
185                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetupConfiguration, 'eth0')
186
187         def cleanup(self):
188                 iNetwork.stopLinkStateConsole()
189                 iNetwork.stopRestartConsole()
190                 iNetwork.stopGetInterfacesConsole()
191
192         def restartLan(self):
193                 iNetwork.restartNetwork(self.restartLanDataAvail)
194                 self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while we configure your network..."), type = MessageBox.TYPE_INFO, enable_input = False)
195                         
196         def restartLanDataAvail(self, data):
197                 if data is True:
198                         iNetwork.getInterfaces(self.getInterfacesDataAvail)
199
200         def getInterfacesDataAvail(self, data):
201                 if data is True:
202                         self.restartLanRef.close(True)
203
204         def restartfinishedCB(self,data):
205                 if data is True:
206                         self.updateList()
207                         self.session.open(MessageBox, _("Finished configuring your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
208
209         def openNetworkWizard(self):
210                 if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
211                         try:
212                                 from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
213                         except ImportError:
214                                 self.session.open(MessageBox, _("The NetworkWizard extension is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
215                         else:
216                                 selection = self["list"].getCurrent()
217                                 if selection is not None:
218                                         self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, selection[0])
219
220
221 class NameserverSetup(Screen, ConfigListScreen, HelpableScreen):
222         def __init__(self, session):
223                 Screen.__init__(self, session)
224                 HelpableScreen.__init__(self)
225                 self.backupNameserverList = iNetwork.getNameserverList()[:]
226                 print "backup-list:", self.backupNameserverList
227                 
228                 self["key_red"] = StaticText(_("Cancel"))
229                 self["key_green"] = StaticText(_("Add"))
230                 self["key_yellow"] = StaticText(_("Delete"))
231
232                 self["introduction"] = StaticText(_("Press OK to activate the settings."))
233                 self.createConfig()
234
235                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
236                         {
237                         "cancel": (self.cancel, _("exit nameserver configuration")),
238                         "ok": (self.ok, _("activate current configuration")),
239                         })
240
241                 self["ColorActions"] = HelpableActionMap(self, "ColorActions",
242                         {
243                         "red": (self.cancel, _("exit nameserver configuration")),
244                         "green": (self.add, _("add a nameserver entry")),
245                         "yellow": (self.remove, _("remove a nameserver entry")),
246                         })
247
248                 self["actions"] = NumberActionMap(["SetupActions"],
249                 {
250                         "ok": self.ok,
251                 }, -2)
252
253                 self.list = []
254                 ConfigListScreen.__init__(self, self.list)
255                 self.createSetup()
256
257         def createConfig(self):
258                 self.nameservers = iNetwork.getNameserverList()
259                 self.nameserverEntries = [ NoSave(ConfigIP(default=nameserver)) for nameserver in self.nameservers]
260
261         def createSetup(self):
262                 self.list = []
263
264                 i = 1
265                 for x in self.nameserverEntries:
266                         self.list.append(getConfigListEntry(_("Nameserver %d") % (i), x))
267                         i += 1
268
269                 self["config"].list = self.list
270                 self["config"].l.setList(self.list)
271
272         def ok(self):
273                 iNetwork.clearNameservers()
274                 for nameserver in self.nameserverEntries:
275                         iNetwork.addNameserver(nameserver.value)
276                 iNetwork.writeNameserverConfig()
277                 self.close()
278
279         def run(self):
280                 self.ok()
281
282         def cancel(self):
283                 iNetwork.clearNameservers()
284                 print "backup-list:", self.backupNameserverList
285                 for nameserver in self.backupNameserverList:
286                         iNetwork.addNameserver(nameserver)
287                 self.close()
288
289         def add(self):
290                 iNetwork.addNameserver([0,0,0,0])
291                 self.createConfig()
292                 self.createSetup()
293
294         def remove(self):
295                 print "currentIndex:", self["config"].getCurrentIndex()
296                 index = self["config"].getCurrentIndex()
297                 if index < len(self.nameservers):
298                         iNetwork.removeNameserver(self.nameservers[index])
299                         self.createConfig()
300                         self.createSetup()
301
302
303 class AdapterSetup(Screen, ConfigListScreen, HelpableScreen):
304         def __init__(self, session, networkinfo, essid=None, aplist=None):
305                 Screen.__init__(self, session)
306                 HelpableScreen.__init__(self)
307                 self.session = session
308                 if isinstance(networkinfo, (list, tuple)):
309                         self.iface = networkinfo[0]
310                         self.essid = networkinfo[1]
311                         self.aplist = networkinfo[2]
312                 else:
313                         self.iface = networkinfo
314                         self.essid = essid
315                         self.aplist = aplist
316                 self.extended = None
317                 self.applyConfigRef = None
318                 self.finished_cb = None
319                 self.oktext = _("Press OK on your remote control to continue.")
320                 self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
321
322                 self.createConfig()
323
324                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
325                         {
326                         "cancel": (self.keyCancel, _("exit network adapter configuration")),
327                         "ok": (self.keySave, _("activate network adapter configuration")),
328                         })
329
330                 self["ColorActions"] = HelpableActionMap(self, "ColorActions",
331                         {
332                         "red": (self.keyCancel, _("exit network adapter configuration")),
333                         "blue": (self.KeyBlue, _("open nameserver configuration")),
334                         })
335
336                 self["actions"] = NumberActionMap(["SetupActions"],
337                 {
338                         "ok": self.keySave,
339                 }, -2)
340
341                 self.list = []
342                 ConfigListScreen.__init__(self, self.list,session = self.session)
343                 self.createSetup()
344                 self.onLayoutFinish.append(self.layoutFinished)
345                 self.onClose.append(self.cleanup)
346
347                 self["DNS1text"] = StaticText(_("Primary DNS"))
348                 self["DNS2text"] = StaticText(_("Secondary DNS"))
349                 self["DNS1"] = StaticText()
350                 self["DNS2"] = StaticText()
351                 self["introduction"] = StaticText(_("Current settings:"))
352
353                 self["IPtext"] = StaticText(_("IP Address"))
354                 self["Netmasktext"] = StaticText(_("Netmask"))
355                 self["Gatewaytext"] = StaticText(_("Gateway"))
356
357                 self["IP"] = StaticText()
358                 self["Mask"] = StaticText()
359                 self["Gateway"] = StaticText()
360
361                 self["Adaptertext"] = StaticText(_("Network:"))
362                 self["Adapter"] = StaticText()
363                 self["introduction2"] = StaticText(_("Press OK to activate the settings."))
364                 self["key_red"] = StaticText(_("Cancel"))
365                 self["key_blue"] = StaticText(_("Edit DNS"))
366
367                 self["VKeyIcon"] = Boolean(False)
368                 self["HelpWindow"] = Pixmap()
369                 self["HelpWindow"].hide()
370                 
371         def layoutFinished(self):
372                 self["DNS1"].setText(self.primaryDNS.getText())
373                 self["DNS2"].setText(self.secondaryDNS.getText())
374                 if self.ipConfigEntry.getText() is not None:
375                         if self.ipConfigEntry.getText() == "0.0.0.0":
376                                 self["IP"].setText(_("N/A"))
377                         else:   
378                                 self["IP"].setText(self.ipConfigEntry.getText())
379                 else:
380                         self["IP"].setText(_("N/A"))
381                 if self.netmaskConfigEntry.getText() is not None:
382                         if self.netmaskConfigEntry.getText() == "0.0.0.0":
383                                         self["Mask"].setText(_("N/A"))
384                         else:   
385                                 self["Mask"].setText(self.netmaskConfigEntry.getText())
386                 else:
387                         self["IP"].setText(_("N/A"))                    
388                 if iNetwork.getAdapterAttribute(self.iface, "gateway"):
389                         if self.gatewayConfigEntry.getText() == "0.0.0.0":
390                                 self["Gatewaytext"].setText(_("Gateway"))
391                                 self["Gateway"].setText(_("N/A"))
392                         else:
393                                 self["Gatewaytext"].setText(_("Gateway"))
394                                 self["Gateway"].setText(self.gatewayConfigEntry.getText())
395                 else:
396                         self["Gateway"].setText("")
397                         self["Gatewaytext"].setText("")
398                 self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
399
400         def createConfig(self):
401                 self.InterfaceEntry = None
402                 self.dhcpEntry = None
403                 self.gatewayEntry = None
404                 self.hiddenSSID = None
405                 self.wlanSSID = None
406                 self.encryptionEnabled = None
407                 self.encryptionKey = None
408                 self.encryptionType = None
409                 self.nwlist = None
410                 self.encryptionlist = None
411                 self.weplist = None
412                 self.wsconfig = None
413                 self.default = None
414
415                 if self.iface == "wlan0" or self.iface == "ath0" :
416                         from Plugins.SystemPlugins.WirelessLan.Wlan import wpaSupplicant,Wlan
417                         self.w = Wlan(self.iface)
418                         self.ws = wpaSupplicant()
419                         self.encryptionlist = []
420                         self.encryptionlist.append(("WEP", _("WEP")))
421                         self.encryptionlist.append(("WPA", _("WPA")))
422                         self.encryptionlist.append(("WPA2", _("WPA2")))
423                         self.encryptionlist.append(("WPA/WPA2", _("WPA or WPA2")))
424                         self.weplist = []
425                         self.weplist.append("ASCII")
426                         self.weplist.append("HEX")
427                         if self.aplist is not None:
428                                 self.nwlist = self.aplist
429                                 self.nwlist.sort(key = lambda x: x[0])
430                         else:
431                                 self.nwlist = []
432                                 self.aps = None
433                                 try:
434                                         self.aps = self.w.getNetworkList()
435                                         if self.aps is not None:
436                                                 for ap in self.aps:
437                                                         a = self.aps[ap]
438                                                         if a['active']:
439                                                                 if a['essid'] != '':
440                                                                         self.nwlist.append((a['essid'],a['essid']))
441                                         self.nwlist.sort(key = lambda x: x[0])
442                                 except:
443                                         self.nwlist.append(("No Networks found",_("No Networks found")))
444
445                         self.wsconfig = self.ws.loadConfig()
446                         if self.essid is not None: # ssid from wlan scan
447                                 self.default = self.essid
448                         else:
449                                 self.default = self.wsconfig['ssid']
450
451                         if "hidden..." not in self.nwlist:
452                                 self.nwlist.append(("hidden...",_("enter hidden network SSID")))
453                         if self.default not in self.nwlist:
454                                 self.nwlist.append((self.default,self.default))
455                         config.plugins.wlan.essid = NoSave(ConfigSelection(self.nwlist, default = self.default ))
456                         config.plugins.wlan.hiddenessid = NoSave(ConfigText(default = self.wsconfig['hiddenessid'], visible_width = 50, fixed_size = False))
457
458                         config.plugins.wlan.encryption.enabled = NoSave(ConfigYesNo(default = self.wsconfig['encryption'] ))
459                         config.plugins.wlan.encryption.type = NoSave(ConfigSelection(self.encryptionlist, default = self.wsconfig['encryption_type'] ))
460                         config.plugins.wlan.encryption.wepkeytype = NoSave(ConfigSelection(self.weplist, default = self.wsconfig['encryption_wepkeytype'] ))
461                         config.plugins.wlan.encryption.psk = NoSave(ConfigPassword(default = self.wsconfig['key'], visible_width = 50, fixed_size = False))
462
463                 self.activateInterfaceEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "up") or False))
464                 self.dhcpConfigEntry = NoSave(ConfigYesNo(default=iNetwork.getAdapterAttribute(self.iface, "dhcp") or False))
465                 self.ipConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "ip")) or [0,0,0,0])
466                 self.netmaskConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "netmask") or [255,0,0,0]))
467                 if iNetwork.getAdapterAttribute(self.iface, "gateway"):
468                         self.dhcpdefault=True
469                 else:
470                         self.dhcpdefault=False
471                 self.hasGatewayConfigEntry = NoSave(ConfigYesNo(default=self.dhcpdefault or False))
472                 self.gatewayConfigEntry = NoSave(ConfigIP(default=iNetwork.getAdapterAttribute(self.iface, "gateway") or [0,0,0,0]))
473                 nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
474                 self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
475                 self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
476
477         def createSetup(self):
478                 self.list = []
479                 self.InterfaceEntry = getConfigListEntry(_("Use Interface"), self.activateInterfaceEntry)
480
481                 self.list.append(self.InterfaceEntry)
482                 if self.activateInterfaceEntry.value:
483                         self.dhcpEntry = getConfigListEntry(_("Use DHCP"), self.dhcpConfigEntry)
484                         self.list.append(self.dhcpEntry)
485                         if not self.dhcpConfigEntry.value:
486                                 self.list.append(getConfigListEntry(_('IP Address'), self.ipConfigEntry))
487                                 self.list.append(getConfigListEntry(_('Netmask'), self.netmaskConfigEntry))
488                                 self.gatewayEntry = getConfigListEntry(_('Use a gateway'), self.hasGatewayConfigEntry)
489                                 self.list.append(self.gatewayEntry)
490                                 if self.hasGatewayConfigEntry.value:
491                                         self.list.append(getConfigListEntry(_('Gateway'), self.gatewayConfigEntry))
492
493                         self.extended = None
494                         for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
495                                 callFnc = p.__call__["ifaceSupported"](self.iface)
496                                 if callFnc is not None:
497                                         if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
498                                                 self.extended = callFnc
499                                                 if p.__call__.has_key("configStrings"):
500                                                         self.configStrings = p.__call__["configStrings"]
501                                                 else:
502                                                         self.configStrings = None
503                                                 if config.plugins.wlan.essid.value == 'hidden...':
504                                                         self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
505                                                         self.list.append(self.wlanSSID)
506                                                         self.hiddenSSID = getConfigListEntry(_("Hidden network SSID"), config.plugins.wlan.hiddenessid)
507                                                         self.list.append(self.hiddenSSID)
508                                                 else:
509                                                         self.wlanSSID = getConfigListEntry(_("Network SSID"), config.plugins.wlan.essid)
510                                                         self.list.append(self.wlanSSID)
511                                                 self.encryptionEnabled = getConfigListEntry(_("Encryption"), config.plugins.wlan.encryption.enabled)
512                                                 self.list.append(self.encryptionEnabled)
513                                                 
514                                                 if config.plugins.wlan.encryption.enabled.value:
515                                                         self.encryptionType = getConfigListEntry(_("Encryption Type"), config.plugins.wlan.encryption.type)
516                                                         self.list.append(self.encryptionType)
517                                                         if config.plugins.wlan.encryption.type.value == 'WEP':
518                                                                 self.list.append(getConfigListEntry(_("Encryption Keytype"), config.plugins.wlan.encryption.wepkeytype))
519                                                                 self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
520                                                                 self.list.append(self.encryptionKey)
521                                                         else:
522                                                                 self.encryptionKey = getConfigListEntry(_("Encryption Key"), config.plugins.wlan.encryption.psk)
523                                                                 self.list.append(self.encryptionKey)
524
525                 self["config"].list = self.list
526                 self["config"].l.setList(self.list)
527
528         def KeyBlue(self):
529                 self.session.openWithCallback(self.NameserverSetupClosed, NameserverSetup)
530
531         def newConfig(self):
532                 if self["config"].getCurrent() == self.InterfaceEntry:
533                         self.createSetup()
534                 if self["config"].getCurrent() == self.dhcpEntry:
535                         self.createSetup()
536                 if self["config"].getCurrent() == self.gatewayEntry:
537                         self.createSetup()
538                 if self.iface == "wlan0" or self.iface == "ath0" :
539                         if self["config"].getCurrent() == self.wlanSSID:
540                                 self.createSetup()
541                         if self["config"].getCurrent() == self.encryptionEnabled:
542                                 self.createSetup()
543                         if self["config"].getCurrent() == self.encryptionType:
544                                 self.createSetup()
545
546         def keyLeft(self):
547                 ConfigListScreen.keyLeft(self)
548                 self.newConfig()
549
550         def keyRight(self):
551                 ConfigListScreen.keyRight(self)
552                 self.newConfig()
553         
554         def keySave(self):
555                 self.hideInputHelp()
556                 if self["config"].isChanged():
557                         self.session.openWithCallback(self.keySaveConfirm, MessageBox, (_("Are you sure you want to activate this network configuration?\n\n") + self.oktext ) )
558                 else:
559                         if self.finished_cb:
560                                 self.finished_cb()
561                         else:
562                                 self.close('cancel')
563
564         def keySaveConfirm(self, ret = False):
565                 if (ret == True):               
566                         num_configured_if = len(iNetwork.getConfiguredAdapters())
567                         if num_configured_if >= 1:
568                                 if num_configured_if == 1 and self.iface in iNetwork.getConfiguredAdapters():
569                                         self.applyConfig(True)
570                                 else:
571                                         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)
572                         else:
573                                 self.applyConfig(True)
574                 else:
575                         self.keyCancel()                
576
577         def secondIfaceFoundCB(self,data):
578                 if data is False:
579                         self.applyConfig(True)
580                 else:
581                         configuredInterfaces = iNetwork.getConfiguredAdapters()
582                         for interface in configuredInterfaces:
583                                 if interface == self.iface:
584                                         continue
585                                 iNetwork.setAdapterAttribute(interface, "up", False)
586                                 iNetwork.deactivateInterface(interface)
587                                 self.applyConfig(True)
588
589         def applyConfig(self, ret = False):
590                 if (ret == True):
591                         iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
592                         iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
593                         iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
594                         iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
595                         if self.hasGatewayConfigEntry.value:
596                                 iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
597                         else:
598                                 iNetwork.removeAdapterAttribute(self.iface, "gateway")
599                         if self.extended is not None and self.configStrings is not None:
600                                 iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
601                                 self.ws.writeConfig()
602                         if self.activateInterfaceEntry.value is False:
603                                 iNetwork.deactivateInterface(self.iface)
604                         iNetwork.writeNetworkConfig()
605                         iNetwork.restartNetwork(self.applyConfigDataAvail)
606                         self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
607                 else:
608                         self.keyCancel()
609
610         def applyConfigDataAvail(self, data):
611                 if data is True:
612                         iNetwork.getInterfaces(self.getInterfacesDataAvail)
613
614         def getInterfacesDataAvail(self, data):
615                 if data is True:
616                         self.applyConfigRef.close(True)
617
618         def applyConfigfinishedCB(self,data):
619                 if data is True:
620                         if self.finished_cb:
621                                 self.session.openWithCallback(lambda x : self.finished_cb(), MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
622                         else:
623                                 self.session.openWithCallback(self.ConfigfinishedCB, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
624
625         def ConfigfinishedCB(self,data):
626                 if data is not None:
627                         if data is True:
628                                 self.close('ok')
629
630         def keyCancelConfirm(self, result):
631                 if not result:
632                         return
633                 if self.oldInterfaceState is False:
634                         iNetwork.deactivateInterface(self.iface,self.keyCancelCB)
635                 else:
636                         self.close('cancel')
637
638         def keyCancel(self):
639                 self.hideInputHelp()
640                 if self["config"].isChanged():
641                         self.session.openWithCallback(self.keyCancelConfirm, MessageBox, _("Really close without saving settings?"))
642                 else:
643                         self.close('cancel')
644
645         def keyCancelCB(self,data):
646                 if data is not None:
647                         if data is True:
648                                 self.close('cancel')
649
650         def runAsync(self, finished_cb):
651                 self.finished_cb = finished_cb
652                 self.keySave()
653
654         def NameserverSetupClosed(self, *ret):
655                 iNetwork.loadNameserverConfig()
656                 nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
657                 self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
658                 self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
659                 self.createSetup()
660                 self.layoutFinished()
661
662         def cleanup(self):
663                 iNetwork.stopLinkStateConsole()
664                 
665         def hideInputHelp(self):
666                 current = self["config"].getCurrent()
667                 if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
668                         if current[1].help_window.instance is not None:
669                                 current[1].help_window.instance.hide()
670                 elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
671                         if current[1].help_window.instance is not None:
672                                 current[1].help_window.instance.hide()
673
674
675 class AdapterSetupConfiguration(Screen, HelpableScreen):
676         def __init__(self, session,iface):
677                 Screen.__init__(self, session)
678                 HelpableScreen.__init__(self)
679                 self.session = session
680                 self.iface = iface
681                 self.restartLanRef = None
682                 self.LinkState = None
683                 self.mainmenu = self.genMainMenu()
684                 self["menulist"] = MenuList(self.mainmenu)
685                 self["key_red"] = StaticText(_("Close"))
686                 self["description"] = StaticText()
687                 self["IFtext"] = StaticText()
688                 self["IF"] = StaticText()
689                 self["Statustext"] = StaticText()
690                 self["statuspic"] = MultiPixmap()
691                 self["statuspic"].hide()
692                 
693                 self.oktext = _("Press OK on your remote control to continue.")
694                 self.reboottext = _("Your STB will restart after pressing OK on your remote control.")
695                 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.")      
696                 
697                 self["WizardActions"] = HelpableActionMap(self, "WizardActions",
698                         {
699                         "up": (self.up, _("move up to previous entry")),
700                         "down": (self.down, _("move down to next entry")),
701                         "left": (self.left, _("move up to first entry")),
702                         "right": (self.right, _("move down to last entry")),
703                         })
704                 
705                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
706                         {
707                         "cancel": (self.close, _("exit networkadapter setup menu")),
708                         "ok": (self.ok, _("select menu entry")),
709                         })
710
711                 self["ColorActions"] = HelpableActionMap(self, "ColorActions",
712                         {
713                         "red": (self.close, _("exit networkadapter setup menu")),       
714                         })
715
716                 self["actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
717                 {
718                         "ok": self.ok,
719                         "back": self.close,
720                         "up": self.up,
721                         "down": self.down,
722                         "red": self.close,
723                         "left": self.left,
724                         "right": self.right,
725                 }, -2)
726                 
727                 self.updateStatusbar()
728                 self.onLayoutFinish.append(self.layoutFinished)
729                 self.onClose.append(self.cleanup)
730
731         def ok(self):
732                 self.cleanup()
733                 if self["menulist"].getCurrent()[1] == 'edit':
734                         if self.iface == 'wlan0' or self.iface == 'ath0':
735                                 try:
736                                         from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
737                                         from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
738                                 except ImportError:
739                                         self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
740                                 else:
741                                         ifobj = Wireless(self.iface) # a Wireless NIC Object
742                                         self.wlanresponse = ifobj.getStatistics()
743                                         if self.wlanresponse[0] != 19: # Wlan Interface found.
744                                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
745                                         else:
746                                                 # Display Wlan not available Message
747                                                 self.showErrorMessage()
748                         else:
749                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
750                 if self["menulist"].getCurrent()[1] == 'test':
751                         self.session.open(NetworkAdapterTest,self.iface)
752                 if self["menulist"].getCurrent()[1] == 'dns':
753                         self.session.open(NameserverSetup)
754                 if self["menulist"].getCurrent()[1] == 'scanwlan':
755                         try:
756                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
757                                 from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
758                         except ImportError:
759                                 self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
760                         else:
761                                 ifobj = Wireless(self.iface) # a Wireless NIC Object
762                                 self.wlanresponse = ifobj.getStatistics()
763                                 if self.wlanresponse[0] != 19:
764                                         self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
765                                 else:
766                                         # Display Wlan not available Message
767                                         self.showErrorMessage()
768                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
769                         try:
770                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
771                                 from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
772                         except ImportError:
773                                 self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
774                         else:   
775                                 ifobj = Wireless(self.iface) # a Wireless NIC Object
776                                 self.wlanresponse = ifobj.getStatistics()
777                                 if self.wlanresponse[0] != 19:
778                                         self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
779                                 else:
780                                         # Display Wlan not available Message
781                                         self.showErrorMessage()
782                 if self["menulist"].getCurrent()[1] == 'lanrestart':
783                         self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
784                 if self["menulist"].getCurrent()[1] == 'openwizard':
785                         from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
786                         self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard, self.iface)
787                 if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
788                         self.extended = self["menulist"].getCurrent()[1][2]
789                         self.extended(self.session, self.iface)
790         
791         def up(self):
792                 self["menulist"].up()
793                 self.loadDescription()
794
795         def down(self):
796                 self["menulist"].down()
797                 self.loadDescription()
798
799         def left(self):
800                 self["menulist"].pageUp()
801                 self.loadDescription()
802
803         def right(self):
804                 self["menulist"].pageDown()
805                 self.loadDescription()
806
807         def layoutFinished(self):
808                 idx = 0
809                 self["menulist"].moveToIndex(idx)
810                 self.loadDescription()
811
812         def loadDescription(self):
813                 if self["menulist"].getCurrent()[1] == 'edit':
814                         self["description"].setText(_("Edit the network configuration of your STB.\n" ) + self.oktext )
815                 if self["menulist"].getCurrent()[1] == 'test':
816                         self["description"].setText(_("Test the network configuration of your STB.\n" ) + self.oktext )
817                 if self["menulist"].getCurrent()[1] == 'dns':
818                         self["description"].setText(_("Edit the Nameserver configuration of your STB.\n" ) + self.oktext )
819                 if self["menulist"].getCurrent()[1] == 'scanwlan':
820                         self["description"].setText(_("Scan your network for wireless Access Points and connect to them using your selected wireless device.\n" ) + self.oktext )
821                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
822                         self["description"].setText(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext )
823                 if self["menulist"].getCurrent()[1] == 'lanrestart':
824                         self["description"].setText(_("Restart your network connection and interfaces.\n" ) + self.oktext )
825                 if self["menulist"].getCurrent()[1] == 'openwizard':
826                         self["description"].setText(_("Use the Networkwizard to configure your Network\n" ) + self.oktext )
827                 if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
828                         self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
829                 
830         def updateStatusbar(self, data = None):
831                 self.mainmenu = self.genMainMenu()
832                 self["menulist"].l.setList(self.mainmenu)
833                 self["IFtext"].setText(_("Network:"))
834                 self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
835                 self["Statustext"].setText(_("Link:"))
836                 
837                 if self.iface == 'wlan0' or self.iface == 'ath0':
838                         try:
839                                 from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
840                         except:
841                                 self["statuspic"].setPixmapNum(1)
842                                 self["statuspic"].show()
843                         else:
844                                 iStatus.getDataForInterface(self.iface,self.getInfoCB)
845                 else:
846                         iNetwork.getLinkState(self.iface,self.dataAvail)
847
848         def doNothing(self):
849                 pass
850
851         def genMainMenu(self):
852                 menu = []
853                 menu.append((_("Adapter settings"), "edit"))
854                 menu.append((_("Nameserver settings"), "dns"))
855                 menu.append((_("Network test"), "test"))
856                 menu.append((_("Restart network"), "lanrestart"))
857
858                 self.extended = None
859                 self.extendedSetup = None               
860                 for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
861                         callFnc = p.__call__["ifaceSupported"](self.iface)
862                         if callFnc is not None:
863                                 self.extended = callFnc
864                                 if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
865                                         menu.append((_("Scan Wireless Networks"), "scanwlan"))
866                                         if iNetwork.getAdapterAttribute(self.iface, "up"):
867                                                 menu.append((_("Show WLAN Status"), "wlanstatus"))
868                                 else:
869                                         if p.__call__.has_key("menuEntryName"):
870                                                 menuEntryName = p.__call__["menuEntryName"](self.iface)
871                                         else:
872                                                 menuEntryName = _('Extended Setup...')
873                                         if p.__call__.has_key("menuEntryDescription"):
874                                                 menuEntryDescription = p.__call__["menuEntryDescription"](self.iface)
875                                         else:
876                                                 menuEntryDescription = _('Extended Networksetup Plugin...')
877                                         self.extendedSetup = ('extendedSetup',menuEntryDescription, self.extended)
878                                         menu.append((menuEntryName,self.extendedSetup))                                 
879                         
880                 if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
881                         menu.append((_("NetworkWizard"), "openwizard"))
882
883                 return menu
884
885         def AdapterSetupClosed(self, *ret):
886                 if ret is not None and len(ret):
887                         if ret[0] == 'ok' and (self.iface == 'wlan0' or self.iface == 'ath0') and iNetwork.getAdapterAttribute(self.iface, "up") is True:
888                                 try:
889                                         from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
890                                         from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
891                                 except ImportError:
892                                         self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
893                                 else:   
894                                         ifobj = Wireless(self.iface) # a Wireless NIC Object
895                                         self.wlanresponse = ifobj.getStatistics()
896                                         if self.wlanresponse[0] != 19:
897                                                 self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
898                                         else:
899                                                 # Display Wlan not available Message
900                                                 self.showErrorMessage()
901                         else:
902                                 self.updateStatusbar()
903                 else:
904                         self.updateStatusbar()
905
906         def WlanStatusClosed(self, *ret):
907                 if ret is not None and len(ret):
908                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
909                         iStatus.stopWlanConsole()
910                         self.updateStatusbar()
911
912         def WlanScanClosed(self,*ret):
913                 if ret[0] is not None:
914                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
915                 else:
916                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
917                         iStatus.stopWlanConsole()
918                         self.updateStatusbar()
919                         
920         def restartLan(self, ret = False):
921                 if (ret == True):
922                         iNetwork.restartNetwork(self.restartLanDataAvail)
923                         self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while your network is restarting..."), type = MessageBox.TYPE_INFO, enable_input = False)
924                         
925         def restartLanDataAvail(self, data):
926                 if data is True:
927                         iNetwork.getInterfaces(self.getInterfacesDataAvail)
928
929         def getInterfacesDataAvail(self, data):
930                 if data is True:
931                         self.restartLanRef.close(True)
932
933         def restartfinishedCB(self,data):
934                 if data is True:
935                         self.updateStatusbar()
936                         self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
937
938         def dataAvail(self,data):
939                 self.LinkState = None
940                 for line in data.splitlines():
941                         line = line.strip()
942                         if 'Link detected:' in line:
943                                 if "yes" in line:
944                                         self.LinkState = True
945                                 else:
946                                         self.LinkState = False
947                 if self.LinkState == True:
948                         iNetwork.checkNetworkState(self.checkNetworkCB)
949                 else:
950                         self["statuspic"].setPixmapNum(1)
951                         self["statuspic"].show()                        
952
953         def showErrorMessage(self):
954                 self.session.open(MessageBox, self.errortext, type = MessageBox.TYPE_INFO,timeout = 10 )
955                 
956         def cleanup(self):
957                 iNetwork.stopLinkStateConsole()
958                 iNetwork.stopDeactivateInterfaceConsole()
959                 iNetwork.stopPingConsole()
960                 try:
961                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
962                 except ImportError:
963                         pass
964                 else:
965                         iStatus.stopWlanConsole()
966
967         def getInfoCB(self,data,status):
968                 self.LinkState = None
969                 if data is not None:
970                         if data is True:
971                                 if status is not None:
972                                         if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
973                                                 self.LinkState = False
974                                                 self["statuspic"].setPixmapNum(1)
975                                                 self["statuspic"].show()
976                                         else:
977                                                 self.LinkState = True
978                                                 iNetwork.checkNetworkState(self.checkNetworkCB)
979
980         def checkNetworkCB(self,data):
981                 if iNetwork.getAdapterAttribute(self.iface, "up") is True:
982                         if self.LinkState is True:
983                                 if data <= 2:
984                                         self["statuspic"].setPixmapNum(0)
985                                 else:
986                                         self["statuspic"].setPixmapNum(1)
987                                 self["statuspic"].show()        
988                         else:
989                                 self["statuspic"].setPixmapNum(1)
990                                 self["statuspic"].show()
991                 else:
992                         self["statuspic"].setPixmapNum(1)
993                         self["statuspic"].show()
994
995
996 class NetworkAdapterTest(Screen):       
997         def __init__(self, session,iface):
998                 Screen.__init__(self, session)
999                 self.iface = iface
1000                 self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
1001                 self.setLabels()
1002                 self.onClose.append(self.cleanup)
1003                 self.onHide.append(self.cleanup)
1004                 
1005                 self["updown_actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
1006                 {
1007                         "ok": self.KeyOK,
1008                         "blue": self.KeyOK,
1009                         "up": lambda: self.updownhandler('up'),
1010                         "down": lambda: self.updownhandler('down'),
1011                 
1012                 }, -2)
1013                 
1014                 self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
1015                 {
1016                         "red": self.cancel,
1017                         "back": self.cancel,
1018                 }, -2)
1019                 self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
1020                 {
1021                         "red": self.closeInfo,
1022                         "back": self.closeInfo,
1023                 }, -2)
1024                 self["shortcutsgreen"] = ActionMap(["ShortcutActions"],
1025                 {
1026                         "green": self.KeyGreen,
1027                 }, -2)
1028                 self["shortcutsgreen_restart"] = ActionMap(["ShortcutActions"],
1029                 {
1030                         "green": self.KeyGreenRestart,
1031                 }, -2)
1032                 self["shortcutsyellow"] = ActionMap(["ShortcutActions"],
1033                 {
1034                         "yellow": self.KeyYellow,
1035                 }, -2)
1036                 
1037                 self["shortcutsgreen_restart"].setEnabled(False)
1038                 self["updown_actions"].setEnabled(False)
1039                 self["infoshortcuts"].setEnabled(False)
1040                 self.onClose.append(self.delTimer)      
1041                 self.onLayoutFinish.append(self.layoutFinished)
1042                 self.steptimer = False
1043                 self.nextstep = 0
1044                 self.activebutton = 0
1045                 self.nextStepTimer = eTimer()
1046                 self.nextStepTimer.callback.append(self.nextStepTimerFire)
1047
1048         def cancel(self):
1049                 if self.oldInterfaceState is False:
1050                         iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
1051                         iNetwork.deactivateInterface(self.iface)
1052                 self.close()
1053
1054         def closeInfo(self):
1055                 self["shortcuts"].setEnabled(True)              
1056                 self["infoshortcuts"].setEnabled(False)
1057                 self["InfoText"].hide()
1058                 self["InfoTextBorder"].hide()
1059                 self["key_red"].setText(_("Close"))
1060
1061         def delTimer(self):
1062                 del self.steptimer
1063                 del self.nextStepTimer
1064
1065         def nextStepTimerFire(self):
1066                 self.nextStepTimer.stop()
1067                 self.steptimer = False
1068                 self.runTest()
1069
1070         def updownhandler(self,direction):
1071                 if direction == 'up':
1072                         if self.activebutton >=2:
1073                                 self.activebutton -= 1
1074                         else:
1075                                 self.activebutton = 6
1076                         self.setActiveButton(self.activebutton)
1077                 if direction == 'down':
1078                         if self.activebutton <=5:
1079                                 self.activebutton += 1
1080                         else:
1081                                 self.activebutton = 1
1082                         self.setActiveButton(self.activebutton)
1083
1084         def setActiveButton(self,button):
1085                 if button == 1:
1086                         self["EditSettingsButton"].setPixmapNum(0)
1087                         self["EditSettings_Text"].setForegroundColorNum(0)
1088                         self["NetworkInfo"].setPixmapNum(0)
1089                         self["NetworkInfo_Text"].setForegroundColorNum(1)
1090                         self["AdapterInfo"].setPixmapNum(1)               # active
1091                         self["AdapterInfo_Text"].setForegroundColorNum(2) # active
1092                 if button == 2:
1093                         self["AdapterInfo_Text"].setForegroundColorNum(1)
1094                         self["AdapterInfo"].setPixmapNum(0)
1095                         self["DhcpInfo"].setPixmapNum(0)
1096                         self["DhcpInfo_Text"].setForegroundColorNum(1)
1097                         self["NetworkInfo"].setPixmapNum(1)               # active
1098                         self["NetworkInfo_Text"].setForegroundColorNum(2) # active
1099                 if button == 3:
1100                         self["NetworkInfo"].setPixmapNum(0)
1101                         self["NetworkInfo_Text"].setForegroundColorNum(1)
1102                         self["IPInfo"].setPixmapNum(0)
1103                         self["IPInfo_Text"].setForegroundColorNum(1)
1104                         self["DhcpInfo"].setPixmapNum(1)                  # active
1105                         self["DhcpInfo_Text"].setForegroundColorNum(2)    # active
1106                 if button == 4:
1107                         self["DhcpInfo"].setPixmapNum(0)
1108                         self["DhcpInfo_Text"].setForegroundColorNum(1)
1109                         self["DNSInfo"].setPixmapNum(0)
1110                         self["DNSInfo_Text"].setForegroundColorNum(1)
1111                         self["IPInfo"].setPixmapNum(1)                  # active
1112                         self["IPInfo_Text"].setForegroundColorNum(2)    # active                
1113                 if button == 5:
1114                         self["IPInfo"].setPixmapNum(0)
1115                         self["IPInfo_Text"].setForegroundColorNum(1)
1116                         self["EditSettingsButton"].setPixmapNum(0)
1117                         self["EditSettings_Text"].setForegroundColorNum(0)
1118                         self["DNSInfo"].setPixmapNum(1)                 # active
1119                         self["DNSInfo_Text"].setForegroundColorNum(2)   # active
1120                 if button == 6:
1121                         self["DNSInfo"].setPixmapNum(0)
1122                         self["DNSInfo_Text"].setForegroundColorNum(1)
1123                         self["EditSettingsButton"].setPixmapNum(1)         # active
1124                         self["EditSettings_Text"].setForegroundColorNum(2) # active
1125                         self["AdapterInfo"].setPixmapNum(0)
1126                         self["AdapterInfo_Text"].setForegroundColorNum(1)
1127                         
1128         def runTest(self):
1129                 next = self.nextstep
1130                 if next == 0:
1131                         self.doStep1()
1132                 elif next == 1:
1133                         self.doStep2()
1134                 elif next == 2:
1135                         self.doStep3()
1136                 elif next == 3:
1137                         self.doStep4()
1138                 elif next == 4:
1139                         self.doStep5()
1140                 elif next == 5:
1141                         self.doStep6()
1142                 self.nextstep += 1
1143
1144         def doStep1(self):
1145                 self.steptimer = True
1146                 self.nextStepTimer.start(3000)
1147                 self["key_yellow"].setText(_("Stop test"))
1148
1149         def doStep2(self):
1150                 self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
1151                 self["Adapter"].setForegroundColorNum(2)
1152                 self["Adaptertext"].setForegroundColorNum(1)
1153                 self["AdapterInfo_Text"].setForegroundColorNum(1)
1154                 self["AdapterInfo_OK"].show()
1155                 self.steptimer = True
1156                 self.nextStepTimer.start(3000)
1157
1158         def doStep3(self):
1159                 self["Networktext"].setForegroundColorNum(1)
1160                 self["Network"].setText(_("Please wait..."))
1161                 self.getLinkState(self.iface)
1162                 self["NetworkInfo_Text"].setForegroundColorNum(1)
1163                 self.steptimer = True
1164                 self.nextStepTimer.start(3000)
1165
1166         def doStep4(self):
1167                 self["Dhcptext"].setForegroundColorNum(1)
1168                 if iNetwork.getAdapterAttribute(self.iface, 'dhcp') is True:
1169                         self["Dhcp"].setForegroundColorNum(2)
1170                         self["Dhcp"].setText(_("enabled"))
1171                         self["DhcpInfo_Check"].setPixmapNum(0)
1172                 else:
1173                         self["Dhcp"].setForegroundColorNum(1)
1174                         self["Dhcp"].setText(_("disabled"))
1175                         self["DhcpInfo_Check"].setPixmapNum(1)
1176                 self["DhcpInfo_Check"].show()
1177                 self["DhcpInfo_Text"].setForegroundColorNum(1)
1178                 self.steptimer = True
1179                 self.nextStepTimer.start(3000)
1180
1181         def doStep5(self):
1182                 self["IPtext"].setForegroundColorNum(1)
1183                 self["IP"].setText(_("Please wait..."))
1184                 iNetwork.checkNetworkState(self.NetworkStatedataAvail)
1185
1186         def doStep6(self):
1187                 self.steptimer = False
1188                 self.nextStepTimer.stop()
1189                 self["DNStext"].setForegroundColorNum(1)
1190                 self["DNS"].setText(_("Please wait..."))
1191                 iNetwork.checkDNSLookup(self.DNSLookupdataAvail)
1192
1193         def KeyGreen(self):
1194                 self["shortcutsgreen"].setEnabled(False)
1195                 self["shortcutsyellow"].setEnabled(True)
1196                 self["updown_actions"].setEnabled(False)
1197                 self["key_yellow"].setText("")
1198                 self["key_green"].setText("")
1199                 self.steptimer = True
1200                 self.nextStepTimer.start(1000)
1201
1202         def KeyGreenRestart(self):
1203                 self.nextstep = 0
1204                 self.layoutFinished()
1205                 self["Adapter"].setText((""))
1206                 self["Network"].setText((""))
1207                 self["Dhcp"].setText((""))
1208                 self["IP"].setText((""))
1209                 self["DNS"].setText((""))
1210                 self["AdapterInfo_Text"].setForegroundColorNum(0)
1211                 self["NetworkInfo_Text"].setForegroundColorNum(0)
1212                 self["DhcpInfo_Text"].setForegroundColorNum(0)
1213                 self["IPInfo_Text"].setForegroundColorNum(0)
1214                 self["DNSInfo_Text"].setForegroundColorNum(0)
1215                 self["shortcutsgreen_restart"].setEnabled(False)
1216                 self["shortcutsgreen"].setEnabled(False)
1217                 self["shortcutsyellow"].setEnabled(True)
1218                 self["updown_actions"].setEnabled(False)
1219                 self["key_yellow"].setText("")
1220                 self["key_green"].setText("")
1221                 self.steptimer = True
1222                 self.nextStepTimer.start(1000)
1223
1224         def KeyOK(self):
1225                 self["infoshortcuts"].setEnabled(True)
1226                 self["shortcuts"].setEnabled(False)
1227                 if self.activebutton == 1: # Adapter Check
1228                         self["InfoText"].setText(_("This test detects your configured LAN-Adapter."))
1229                         self["InfoTextBorder"].show()
1230                         self["InfoText"].show()
1231                         self["key_red"].setText(_("Back"))
1232                 if self.activebutton == 2: #LAN Check
1233                         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"))
1234                         self["InfoTextBorder"].show()
1235                         self["InfoText"].show()
1236                         self["key_red"].setText(_("Back"))
1237                 if self.activebutton == 3: #DHCP Check
1238                         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."))
1239                         self["InfoTextBorder"].show()
1240                         self["InfoText"].show()
1241                         self["key_red"].setText(_("Back"))
1242                 if self.activebutton == 4: # IP Check
1243                         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"))
1244                         self["InfoTextBorder"].show()
1245                         self["InfoText"].show()
1246                         self["key_red"].setText(_("Back"))
1247                 if self.activebutton == 5: # DNS Check
1248                         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"))
1249                         self["InfoTextBorder"].show()
1250                         self["InfoText"].show()
1251                         self["key_red"].setText(_("Back"))
1252                 if self.activebutton == 6: # Edit Settings
1253                         self.session.open(AdapterSetup,self.iface)
1254
1255         def KeyYellow(self):
1256                 self.nextstep = 0
1257                 self["shortcutsgreen_restart"].setEnabled(True)
1258                 self["shortcutsgreen"].setEnabled(False)
1259                 self["shortcutsyellow"].setEnabled(False)
1260                 self["key_green"].setText(_("Restart test"))
1261                 self["key_yellow"].setText("")
1262                 self.steptimer = False
1263                 self.nextStepTimer.stop()
1264
1265         def layoutFinished(self):
1266                 self["shortcutsyellow"].setEnabled(False)
1267                 self["AdapterInfo_OK"].hide()
1268                 self["NetworkInfo_Check"].hide()
1269                 self["DhcpInfo_Check"].hide()
1270                 self["IPInfo_Check"].hide()
1271                 self["DNSInfo_Check"].hide()
1272                 self["EditSettings_Text"].hide()
1273                 self["EditSettingsButton"].hide()
1274                 self["InfoText"].hide()
1275                 self["InfoTextBorder"].hide()
1276                 self["key_yellow"].setText("")
1277
1278         def setLabels(self):
1279                 self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))
1280                 self["Adapter"] = MultiColorLabel()
1281                 self["AdapterInfo"] = MultiPixmap()
1282                 self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info"))
1283                 self["AdapterInfo_OK"] = Pixmap()
1284                 
1285                 if self.iface == 'wlan0' or self.iface == 'ath0':
1286                         self["Networktext"] = MultiColorLabel(_("Wireless Network"))
1287                 else:
1288                         self["Networktext"] = MultiColorLabel(_("Local Network"))
1289                 
1290                 self["Network"] = MultiColorLabel()
1291                 self["NetworkInfo"] = MultiPixmap()
1292                 self["NetworkInfo_Text"] = MultiColorLabel(_("Show Info"))
1293                 self["NetworkInfo_Check"] = MultiPixmap()
1294                 
1295                 self["Dhcptext"] = MultiColorLabel(_("DHCP"))
1296                 self["Dhcp"] = MultiColorLabel()
1297                 self["DhcpInfo"] = MultiPixmap()
1298                 self["DhcpInfo_Text"] = MultiColorLabel(_("Show Info"))
1299                 self["DhcpInfo_Check"] = MultiPixmap()
1300                 
1301                 self["IPtext"] = MultiColorLabel(_("IP Address"))
1302                 self["IP"] = MultiColorLabel()
1303                 self["IPInfo"] = MultiPixmap()
1304                 self["IPInfo_Text"] = MultiColorLabel(_("Show Info"))
1305                 self["IPInfo_Check"] = MultiPixmap()
1306                 
1307                 self["DNStext"] = MultiColorLabel(_("Nameserver"))
1308                 self["DNS"] = MultiColorLabel()
1309                 self["DNSInfo"] = MultiPixmap()
1310                 self["DNSInfo_Text"] = MultiColorLabel(_("Show Info"))
1311                 self["DNSInfo_Check"] = MultiPixmap()
1312                 
1313                 self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
1314                 self["EditSettingsButton"] = MultiPixmap()
1315                 
1316                 self["key_red"] = StaticText(_("Close"))
1317                 self["key_green"] = StaticText(_("Start test"))
1318                 self["key_yellow"] = StaticText(_("Stop test"))
1319                 
1320                 self["InfoTextBorder"] = Pixmap()
1321                 self["InfoText"] = Label()
1322
1323         def getLinkState(self,iface):
1324                 if iface == 'wlan0' or iface == 'ath0':
1325                         try:
1326                                 from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
1327                         except:
1328                                         self["Network"].setForegroundColorNum(1)
1329                                         self["Network"].setText(_("disconnected"))
1330                                         self["NetworkInfo_Check"].setPixmapNum(1)
1331                                         self["NetworkInfo_Check"].show()
1332                         else:
1333                                 iStatus.getDataForInterface(self.iface,self.getInfoCB)
1334                 else:
1335                         iNetwork.getLinkState(iface,self.LinkStatedataAvail)
1336
1337         def LinkStatedataAvail(self,data):
1338                 self.output = data.strip()
1339                 result = self.output.split('\n')
1340                 pattern = re_compile("Link detected: yes")
1341                 for item in result:
1342                         if re_search(pattern, item):
1343                                 self["Network"].setForegroundColorNum(2)
1344                                 self["Network"].setText(_("connected"))
1345                                 self["NetworkInfo_Check"].setPixmapNum(0)
1346                         else:
1347                                 self["Network"].setForegroundColorNum(1)
1348                                 self["Network"].setText(_("disconnected"))
1349                                 self["NetworkInfo_Check"].setPixmapNum(1)
1350                 self["NetworkInfo_Check"].show()
1351
1352         def NetworkStatedataAvail(self,data):
1353                 if data <= 2:
1354                         self["IP"].setForegroundColorNum(2)
1355                         self["IP"].setText(_("confirmed"))
1356                         self["IPInfo_Check"].setPixmapNum(0)
1357                 else:
1358                         self["IP"].setForegroundColorNum(1)
1359                         self["IP"].setText(_("unconfirmed"))
1360                         self["IPInfo_Check"].setPixmapNum(1)
1361                 self["IPInfo_Check"].show()
1362                 self["IPInfo_Text"].setForegroundColorNum(1)            
1363                 self.steptimer = True
1364                 self.nextStepTimer.start(3000)          
1365                 
1366         def DNSLookupdataAvail(self,data):
1367                 if data <= 2:
1368                         self["DNS"].setForegroundColorNum(2)
1369                         self["DNS"].setText(_("confirmed"))
1370                         self["DNSInfo_Check"].setPixmapNum(0)
1371                 else:
1372                         self["DNS"].setForegroundColorNum(1)
1373                         self["DNS"].setText(_("unconfirmed"))
1374                         self["DNSInfo_Check"].setPixmapNum(1)
1375                 self["DNSInfo_Check"].show()
1376                 self["DNSInfo_Text"].setForegroundColorNum(1)
1377                 self["EditSettings_Text"].show()
1378                 self["EditSettingsButton"].setPixmapNum(1)
1379                 self["EditSettings_Text"].setForegroundColorNum(2) # active
1380                 self["EditSettingsButton"].show()
1381                 self["key_yellow"].setText("")
1382                 self["key_green"].setText(_("Restart test"))
1383                 self["shortcutsgreen"].setEnabled(False)
1384                 self["shortcutsgreen_restart"].setEnabled(True)
1385                 self["shortcutsyellow"].setEnabled(False)
1386                 self["updown_actions"].setEnabled(True)
1387                 self.activebutton = 6
1388
1389         def getInfoCB(self,data,status):
1390                 if data is not None:
1391                         if data is True:
1392                                 if status is not None:
1393                                         if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
1394                                                 self["Network"].setForegroundColorNum(1)
1395                                                 self["Network"].setText(_("disconnected"))
1396                                                 self["NetworkInfo_Check"].setPixmapNum(1)
1397                                                 self["NetworkInfo_Check"].show()
1398                                         else:
1399                                                 self["Network"].setForegroundColorNum(2)
1400                                                 self["Network"].setText(_("connected"))
1401                                                 self["NetworkInfo_Check"].setPixmapNum(0)
1402                                                 self["NetworkInfo_Check"].show()
1403                                                 
1404         def cleanup(self):
1405                 iNetwork.stopLinkStateConsole()
1406                 iNetwork.stopDNSConsole()
1407                 try:
1408                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
1409                 except ImportError:
1410                         pass
1411                 else:
1412                         iStatus.stopWlanConsole()
1413