NetworkWizard/NetworkWizard.py: * fix automatic interface selection if only one netwo...

[enigma2.git] / lib / python / Plugins / SystemPlugins / NetworkWizard / NetworkWizard.py

diff --git a/lib/python/Plugins/SystemPlugins/NetworkWizard/NetworkWizard.py b/lib/python/Plugins/SystemPlugins/NetworkWizard/NetworkWizard.py
index b158cde1e4a51269fd1e84668ffcb8497e6fd03c..a8b34acd8aaa172cc8de8a3f9f493ec48d231917 100755 (executable)
--- a/lib/python/Plugins/SystemPlugins/NetworkWizard/NetworkWizard.py
+++ b/lib/python/Plugins/SystemPlugins/NetworkWizard/NetworkWizard.py
@@ -2,14 +2,12 @@ from Screens.Wizard import wizardManager, WizardSummary
 from Screens.WizardLanguage import WizardLanguage
 from Screens.Rc import Rc
 from Screens.MessageBox import MessageBox
 from Screens.WizardLanguage import WizardLanguage
 from Screens.Rc import Rc
 from Screens.MessageBox import MessageBox

-

 from Components.Pixmap import Pixmap, MovingPixmap, MultiPixmap
 from Components.Sources.Boolean import Boolean
 from Components.config import config, ConfigBoolean, configfile, ConfigYesNo, NoSave, ConfigSubsection, ConfigText, getConfigListEntry, ConfigSelection, ConfigPassword
 from Components.Network import iNetwork
 from Components.Pixmap import Pixmap, MovingPixmap, MultiPixmap
 from Components.Sources.Boolean import Boolean
 from Components.config import config, ConfigBoolean, configfile, ConfigYesNo, NoSave, ConfigSubsection, ConfigText, getConfigListEntry, ConfigSelection, ConfigPassword
 from Components.Network import iNetwork

-

 from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_SKIN_IMAGE
 from Tools.Directories import resolveFilename, SCOPE_PLUGINS, SCOPE_SKIN_IMAGE

-
+from enigma import eTimer

 
 config.misc.firstrun = ConfigBoolean(default = True)
 list = []
 
 config.misc.firstrun = ConfigBoolean(default = True)
 list = []


@@ -53,7 +51,7 @@ class NetworkWizard(WizardLanguage, Rc):
                        </widget>
                        <widget name="HelpWindow" pixmap="skin_default/buttons/key_text.png" position="125,170" zPosition="1" size="1,1" transparent="1" alphatest="on" />      
                </screen>"""
                        </widget>
                        <widget name="HelpWindow" pixmap="skin_default/buttons/key_text.png" position="125,170" zPosition="1" size="1,1" transparent="1" alphatest="on" />      
                </screen>"""

-       def __init__(self, session):
+       def __init__(self, session, interface = None):

                self.xmlfile = resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")
                WizardLanguage.__init__(self, session, showSteps = False, showStepSlider = False)
                Rc.__init__(self)
                self.xmlfile = resolveFilename(SCOPE_PLUGINS, "SystemPlugins/NetworkWizard/networkwizard.xml")
                WizardLanguage.__init__(self, session, showSteps = False, showStepSlider = False)
                Rc.__init__(self)


@@ -63,19 +61,100 @@ class NetworkWizard(WizardLanguage, Rc):
                self["HelpWindow"].hide()
                self["VKeyIcon"] = Boolean(False)
 
                self["HelpWindow"].hide()
                self["VKeyIcon"] = Boolean(False)
 

+               self.InstalledInterfaceCount = None
+               self.Adapterlist = None

                self.InterfaceState = None
                self.isInterfaceUp = None
                self.WlanPluginInstalled = None
                self.ap = None
                self.InterfaceState = None
                self.isInterfaceUp = None
                self.WlanPluginInstalled = None
                self.ap = None

-               self.selectedInterface = None
+               if interface is not None:
+                       self.selectedInterface = interface
+               else:
+                       self.selectedInterface = None

                self.NextStep = None
                self.NextStep = None

-               self.myref = None
+               self.resetRef = None

                self.checkRef = None
                self.AdapterRef = None
                self.checkRef = None
                self.AdapterRef = None

