Screens/NetworkSetup.py: small fix for yesterdays network cleanup.
[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                         if self.finished_cb:
546                                 self.finished_cb()
547                         else:
548                                 self.close('cancel')
549
550         def keySaveConfirm(self, ret = False):
551                 if (ret == True):               
552                         num_configured_if = len(iNetwork.getConfiguredAdapters())
553                         if num_configured_if >= 1:
554                                 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)
555                         else:
556                                 self.applyConfig(True)
557                 else:
558                         self.keyCancel()                
559
560         def secondIfaceFoundCB(self,data):
561                 if data is False:
562                         self.applyConfig(True)
563                 else:
564                         configuredInterfaces = iNetwork.getConfiguredAdapters()
565                         for interface in configuredInterfaces:
566                                 if interface == self.iface:
567                                         continue
568                                 iNetwork.setAdapterAttribute(interface, "up", False)
569                                 iNetwork.deactivateInterface(interface)
570                                 self.applyConfig(True)
571
572         def applyConfig(self, ret = False):
573                 if (ret == True):
574                         iNetwork.setAdapterAttribute(self.iface, "up", self.activateInterfaceEntry.value)
575                         iNetwork.setAdapterAttribute(self.iface, "dhcp", self.dhcpConfigEntry.value)
576                         iNetwork.setAdapterAttribute(self.iface, "ip", self.ipConfigEntry.value)
577                         iNetwork.setAdapterAttribute(self.iface, "netmask", self.netmaskConfigEntry.value)
578                         if self.hasGatewayConfigEntry.value:
579                                 iNetwork.setAdapterAttribute(self.iface, "gateway", self.gatewayConfigEntry.value)
580                         else:
581                                 iNetwork.removeAdapterAttribute(self.iface, "gateway")
582                         if self.extended is not None and self.configStrings is not None:
583                                 iNetwork.setAdapterAttribute(self.iface, "configStrings", self.configStrings(self.iface))
584                                 self.ws.writeConfig()
585                         if self.activateInterfaceEntry.value is False:
586                                 iNetwork.deactivateInterface(self.iface)
587                         iNetwork.writeNetworkConfig()
588                         iNetwork.restartNetwork(self.applyConfigDataAvail)
589                         self.applyConfigRef = self.session.openWithCallback(self.applyConfigfinishedCB, MessageBox, _("Please wait for activation of your network configuration..."), type = MessageBox.TYPE_INFO, enable_input = False)
590                 else:
591                         self.keyCancel()
592
593         def applyConfigDataAvail(self, data):
594                 if data is True:
595                         iNetwork.getInterfaces(self.getInterfacesDataAvail)
596
597         def getInterfacesDataAvail(self, data):
598                 if data is True:
599                         self.applyConfigRef.close(True)
600
601         def applyConfigfinishedCB(self,data):
602                 if data is True:
603                         if self.finished_cb:
604                                 self.session.openWithCallback(lambda x : self.finished_cb(), MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
605                         else:
606                                 self.session.openWithCallback(self.ConfigfinishedCB, MessageBox, _("Your network configuration has been activated."), type = MessageBox.TYPE_INFO, timeout = 10)
607
608         def ConfigfinishedCB(self,data):
609                 if data is not None:
610                         if data is True:
611                                 self.close('ok')
612
613         def keyCancelConfirm(self, result):
614                 if not result:
615                         return
616                 if self.oldInterfaceState is False:
617                         iNetwork.deactivateInterface(self.iface,self.keyCancelCB)
618                 else:
619                         self.close('cancel')
620
621         def keyCancel(self):
622                 self.hideInputHelp()
623                 if self["config"].isChanged():
624                         self.session.openWithCallback(self.keyCancelConfirm, MessageBox, _("Really close without saving settings?"))
625                 else:
626                         self.close('cancel')
627
628         def keyCancelCB(self,data):
629                 if data is not None:
630                         if data is True:
631                                 self.close('cancel')
632
633         def runAsync(self, finished_cb):
634                 self.finished_cb = finished_cb
635                 self.keySave()
636
637         def NameserverSetupClosed(self, *ret):
638                 iNetwork.loadNameserverConfig()
639                 nameserver = (iNetwork.getNameserverList() + [[0,0,0,0]] * 2)[0:2]
640                 self.primaryDNS = NoSave(ConfigIP(default=nameserver[0]))
641                 self.secondaryDNS = NoSave(ConfigIP(default=nameserver[1]))
642                 self.createSetup()
643                 self.layoutFinished()
644
645         def cleanup(self):
646                 iNetwork.stopLinkStateConsole()
647                 
648         def hideInputHelp(self):
649                 current = self["config"].getCurrent()
650                 if current == self.hiddenSSID and config.plugins.wlan.essid.value == 'hidden...':
651                         if current[1].help_window.instance is not None:
652                                 current[1].help_window.instance.hide()
653                 elif current == self.encryptionKey and config.plugins.wlan.encryption.enabled.value:
654                         if current[1].help_window.instance is not None:
655                                 current[1].help_window.instance.hide()
656
657
658 class AdapterSetupConfiguration(Screen, HelpableScreen):
659         def __init__(self, session,iface):
660                 Screen.__init__(self, session)
661                 HelpableScreen.__init__(self)
662                 self.session = session
663                 self.iface = iface
664                 self.restartLanRef = None
665                 self.mainmenu = self.genMainMenu()
666                 self["menulist"] = MenuList(self.mainmenu)
667                 self["key_red"] = StaticText(_("Close"))
668                 self["description"] = StaticText()
669                 self["IFtext"] = StaticText()
670                 self["IF"] = StaticText()
671                 self["Statustext"] = StaticText()
672                 self["statuspic"] = MultiPixmap()
673                 self["statuspic"].hide()
674                 
675                 self.oktext = _("Press OK on your remote control to continue.")
676                 self.reboottext = _("Your Dreambox will restart after pressing OK on your remote control.")
677                 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.")      
678                 
679                 self["WizardActions"] = HelpableActionMap(self, "WizardActions",
680                         {
681                         "up": (self.up, _("move up to previous entry")),
682                         "down": (self.down, _("move down to next entry")),
683                         "left": (self.left, _("move up to first entry")),
684                         "right": (self.right, _("move down to last entry")),
685                         })
686                 
687                 self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
688                         {
689                         "cancel": (self.close, _("exit networkadapter setup menu")),
690                         "ok": (self.ok, _("select menu entry")),
691                         })
692
693                 self["ColorActions"] = HelpableActionMap(self, "ColorActions",
694                         {
695                         "red": (self.close, _("exit networkadapter setup menu")),       
696                         })
697
698                 self["actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
699                 {
700                         "ok": self.ok,
701                         "back": self.close,
702                         "up": self.up,
703                         "down": self.down,
704                         "red": self.close,
705                         "left": self.left,
706                         "right": self.right,
707                 }, -2)
708                 
709                 self.updateStatusbar()
710                 self.onLayoutFinish.append(self.layoutFinished)
711                 self.onClose.append(self.cleanup)
712
713         def ok(self):
714                 if self["menulist"].getCurrent()[1] == 'edit':
715                         if self.iface == 'wlan0' or self.iface == 'ath0':
716                                 try:
717                                         from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
718                                         from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
719                                 except ImportError:
720                                         self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
721                                 else:
722                                         ifobj = Wireless(self.iface) # a Wireless NIC Object
723                                         self.wlanresponse = ifobj.getStatistics()
724                                         if self.wlanresponse[0] != 19: # Wlan Interface found.
725                                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
726                                         else:
727                                                 # Display Wlan not available Message
728                                                 self.showErrorMessage()
729                         else:
730                                 self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup,self.iface)
731                 if self["menulist"].getCurrent()[1] == 'test':
732                         self.session.open(NetworkAdapterTest,self.iface)
733                 if self["menulist"].getCurrent()[1] == 'dns':
734                         self.session.open(NameserverSetup)
735                 if self["menulist"].getCurrent()[1] == 'scanwlan':
736                         try:
737                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanScan
738                                 from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
739                         except ImportError:
740                                 self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
741                         else:
742                                 ifobj = Wireless(self.iface) # a Wireless NIC Object
743                                 self.wlanresponse = ifobj.getStatistics()
744                                 if self.wlanresponse[0] != 19:
745                                         self.session.openWithCallback(self.WlanScanClosed, WlanScan, self.iface)
746                                 else:
747                                         # Display Wlan not available Message
748                                         self.showErrorMessage()
749                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
750                         try:
751                                 from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
752                                 from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
753                         except ImportError:
754                                 self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
755                         else:   
756                                 ifobj = Wireless(self.iface) # a Wireless NIC Object
757                                 self.wlanresponse = ifobj.getStatistics()
758                                 if self.wlanresponse[0] != 19:
759                                         self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
760                                 else:
761                                         # Display Wlan not available Message
762                                         self.showErrorMessage()
763                 if self["menulist"].getCurrent()[1] == 'lanrestart':
764                         self.session.openWithCallback(self.restartLan, MessageBox, (_("Are you sure you want to restart your network interfaces?\n\n") + self.oktext ) )
765                 if self["menulist"].getCurrent()[1] == 'openwizard':
766                         from Plugins.SystemPlugins.NetworkWizard.NetworkWizard import NetworkWizard
767                         self.session.openWithCallback(self.AdapterSetupClosed, NetworkWizard)
768                 if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
769                         self.extended = self["menulist"].getCurrent()[1][2]
770                         self.extended(self.session, self.iface)
771         
772         def up(self):
773                 self["menulist"].up()
774                 self.loadDescription()
775
776         def down(self):
777                 self["menulist"].down()
778                 self.loadDescription()
779
780         def left(self):
781                 self["menulist"].pageUp()
782                 self.loadDescription()
783
784         def right(self):
785                 self["menulist"].pageDown()
786                 self.loadDescription()
787
788         def layoutFinished(self):
789                 idx = 0
790                 self["menulist"].moveToIndex(idx)
791                 self.loadDescription()
792
793         def loadDescription(self):
794                 if self["menulist"].getCurrent()[1] == 'edit':
795                         self["description"].setText(_("Edit the network configuration of your Dreambox.\n" ) + self.oktext )
796                 if self["menulist"].getCurrent()[1] == 'test':
797                         self["description"].setText(_("Test the network configuration of your Dreambox.\n" ) + self.oktext )
798                 if self["menulist"].getCurrent()[1] == 'dns':
799                         self["description"].setText(_("Edit the Nameserver configuration of your Dreambox.\n" ) + self.oktext )
800                 if self["menulist"].getCurrent()[1] == 'scanwlan':
801                         self["description"].setText(_("Scan your network for wireless Access Points and connect to them using your selected wireless device.\n" ) + self.oktext )
802                 if self["menulist"].getCurrent()[1] == 'wlanstatus':
803                         self["description"].setText(_("Shows the state of your wireless LAN connection.\n" ) + self.oktext )
804                 if self["menulist"].getCurrent()[1] == 'lanrestart':
805                         self["description"].setText(_("Restart your network connection and interfaces.\n" ) + self.oktext )
806                 if self["menulist"].getCurrent()[1] == 'openwizard':
807                         self["description"].setText(_("Use the Networkwizard to configure your Network\n" ) + self.oktext )
808                 if self["menulist"].getCurrent()[1][0] == 'extendedSetup':
809                         self["description"].setText(_(self["menulist"].getCurrent()[1][1]) + self.oktext )
810                 
811         def updateStatusbar(self, data = None):
812                 self["IFtext"].setText(_("Network:"))
813                 self["IF"].setText(iNetwork.getFriendlyAdapterName(self.iface))
814                 self["Statustext"].setText(_("Link:"))
815                 
816                 if self.iface == 'wlan0' or self.iface == 'ath0':
817                         try:
818                                 from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
819                         except:
820                                 self["statuspic"].setPixmapNum(1)
821                                 self["statuspic"].show()
822                         else:
823                                 iStatus.getDataForInterface(self.iface,self.getInfoCB)
824                 else:
825                         iNetwork.getLinkState(self.iface,self.dataAvail)
826
827         def doNothing(self):
828                 pass
829
830         def genMainMenu(self):
831                 menu = []
832                 menu.append((_("Adapter settings"), "edit"))
833                 menu.append((_("Nameserver settings"), "dns"))
834                 menu.append((_("Network test"), "test"))
835                 menu.append((_("Restart network"), "lanrestart"))
836
837                 self.extended = None
838                 self.extendedSetup = None               
839                 for p in plugins.getPlugins(PluginDescriptor.WHERE_NETWORKSETUP):
840                         callFnc = p.__call__["ifaceSupported"](self.iface)
841                         if callFnc is not None:
842                                 self.extended = callFnc
843                                 if p.__call__.has_key("WlanPluginEntry"): # internally used only for WLAN Plugin
844                                         menu.append((_("Scan Wireless Networks"), "scanwlan"))
845                                         if iNetwork.getAdapterAttribute(self.iface, "up"):
846                                                 menu.append((_("Show WLAN Status"), "wlanstatus"))
847                                 else:
848                                         if p.__call__.has_key("menuEntryName"):
849                                                 menuEntryName = p.__call__["menuEntryName"](self.iface)
850                                         else:
851                                                 menuEntryName = _('Extended Setup...')
852                                         if p.__call__.has_key("menuEntryDescription"):
853                                                 menuEntryDescription = p.__call__["menuEntryDescription"](self.iface)
854                                         else:
855                                                 menuEntryDescription = _('Extended Networksetup Plugin...')
856                                         self.extendedSetup = ('extendedSetup',menuEntryDescription, self.extended)
857                                         menu.append((menuEntryName,self.extendedSetup))                                 
858                         
859                 if os_path.exists(resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")):
860                         menu.append((_("NetworkWizard"), "openwizard"))
861
862                 return menu
863
864         def AdapterSetupClosed(self, *ret):
865                 if ret is not None and len(ret):
866                         if ret[0] == 'ok' and (self.iface == 'wlan0' or self.iface == 'ath0') and iNetwork.getAdapterAttribute(self.iface, "up") is True:
867                                 try:
868                                         from Plugins.SystemPlugins.WirelessLan.plugin import WlanStatus
869                                         from Plugins.SystemPlugins.WirelessLan.iwlibs import Wireless
870                                 except ImportError:
871                                         self.session.open(MessageBox, _("The wireless LAN plugin is not installed!\nPlease install it."), type = MessageBox.TYPE_INFO,timeout = 10 )
872                                 else:   
873                                         ifobj = Wireless(self.iface) # a Wireless NIC Object
874                                         self.wlanresponse = ifobj.getStatistics()
875                                         if self.wlanresponse[0] != 19:
876                                                 self.session.openWithCallback(self.WlanStatusClosed, WlanStatus,self.iface)
877                                         else:
878                                                 # Display Wlan not available Message
879                                                 self.showErrorMessage()
880                         else:
881                                 self.mainmenu = self.genMainMenu()
882                                 self["menulist"].l.setList(self.mainmenu)
883                                 self.updateStatusbar()
884                 else:
885                         self.mainmenu = self.genMainMenu()
886                         self["menulist"].l.setList(self.mainmenu)
887                         self.updateStatusbar()
888
889         def WlanStatusClosed(self, *ret):
890                 if ret is not None and len(ret):
891                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
892                         iStatus.stopWlanConsole()
893                         self.mainmenu = self.genMainMenu()
894                         self["menulist"].l.setList(self.mainmenu)
895                         self.updateStatusbar()
896
897         def WlanScanClosed(self,*ret):
898                 if ret[0] is not None:
899                         self.session.openWithCallback(self.AdapterSetupClosed, AdapterSetup, self.iface,ret[0],ret[1])
900                 else:
901                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
902                         iStatus.stopWlanConsole()
903                         self.mainmenu = self.genMainMenu()
904                         self["menulist"].l.setList(self.mainmenu)
905                         self.updateStatusbar()
906                         
907         def restartLan(self, ret = False):
908                 if (ret == True):
909                         iNetwork.restartNetwork(self.restartLanDataAvail)
910                         self.restartLanRef = self.session.openWithCallback(self.restartfinishedCB, MessageBox, _("Please wait while your network is restarting..."), type = MessageBox.TYPE_INFO, enable_input = False)
911                         
912         def restartLanDataAvail(self, data):
913                 if data is True:
914                         iNetwork.getInterfaces(self.getInterfacesDataAvail)
915
916         def getInterfacesDataAvail(self, data):
917                 if data is True:
918                         self.restartLanRef.close(True)
919
920         def restartfinishedCB(self,data):
921                 if data is True:
922                         self.updateStatusbar()
923                         self.session.open(MessageBox, _("Finished restarting your network"), type = MessageBox.TYPE_INFO, timeout = 10, default = False)
924
925         def dataAvail(self,data):
926                 self.output = data.strip()
927                 result = self.output.split('\n')
928                 pattern = re_compile("Link detected: yes")
929                 for item in result:
930                         if re_search(pattern, item):
931                                 self["statuspic"].setPixmapNum(0)
932                         else:
933                                 self["statuspic"].setPixmapNum(1)
934                 self["statuspic"].show()
935
936         def showErrorMessage(self):
937                 self.session.open(MessageBox, self.errortext, type = MessageBox.TYPE_INFO,timeout = 10 )
938                 
939         def cleanup(self):
940                 iNetwork.stopLinkStateConsole()
941                 iNetwork.stopDeactivateInterfaceConsole()
942                 try:
943                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
944                 except ImportError:
945                         pass
946                 else:
947                         iStatus.stopWlanConsole()
948
949         def getInfoCB(self,data,status):
950                 if data is not None:
951                         if data is True:
952                                 if status is not None:
953                                         if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
954                                                 self["statuspic"].setPixmapNum(1)
955                                         else:
956                                                 self["statuspic"].setPixmapNum(0)
957                                         self["statuspic"].show()
958
959 class NetworkAdapterTest(Screen):       
960         def __init__(self, session,iface):
961                 Screen.__init__(self, session)
962                 self.iface = iface
963                 self.oldInterfaceState = iNetwork.getAdapterAttribute(self.iface, "up")
964                 self.setLabels()
965                 self.onClose.append(self.cleanup)
966                 self.onHide.append(self.cleanup)
967                 
968                 self["updown_actions"] = NumberActionMap(["WizardActions","ShortcutActions"],
969                 {
970                         "ok": self.KeyOK,
971                         "blue": self.KeyOK,
972                         "up": lambda: self.updownhandler('up'),
973                         "down": lambda: self.updownhandler('down'),
974                 
975                 }, -2)
976                 
977                 self["shortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
978                 {
979                         "red": self.cancel,
980                         "back": self.cancel,
981                 }, -2)
982                 self["infoshortcuts"] = ActionMap(["ShortcutActions","WizardActions"],
983                 {
984                         "red": self.closeInfo,
985                         "back": self.closeInfo,
986                 }, -2)
987                 self["shortcutsgreen"] = ActionMap(["ShortcutActions"],
988                 {
989                         "green": self.KeyGreen,
990                 }, -2)
991                 self["shortcutsgreen_restart"] = ActionMap(["ShortcutActions"],
992                 {
993                         "green": self.KeyGreenRestart,
994                 }, -2)
995                 self["shortcutsyellow"] = ActionMap(["ShortcutActions"],
996                 {
997                         "yellow": self.KeyYellow,
998                 }, -2)
999                 
1000                 self["shortcutsgreen_restart"].setEnabled(False)
1001                 self["updown_actions"].setEnabled(False)
1002                 self["infoshortcuts"].setEnabled(False)
1003                 self.onClose.append(self.delTimer)      
1004                 self.onLayoutFinish.append(self.layoutFinished)
1005                 self.steptimer = False
1006                 self.nextstep = 0
1007                 self.activebutton = 0
1008                 self.nextStepTimer = eTimer()
1009                 self.nextStepTimer.callback.append(self.nextStepTimerFire)
1010
1011         def cancel(self):
1012                 if self.oldInterfaceState is False:
1013                         iNetwork.setAdapterAttribute(self.iface, "up", self.oldInterfaceState)
1014                         iNetwork.deactivateInterface(self.iface)
1015                 self.close()
1016
1017         def closeInfo(self):
1018                 self["shortcuts"].setEnabled(True)              
1019                 self["infoshortcuts"].setEnabled(False)
1020                 self["InfoText"].hide()
1021                 self["InfoTextBorder"].hide()
1022                 self["key_red"].setText(_("Close"))
1023
1024         def delTimer(self):
1025                 del self.steptimer
1026                 del self.nextStepTimer
1027
1028         def nextStepTimerFire(self):
1029                 self.nextStepTimer.stop()
1030                 self.steptimer = False
1031                 self.runTest()
1032
1033         def updownhandler(self,direction):
1034                 if direction == 'up':
1035                         if self.activebutton >=2:
1036                                 self.activebutton -= 1
1037                         else:
1038                                 self.activebutton = 6
1039                         self.setActiveButton(self.activebutton)
1040                 if direction == 'down':
1041                         if self.activebutton <=5:
1042                                 self.activebutton += 1
1043                         else:
1044                                 self.activebutton = 1
1045                         self.setActiveButton(self.activebutton)
1046
1047         def setActiveButton(self,button):
1048                 if button == 1:
1049                         self["EditSettingsButton"].setPixmapNum(0)
1050                         self["EditSettings_Text"].setForegroundColorNum(0)
1051                         self["NetworkInfo"].setPixmapNum(0)
1052                         self["NetworkInfo_Text"].setForegroundColorNum(1)
1053                         self["AdapterInfo"].setPixmapNum(1)               # active
1054                         self["AdapterInfo_Text"].setForegroundColorNum(2) # active
1055                 if button == 2:
1056                         self["AdapterInfo_Text"].setForegroundColorNum(1)
1057                         self["AdapterInfo"].setPixmapNum(0)
1058                         self["DhcpInfo"].setPixmapNum(0)
1059                         self["DhcpInfo_Text"].setForegroundColorNum(1)
1060                         self["NetworkInfo"].setPixmapNum(1)               # active
1061                         self["NetworkInfo_Text"].setForegroundColorNum(2) # active
1062                 if button == 3:
1063                         self["NetworkInfo"].setPixmapNum(0)
1064                         self["NetworkInfo_Text"].setForegroundColorNum(1)
1065                         self["IPInfo"].setPixmapNum(0)
1066                         self["IPInfo_Text"].setForegroundColorNum(1)
1067                         self["DhcpInfo"].setPixmapNum(1)                  # active
1068                         self["DhcpInfo_Text"].setForegroundColorNum(2)    # active
1069                 if button == 4:
1070                         self["DhcpInfo"].setPixmapNum(0)
1071                         self["DhcpInfo_Text"].setForegroundColorNum(1)
1072                         self["DNSInfo"].setPixmapNum(0)
1073                         self["DNSInfo_Text"].setForegroundColorNum(1)
1074                         self["IPInfo"].setPixmapNum(1)                  # active
1075                         self["IPInfo_Text"].setForegroundColorNum(2)    # active                
1076                 if button == 5:
1077                         self["IPInfo"].setPixmapNum(0)
1078                         self["IPInfo_Text"].setForegroundColorNum(1)
1079                         self["EditSettingsButton"].setPixmapNum(0)
1080                         self["EditSettings_Text"].setForegroundColorNum(0)
1081                         self["DNSInfo"].setPixmapNum(1)                 # active
1082                         self["DNSInfo_Text"].setForegroundColorNum(2)   # active
1083                 if button == 6:
1084                         self["DNSInfo"].setPixmapNum(0)
1085                         self["DNSInfo_Text"].setForegroundColorNum(1)
1086                         self["EditSettingsButton"].setPixmapNum(1)         # active
1087                         self["EditSettings_Text"].setForegroundColorNum(2) # active
1088                         self["AdapterInfo"].setPixmapNum(0)
1089                         self["AdapterInfo_Text"].setForegroundColorNum(1)
1090                         
1091         def runTest(self):
1092                 next = self.nextstep
1093                 if next == 0:
1094                         self.doStep1()
1095                 elif next == 1:
1096                         self.doStep2()
1097                 elif next == 2:
1098                         self.doStep3()
1099                 elif next == 3:
1100                         self.doStep4()
1101                 elif next == 4:
1102                         self.doStep5()
1103                 elif next == 5:
1104                         self.doStep6()
1105                 self.nextstep += 1
1106
1107         def doStep1(self):
1108                 self.steptimer = True
1109                 self.nextStepTimer.start(3000)
1110                 self["key_yellow"].setText(_("Stop test"))
1111
1112         def doStep2(self):
1113                 self["Adapter"].setText(iNetwork.getFriendlyAdapterName(self.iface))
1114                 self["Adapter"].setForegroundColorNum(2)
1115                 self["Adaptertext"].setForegroundColorNum(1)
1116                 self["AdapterInfo_Text"].setForegroundColorNum(1)
1117                 self["AdapterInfo_OK"].show()
1118                 self.steptimer = True
1119                 self.nextStepTimer.start(3000)
1120
1121         def doStep3(self):
1122                 self["Networktext"].setForegroundColorNum(1)
1123                 self["Network"].setText(_("Please wait..."))
1124                 self.getLinkState(self.iface)
1125                 self["NetworkInfo_Text"].setForegroundColorNum(1)
1126                 self.steptimer = True
1127                 self.nextStepTimer.start(3000)
1128
1129         def doStep4(self):
1130                 self["Dhcptext"].setForegroundColorNum(1)
1131                 if iNetwork.getAdapterAttribute(self.iface, 'dhcp') is True:
1132                         self["Dhcp"].setForegroundColorNum(2)
1133                         self["Dhcp"].setText(_("enabled"))
1134                         self["DhcpInfo_Check"].setPixmapNum(0)
1135                 else:
1136                         self["Dhcp"].setForegroundColorNum(1)
1137                         self["Dhcp"].setText(_("disabled"))
1138                         self["DhcpInfo_Check"].setPixmapNum(1)
1139                 self["DhcpInfo_Check"].show()
1140                 self["DhcpInfo_Text"].setForegroundColorNum(1)
1141                 self.steptimer = True
1142                 self.nextStepTimer.start(3000)
1143
1144         def doStep5(self):
1145                 self["IPtext"].setForegroundColorNum(1)
1146                 self["IP"].setText(_("Please wait..."))
1147                 iNetwork.checkNetworkState(self.NetworkStatedataAvail)
1148
1149         def doStep6(self):
1150                 self.steptimer = False
1151                 self.nextStepTimer.stop()
1152                 self["DNStext"].setForegroundColorNum(1)
1153                 self["DNS"].setText(_("Please wait..."))
1154                 iNetwork.checkDNSLookup(self.DNSLookupdataAvail)
1155
1156         def KeyGreen(self):
1157                 self["shortcutsgreen"].setEnabled(False)
1158                 self["shortcutsyellow"].setEnabled(True)
1159                 self["updown_actions"].setEnabled(False)
1160                 self["key_yellow"].setText("")
1161                 self["key_green"].setText("")
1162                 self.steptimer = True
1163                 self.nextStepTimer.start(1000)
1164
1165         def KeyGreenRestart(self):
1166                 self.nextstep = 0
1167                 self.layoutFinished()
1168                 self["Adapter"].setText((""))
1169                 self["Network"].setText((""))
1170                 self["Dhcp"].setText((""))
1171                 self["IP"].setText((""))
1172                 self["DNS"].setText((""))
1173                 self["AdapterInfo_Text"].setForegroundColorNum(0)
1174                 self["NetworkInfo_Text"].setForegroundColorNum(0)
1175                 self["DhcpInfo_Text"].setForegroundColorNum(0)
1176                 self["IPInfo_Text"].setForegroundColorNum(0)
1177                 self["DNSInfo_Text"].setForegroundColorNum(0)
1178                 self["shortcutsgreen_restart"].setEnabled(False)
1179                 self["shortcutsgreen"].setEnabled(False)
1180                 self["shortcutsyellow"].setEnabled(True)
1181                 self["updown_actions"].setEnabled(False)
1182                 self["key_yellow"].setText("")
1183                 self["key_green"].setText("")
1184                 self.steptimer = True
1185                 self.nextStepTimer.start(1000)
1186
1187         def KeyOK(self):
1188                 self["infoshortcuts"].setEnabled(True)
1189                 self["shortcuts"].setEnabled(False)
1190                 if self.activebutton == 1: # Adapter Check
1191                         self["InfoText"].setText(_("This test detects your configured LAN-Adapter."))
1192                         self["InfoTextBorder"].show()
1193                         self["InfoText"].show()
1194                         self["key_red"].setText(_("Back"))
1195                 if self.activebutton == 2: #LAN Check
1196                         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"))
1197                         self["InfoTextBorder"].show()
1198                         self["InfoText"].show()
1199                         self["key_red"].setText(_("Back"))
1200                 if self.activebutton == 3: #DHCP Check
1201                         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."))
1202                         self["InfoTextBorder"].show()
1203                         self["InfoText"].show()
1204                         self["key_red"].setText(_("Back"))
1205                 if self.activebutton == 4: # IP Check
1206                         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"))
1207                         self["InfoTextBorder"].show()
1208                         self["InfoText"].show()
1209                         self["key_red"].setText(_("Back"))
1210                 if self.activebutton == 5: # DNS Check
1211                         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"))
1212                         self["InfoTextBorder"].show()
1213                         self["InfoText"].show()
1214                         self["key_red"].setText(_("Back"))
1215                 if self.activebutton == 6: # Edit Settings
1216                         self.session.open(AdapterSetup,self.iface)
1217
1218         def KeyYellow(self):
1219                 self.nextstep = 0
1220                 self["shortcutsgreen_restart"].setEnabled(True)
1221                 self["shortcutsgreen"].setEnabled(False)
1222                 self["shortcutsyellow"].setEnabled(False)
1223                 self["key_green"].setText(_("Restart test"))
1224                 self["key_yellow"].setText("")
1225                 self.steptimer = False
1226                 self.nextStepTimer.stop()
1227
1228         def layoutFinished(self):
1229                 self["shortcutsyellow"].setEnabled(False)
1230                 self["AdapterInfo_OK"].hide()
1231                 self["NetworkInfo_Check"].hide()
1232                 self["DhcpInfo_Check"].hide()
1233                 self["IPInfo_Check"].hide()
1234                 self["DNSInfo_Check"].hide()
1235                 self["EditSettings_Text"].hide()
1236                 self["EditSettingsButton"].hide()
1237                 self["InfoText"].hide()
1238                 self["InfoTextBorder"].hide()
1239                 self["key_yellow"].setText("")
1240
1241         def setLabels(self):
1242                 self["Adaptertext"] = MultiColorLabel(_("LAN Adapter"))
1243                 self["Adapter"] = MultiColorLabel()
1244                 self["AdapterInfo"] = MultiPixmap()
1245                 self["AdapterInfo_Text"] = MultiColorLabel(_("Show Info"))
1246                 self["AdapterInfo_OK"] = Pixmap()
1247                 
1248                 if self.iface == 'wlan0' or self.iface == 'ath0':
1249                         self["Networktext"] = MultiColorLabel(_("Wireless Network"))
1250                 else:
1251                         self["Networktext"] = MultiColorLabel(_("Local Network"))
1252                 
1253                 self["Network"] = MultiColorLabel()
1254                 self["NetworkInfo"] = MultiPixmap()
1255                 self["NetworkInfo_Text"] = MultiColorLabel(_("Show Info"))
1256                 self["NetworkInfo_Check"] = MultiPixmap()
1257                 
1258                 self["Dhcptext"] = MultiColorLabel(_("DHCP"))
1259                 self["Dhcp"] = MultiColorLabel()
1260                 self["DhcpInfo"] = MultiPixmap()
1261                 self["DhcpInfo_Text"] = MultiColorLabel(_("Show Info"))
1262                 self["DhcpInfo_Check"] = MultiPixmap()
1263                 
1264                 self["IPtext"] = MultiColorLabel(_("IP Address"))
1265                 self["IP"] = MultiColorLabel()
1266                 self["IPInfo"] = MultiPixmap()
1267                 self["IPInfo_Text"] = MultiColorLabel(_("Show Info"))
1268                 self["IPInfo_Check"] = MultiPixmap()
1269                 
1270                 self["DNStext"] = MultiColorLabel(_("Nameserver"))
1271                 self["DNS"] = MultiColorLabel()
1272                 self["DNSInfo"] = MultiPixmap()
1273                 self["DNSInfo_Text"] = MultiColorLabel(_("Show Info"))
1274                 self["DNSInfo_Check"] = MultiPixmap()
1275                 
1276                 self["EditSettings_Text"] = MultiColorLabel(_("Edit settings"))
1277                 self["EditSettingsButton"] = MultiPixmap()
1278                 
1279                 self["key_red"] = StaticText(_("Close"))
1280                 self["key_green"] = StaticText(_("Start test"))
1281                 self["key_yellow"] = StaticText(_("Stop test"))
1282                 
1283                 self["InfoTextBorder"] = Pixmap()
1284                 self["InfoText"] = Label()
1285
1286         def getLinkState(self,iface):
1287                 if iface == 'wlan0' or iface == 'ath0':
1288                         try:
1289                                 from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
1290                         except:
1291                                         self["Network"].setForegroundColorNum(1)
1292                                         self["Network"].setText(_("disconnected"))
1293                                         self["NetworkInfo_Check"].setPixmapNum(1)
1294                                         self["NetworkInfo_Check"].show()
1295                         else:
1296                                 iStatus.getDataForInterface(self.iface,self.getInfoCB)
1297                 else:
1298                         iNetwork.getLinkState(iface,self.LinkStatedataAvail)
1299
1300         def LinkStatedataAvail(self,data):
1301                 self.output = data.strip()
1302                 result = self.output.split('\n')
1303                 pattern = re_compile("Link detected: yes")
1304                 for item in result:
1305                         if re_search(pattern, item):
1306                                 self["Network"].setForegroundColorNum(2)
1307                                 self["Network"].setText(_("connected"))
1308                                 self["NetworkInfo_Check"].setPixmapNum(0)
1309                         else:
1310                                 self["Network"].setForegroundColorNum(1)
1311                                 self["Network"].setText(_("disconnected"))
1312                                 self["NetworkInfo_Check"].setPixmapNum(1)
1313                 self["NetworkInfo_Check"].show()
1314
1315         def NetworkStatedataAvail(self,data):
1316                 if data <= 2:
1317                         self["IP"].setForegroundColorNum(2)
1318                         self["IP"].setText(_("confirmed"))
1319                         self["IPInfo_Check"].setPixmapNum(0)
1320                 else:
1321                         self["IP"].setForegroundColorNum(1)
1322                         self["IP"].setText(_("unconfirmed"))
1323                         self["IPInfo_Check"].setPixmapNum(1)
1324                 self["IPInfo_Check"].show()
1325                 self["IPInfo_Text"].setForegroundColorNum(1)            
1326                 self.steptimer = True
1327                 self.nextStepTimer.start(3000)          
1328                 
1329         def DNSLookupdataAvail(self,data):
1330                 if data <= 2:
1331                         self["DNS"].setForegroundColorNum(2)
1332                         self["DNS"].setText(_("confirmed"))
1333                         self["DNSInfo_Check"].setPixmapNum(0)
1334                 else:
1335                         self["DNS"].setForegroundColorNum(1)
1336                         self["DNS"].setText(_("unconfirmed"))
1337                         self["DNSInfo_Check"].setPixmapNum(1)
1338                 self["DNSInfo_Check"].show()
1339                 self["DNSInfo_Text"].setForegroundColorNum(1)
1340                 self["EditSettings_Text"].show()
1341                 self["EditSettingsButton"].setPixmapNum(1)
1342                 self["EditSettings_Text"].setForegroundColorNum(2) # active
1343                 self["EditSettingsButton"].show()
1344                 self["key_yellow"].setText("")
1345                 self["key_green"].setText(_("Restart test"))
1346                 self["shortcutsgreen"].setEnabled(False)
1347                 self["shortcutsgreen_restart"].setEnabled(True)
1348                 self["shortcutsyellow"].setEnabled(False)
1349                 self["updown_actions"].setEnabled(True)
1350                 self.activebutton = 6
1351
1352         def getInfoCB(self,data,status):
1353                 if data is not None:
1354                         if data is True:
1355                                 if status is not None:
1356                                         if status[self.iface]["acesspoint"] == "No Connection" or status[self.iface]["acesspoint"] == "Not-Associated" or status[self.iface]["acesspoint"] == False:
1357                                                 self["Network"].setForegroundColorNum(1)
1358                                                 self["Network"].setText(_("disconnected"))
1359                                                 self["NetworkInfo_Check"].setPixmapNum(1)
1360                                                 self["NetworkInfo_Check"].show()
1361                                         else:
1362                                                 self["Network"].setForegroundColorNum(2)
1363                                                 self["Network"].setText(_("connected"))
1364                                                 self["NetworkInfo_Check"].setPixmapNum(0)
1365                                                 self["NetworkInfo_Check"].show()
1366                                                 
1367         def cleanup(self):
1368                 iNetwork.stopLinkStateConsole()
1369                 iNetwork.stopDNSConsole()
1370                 try:
1371                         from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus,Status
1372                 except ImportError:
1373                         pass
1374                 else:
1375                         iStatus.stopWlanConsole()
1376