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