+               self.APList = None
+               self.newAPlist = None

                self.WlanList = None
                self.WlanList = None

+               self.oldlist = None
+               self.originalAth0State = None
+               self.originalEth0State = None
+               self.originalWlan0State = None
+               self.originalInterfaceStateChanged = False
+               self.Text = None
+               self.rescanTimer = eTimer()
+               self.rescanTimer.callback.append(self.rescanTimerFired)
+               self.getInstalledInterfaceCount()

                self.isWlanPluginInstalled()
                self.isWlanPluginInstalled()

+               
+       def exitWizardQuestion(self, ret = False):
+               if (ret):
+                       self.markDone()
+                       self.close()
+               
+       def markDone(self):
+               self.rescanTimer.stop()
+               del self.rescanTimer
+               self.checkOldInterfaceState()
+               pass
+
+       def getInstalledInterfaceCount(self):
+               self.rescanTimer.stop()
+               self.Adapterlist = iNetwork.getAdapterList()
+               self.InstalledInterfaceCount = len(self.Adapterlist)
+               if self.Adapterlist is not None:
+                       if self.InstalledInterfaceCount == 1 and self.selectedInterface is None:
+                                       self.selectedInterface = self.Adapterlist[0]
+               self.originalAth0State = iNetwork.getAdapterAttribute('ath0', 'up')
+               self.originalEth0State = iNetwork.getAdapterAttribute('eth0', 'up')
+               self.originalWlan0State = iNetwork.getAdapterAttribute('wlan0', 'up')
+
+       def selectInterface(self):
+               self.InterfaceState = None
+               if self.selectedInterface is None and self.InstalledInterfaceCount <= 1:
+                       if self.selectedInterface == 'eth0':
+                               self.NextStep = 'nwconfig'
+                       else:
+                               self.NextStep = 'scanwlan'
+                       self.checkInterface(self.selectedInterface)
+               elif self.selectedInterface is not None and self.InstalledInterfaceCount <= 1:
+                       if self.selectedInterface == 'eth0':
+                               self.NextStep = 'nwconfig'
+                       else:
+                               self.NextStep = 'scanwlan'
+                       self.checkInterface(self.selectedInterface)
+               elif self.selectedInterface is None and self.InstalledInterfaceCount > 1:
+                       self.NextStep = 'selectinterface'
+                       self.currStep = self.getStepWithID(self.NextStep)
+                       self.afterAsyncCode()
+               elif self.selectedInterface is not None and self.InstalledInterfaceCount > 1:
+                       if self.selectedInterface == 'eth0':
+                               self.NextStep = 'nwconfig'
+                       else:
+                               self.NextStep = 'scanwlan'
+                       self.checkInterface(self.selectedInterface)
+               else:
+                       self.NextStep = 'selectinterface'
+                       self.currStep = self.getStepWithID(self.NextStep)
+                       self.afterAsyncCode()                   
+
+       def checkOldInterfaceState(self):
+               # disable up interface if it was originally down and config is unchanged.
+               if self.originalAth0State is False and self.originalInterfaceStateChanged is False:
+                       if iNetwork.checkforInterface('ath0') is True:
+                               iNetwork.deactivateInterface('ath0')            
+               if self.originalEth0State is False and self.originalInterfaceStateChanged is False:
+                       if iNetwork.checkforInterface('eth0') is True:
+                               iNetwork.deactivateInterface('eth0')
+               if self.originalWlan0State is False and self.originalInterfaceStateChanged is False:
+                       if iNetwork.checkforInterface('wlan0') is True:
+                               iNetwork.deactivateInterface('wlan0')

 
        def listInterfaces(self):
 
        def listInterfaces(self):

+               self.rescanTimer.stop()
+               self.checkOldInterfaceState()

                list = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
                list.append((_("Exit network wizard"), "end"))
                return list
                list = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()]
                list.append((_("Exit network wizard"), "end"))
                return list


@@ -96,46 +175,30 @@ class NetworkWizard(WizardLanguage, Rc):
                self.InterfaceSelect(self.selection)
                
        def checkInterface(self,iface):
                self.InterfaceSelect(self.selection)
                
        def checkInterface(self,iface):

