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