-               self.Adapterlist = iNetwork.getAdapterList()
+               self.rescanTimer.stop()
+               if self.Adapterlist is None:
+                       self.Adapterlist = iNetwork.getAdapterList()

                if self.NextStep is not 'end':
                        if len(self.Adapterlist) == 0:
                                #Reset Network to defaults if network broken
                if self.NextStep is not 'end':
                        if len(self.Adapterlist) == 0:
                                #Reset Network to defaults if network broken

-                               iNetwork.resetNetworkConfig('lan', self.checkInterfaceCB)
-                               self.myref = self.session.openWithCallback(self.resetfinishedCB, MessageBox, _("Please wait while we prepare your network interfaces..."), type = MessageBox.TYPE_INFO, enable_input = False)
-                       if iface == 'eth0':
-                               if iface in iNetwork.configuredNetworkAdapters and len(iNetwork.configuredNetworkAdapters) == 1:
-                                       if iNetwork.getAdapterAttribute(iface, 'up') is True:
-                                               self.isInterfaceUp = True
-                                       else:
-                                               self.isInterfaceUp = False
-                                       self.resetfinishedCB(False)
-                               else:
-                                       iNetwork.resetNetworkConfig('lan',self.checkInterfaceCB)
-                                       self.myref = self.session.openWithCallback(self.resetfinishedCB, MessageBox, _("Please wait while we prepare your network interfaces..."), type = MessageBox.TYPE_INFO, enable_input = False)
-                       elif iface == 'wlan0':
+                               iNetwork.resetNetworkConfig('lan', self.resetNetworkConfigCB)
+                               self.resetRef = self.session.openWithCallback(self.resetNetworkConfigFinished, MessageBox, _("Please wait while we prepare your network interfaces..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                       if iface in ('eth0', 'wlan0', 'ath0'):

                                if iface in iNetwork.configuredNetworkAdapters and len(iNetwork.configuredNetworkAdapters) == 1:
                                        if iNetwork.getAdapterAttribute(iface, 'up') is True:
                                                self.isInterfaceUp = True
                                        else:
                                                self.isInterfaceUp = False
                                if iface in iNetwork.configuredNetworkAdapters and len(iNetwork.configuredNetworkAdapters) == 1:
                                        if iNetwork.getAdapterAttribute(iface, 'up') is True:
                                                self.isInterfaceUp = True
                                        else:
                                                self.isInterfaceUp = False

-                                       self.resetfinishedCB(False)
+                                       self.currStep = self.getStepWithID(self.NextStep)
+                                       self.afterAsyncCode()

                                else:
                                else:

-                                       iNetwork.resetNetworkConfig('wlan',self.checkInterfaceCB)
-                                       self.myref = self.session.openWithCallback(self.resetfinishedCB, MessageBox, _("Please wait while we prepare your network interfaces..."), type = MessageBox.TYPE_INFO, enable_input = False)
-                       elif iface == 'ath0':
-                               if iface in iNetwork.configuredNetworkAdapters and len(iNetwork.configuredNetworkAdapters) == 1:
-                                       if iNetwork.getAdapterAttribute(iface, 'up') is True:
-                                               self.isInterfaceUp = True
-                                       else:
-                                               self.isInterfaceUp = False
-                                       self.resetfinishedCB(False)
-                               else:
-                                       iNetwork.resetNetworkConfig('wlan-mpci',self.checkInterfaceCB)
-                                       self.myref = self.session.openWithCallback(self.resetfinishedCB, MessageBox, _("Please wait while we prepare your network interfaces..."), type = MessageBox.TYPE_INFO, enable_input = False)
+                                       self.isInterfaceUp = iNetwork.checkforInterface(iface)
+                                       self.currStep = self.getStepWithID(self.NextStep)
+                                       self.afterAsyncCode()

                else:
                else:

-                       self.resetfinishedCB(False)
+                       self.resetNetworkConfigFinished(False)

                        
                        

-       def resetfinishedCB(self,data):
+       def resetNetworkConfigFinished(self,data):

                if data is True:
                        self.currStep = self.getStepWithID(self.NextStep)
                        self.afterAsyncCode()
                if data is True:
                        self.currStep = self.getStepWithID(self.NextStep)
                        self.afterAsyncCode()


@@ -143,33 +206,42 @@ class NetworkWizard(WizardLanguage, Rc):
                        self.currStep = self.getStepWithID(self.NextStep)
                        self.afterAsyncCode()
 
                        self.currStep = self.getStepWithID(self.NextStep)
                        self.afterAsyncCode()
 

-       def checkInterfaceCB(self,callback,iface):
+       def resetNetworkConfigCB(self,callback,iface):

                if callback is not None:
                        if callback is True:
                if callback is not None:
                        if callback is True:

-                               iNetwork.getInterfaces(self.getInterfacesDataAvail)
+                               iNetwork.getInterfaces(self.getInterfacesFinished)

                                
                                

-
-       def getInterfacesDataAvail(self, data):
+       def getInterfacesFinished(self, data):

                if data is True:
                        if iNetwork.getAdapterAttribute(self.selectedInterface, 'up') is True:
                                self.isInterfaceUp = True
                        else:
                                self.isInterfaceUp = False
                if data is True:
                        if iNetwork.getAdapterAttribute(self.selectedInterface, 'up') is True:
                                self.isInterfaceUp = True
                        else:
                                self.isInterfaceUp = False

-                       self.myref.close(True)
+                       self.resetRef.close(True)
+               else:
+                       print "we should never come here!"

 
        def AdapterSetupEnd(self, iface):
 
        def AdapterSetupEnd(self, iface):

+               self.originalInterfaceStateChanged = True

                if iNetwork.getAdapterAttribute(iface, "dhcp") is True:
                        iNetwork.checkNetworkState(self.AdapterSetupEndFinished)
                        self.AdapterRef = self.session.openWithCallback(self.AdapterSetupEndCB, MessageBox, _("Please wait while we test your network..."), type = MessageBox.TYPE_INFO, enable_input = False)
                if iNetwork.getAdapterAttribute(iface, "dhcp") is True:
                        iNetwork.checkNetworkState(self.AdapterSetupEndFinished)
                        self.AdapterRef = self.session.openWithCallback(self.AdapterSetupEndCB, MessageBox, _("Please wait while we test your network..."), type = MessageBox.TYPE_INFO, enable_input = False)

-

                else:
                        self.currStep = self.getStepWithID("confdns")
                        self.afterAsyncCode()
 
        def AdapterSetupEndCB(self,data):
                if data is True:
                else:
                        self.currStep = self.getStepWithID("confdns")
                        self.afterAsyncCode()
 
        def AdapterSetupEndCB(self,data):
                if data is True:

-                       self.currStep = self.getStepWithID("checklanstatusend")
-                       self.afterAsyncCode()
+                       if self.selectedInterface in ('wlan0', 'ath0'):
+                               if self.WlanPluginInstalled == True:
+                                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+                                       iStatus.getDataForInterface(self.selectedInterface,self.checkWlanStateCB)
+                               else:
+                                       self.currStep = self.getStepWithID("checklanstatusend")
+                                       self.afterAsyncCode()                                   
+                       else:
+                               self.currStep = self.getStepWithID("checklanstatusend")
+                               self.afterAsyncCode()

 
        def AdapterSetupEndFinished(self,data):
                if data <= 2:
 
        def AdapterSetupEndFinished(self,data):
                if data <= 2:


@@ -178,66 +250,147 @@ class NetworkWizard(WizardLanguage, Rc):
                        self.InterfaceState = False
                self.AdapterRef.close(True)
                        
                        self.InterfaceState = False
                self.AdapterRef.close(True)
                        

+       def checkWlanStateCB(self,data,status):
+               if data is not None:
+                       if data is True:
+                               if status is not None:
+                                       text1 = _("Your Dreambox is now ready to use.\n\nYour internet connection is working now.\n\n")
+                                       text2 = _('Accesspoint:') + "\t" + str(status[self.selectedInterface]["acesspoint"]) + "\n"
+                                       text3 = _('SSID:') + "\t" + str(status[self.selectedInterface]["essid"]) + "\n"
+                                       text4 = _('Link Quality:') + "\t" + str(status[self.selectedInterface]["quality"])+"%" + "\n"
+                                       text5 = _('Signal Strength:') + "\t" + str(status[self.selectedInterface]["signal"]) + "\n"
+                                       text6 = _('Bitrate:') + "\t" + str(status[self.selectedInterface]["bitrate"]) + "\n"
+                                       text7 = _('Encryption:') + " " + str(status[self.selectedInterface]["encryption"]) + "\n"
+                                       text8 = _("Please press OK to continue.")
+                                       infotext = text1 + text2 + text3 + text4 + text5 + text7 +"\n" + text8
+                                       self.currStep = self.getStepWithID("checkWlanstatusend")
+                                       self.Text = infotext
+                                       if str(status[self.selectedInterface]["acesspoint"]) == "Not-Associated":
+                                               self.InterfaceState = False
+                                       self.afterAsyncCode()
+

        def checkNetwork(self):
        def checkNetwork(self):

-               iNetwork.checkNetworkState(self.checkNetworkStateFinished)
+               iNetwork.checkNetworkState(self.checkNetworkStateCB)

                self.checkRef = self.session.openWithCallback(self.checkNetworkCB, MessageBox, _("Please wait while we test your network..."), type = MessageBox.TYPE_INFO, enable_input = False)
 
        def checkNetworkCB(self,data):
                if data is True:
                self.checkRef = self.session.openWithCallback(self.checkNetworkCB, MessageBox, _("Please wait while we test your network..."), type = MessageBox.TYPE_INFO, enable_input = False)
 
        def checkNetworkCB(self,data):
                if data is True:

-                       self.currStep = self.getStepWithID("checklanstatusend")
-                       self.afterAsyncCode()
+                       if self.selectedInterface in ('wlan0', 'ath0'):
+                               if self.WlanPluginInstalled == True:
+                                       from Plugins.SystemPlugins.WirelessLan.Wlan import iStatus
+                                       iStatus.getDataForInterface(self.selectedInterface,self.checkWlanStateCB)
+                               else:
+                                       self.currStep = self.getStepWithID("checklanstatusend")
+                                       self.afterAsyncCode()                                   
+                       else:
+                               self.currStep = self.getStepWithID("checklanstatusend")
+                               self.afterAsyncCode()

 
 

-       def checkNetworkStateFinished(self,data):
+       def checkNetworkStateCB(self,data):

                if data <= 2:
                        self.InterfaceState = True
                else:
                        self.InterfaceState = False
                self.checkRef.close(True)
        
                if data <= 2:
                        self.InterfaceState = True
                else:
                        self.InterfaceState = False
                self.checkRef.close(True)
        

-       def markDone(self):
-               pass
+       def rescanTimerFired(self):
+               self.rescanTimer.stop()
+               self.updateAPList()

 
 

-       def listModes(self):
-               list = []
-               self.WlanList = []
+       def updateAPList(self):
+               self.oldlist = self.APList
+               self.newAPlist = []
+               newList = []
+               newListIndex = None
+               currentListEntry = None
+               newList = self.listAccessPoints()
+
+               for oldentry in self.oldlist:
+                       if oldentry not in newList:
+                               newList.append(oldentry)
+                               
+               for newentry in newList:
+                       if newentry[1] == "hidden...":
+                               continue
+                       self.newAPlist.append(newentry)
+               
+               if len(self.newAPlist):
+                       if "hidden..." not in self.newAPlist:
+                               self.newAPlist.append(( _("enter hidden network SSID"), "hidden..." ))
+
+                       if (self.wizard[self.currStep].has_key("dynamiclist")):
+                               currentListEntry = self["list"].getCurrent()
+                               idx = 0
+                               for entry in self.newAPlist:
+                                       if entry == currentListEntry:
+                                               newListIndex = idx
+                                       idx +=1
+                               self.wizard[self.currStep]["evaluatedlist"] = self.newAPlist
+                               self['list'].setList(self.newAPlist)
+                               self["list"].setIndex(newListIndex)
+                               self["list"].updateList(self.newAPlist)
+
+       def listAccessPoints(self):
+               self.APList = []

                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
                except ImportError:
                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
                except ImportError:

-                       list.append( ( _("No networks found"),_("unavailable") ) )
-                       self.WlanList.append(_("No networks found"))
-                       return list
-               else:   
-                       self.w = Wlan(self.selectedInterface)
-                       aps = self.w.getNetworkList()
-                       if aps is not None:
-                               print "[NetworkWizard.py] got Accespoints!"
-                               for ap in aps:
-                                       a = aps[ap]
-                                       if a['active']:
-                                               if a['essid'] != "":
-                                                       #a['essid'] = a['bssid']
-                                                       list.append( (a['essid'], a['essid']) )
-                                                       self.WlanList.append(a['essid'])        
-                       if "hidden..." not in list:
-                               list.append( ( _("enter hidden network SSID"),_("hidden...") ) )
-                               self.WlanList.append(_("hidden..."))    
-                       return list
-
-       def modeSelectionMade(self, index):
-               self.modeSelect(index)
-               
-       def modeSelectionMoved(self):
-               self.modeSelect(self.selection)
-               
-       def modeSelect(self, mode):
-               self.ap = mode
-               print "ModeSelected:", mode
-
-       def restartNetwork(self):
-               iNetwork.restartNetwork()
-               self.checkNetwork()
+                       self.APList.append( ( _("No networks found"),_("unavailable") ) )
+                       return self.APList
+               else:
+                       try:
+                               self.w = Wlan(self.selectedInterface)
+                               aps = self.w.getNetworkList()
+                       except ValueError:
+                               self.APList = []
+                               self.APList.append( ( _("No networks found"),_("unavailable") ) )
+                               return self.APList
+                       else:
+                               if aps is not None:
+                                       print "[NetworkWizard.py] got Accespoints!"
+                                       tmplist = []
+                                       complist = []
+                                       for ap in aps:
+                                               a = aps[ap]
+                                               if a['active']:
+                                                       tmplist.append( (a['bssid'], a['essid']) )
+                                                       complist.append( (a['bssid'], a['essid']) )
+                                       
+                                       for entry in tmplist:
+                                               if entry[1] == "":
+                                                       for compentry in complist:
+                                                               if compentry[0] == entry[0]:
+                                                                       complist.remove(compentry)
+                                       for entry in complist:
+                                               self.APList.append( (entry[1], entry[1]) )

        
        

-       def isWlanPluginInstalled(self):                
+                               if "hidden..." not in self.APList:
+                                       self.APList.append(( _("enter hidden network SSID"), "hidden..." ))
+                       
+                               self.rescanTimer.start(3000)
+                               return self.APList
+
+       def AccessPointsSelectionMade(self, index):
+               self.ap = index
+               self.WlanList = []
+               currList = []
+               if (self.wizard[self.currStep].has_key("dynamiclist")):
+                       currList = self['list'].list
+                       for entry in currList:
+                               self.WlanList.append( (entry[1], entry[0]) )
+               self.AccessPointsSelect(index)
+
+       def AccessPointsSelect(self, index):
+               self.NextStep = 'wlanconfig'
+
+       def AccessPointsSelectionMoved(self):
+               self.AccessPointsSelect(self.selection)
+
+       def checkWlanSelection(self):
+               self.rescanTimer.stop()
+               self.currStep = self.getStepWithID(self.NextStep)
+
+       def isWlanPluginInstalled(self):

                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
                except ImportError:
                try:
                        from Plugins.SystemPlugins.WirelessLan.Wlan import Wlan
                except ImportError:


@@ -245,3 +398,27 @@ class NetworkWizard(WizardLanguage, Rc):
                else:
                        self.WlanPluginInstalled = True
 
                else:
                        self.WlanPluginInstalled = True
 

+       def listChoices(self):
+               self.rescanTimer.stop()
+               list = []
+               if self.WlanPluginInstalled == True:
+                       list.append((_("Configure your wireless LAN again"), "scanwlan"))
+               list.append((_("Configure your internal LAN"), "nwconfig"))
+               list.append((_("Exit network wizard"), "end"))          
+               return list
+
+       def ChoicesSelectionMade(self, index):
+               self.ChoicesSelect(index)
+
+       def ChoicesSelect(self, index):
+               if index == 'end':
+                       self.NextStep = 'end'
+               elif index == 'nwconfig':
+                       self.selectedInterface = "eth0"
+                       self.NextStep = 'nwconfig'
+               else:
+                       self.NextStep = 'scanwlan'
+
+       def ChoicesSelectionMoved(self):
+               pass
+