TaskView: correctly pop-up aborted/failed notifications in foreground

[enigma2.git] / lib / python / Screens / Wizard.py

diff --git a/lib/python/Screens/Wizard.py b/lib/python/Screens/Wizard.py
old mode 100644 (file)
new mode 100755 (executable)
index 1d099c9..a752d31
--- a/lib/python/Screens/Wizard.py
+++ b/lib/python/Screens/Wizard.py
@@ -1,16 +1,15 @@
 from Screen import Screen
 from Screen import Screen

-
-import string
-

 from Screens.HelpMenu import HelpableScreen
 from Screens.HelpMenu import HelpableScreen

-from Components.config import config
+from Screens.MessageBox import MessageBox
+from Components.config import config, ConfigText, ConfigPassword, KEY_LEFT, KEY_RIGHT, KEY_HOME, KEY_END, KEY_0, KEY_DELETE, KEY_BACKSPACE, KEY_OK, KEY_TOGGLEOW, KEY_ASCII, KEY_TIMEOUT, KEY_NUMBERS
+

 from Components.Label import Label
 from Components.Label import Label

+from Components.Sources.StaticText import StaticText

 from Components.Slider import Slider
 from Components.ActionMap import NumberActionMap
 from Components.MenuList import MenuList
 from Components.ConfigList import ConfigList
 from Components.Sources.List import List
 from Components.Slider import Slider
 from Components.ActionMap import NumberActionMap
 from Components.MenuList import MenuList
 from Components.ConfigList import ConfigList
 from Components.Sources.List import List

-

 from enigma import eTimer
 
 from xml.sax import make_parser
 from enigma import eTimer
 
 from xml.sax import make_parser


@@ -19,8 +18,8 @@ from xml.sax.handler import ContentHandler
 class WizardSummary(Screen):
        skin = """
        <screen position="0,0" size="132,64">
 class WizardSummary(Screen):
        skin = """
        <screen position="0,0" size="132,64">

-               <widget name="text" position="6,4" size="120,42" font="Regular;14" transparent="1" />
-               <widget source="parent.list" render="Label" position="6,25" size="120,21" font="Regular;16">
+               <widget source="text" render="Label" position="6,0" size="120,16" font="Regular;16" transparent="1" />
+               <widget source="parent.list" render="Label" position="6,18" size="120,46" font="Regular;12">

                        <convert type="StringListSelection" />
                </widget>
        </screen>"""
                        <convert type="StringListSelection" />
                </widget>
        </screen>"""


@@ -36,7 +35,7 @@ class WizardSummary(Screen):
                #self.skinName.append("Wizard")
                #print "*************+++++++++++++++++****************++++++++++******************* WizardSummary", self.skinName
                        #
                #self.skinName.append("Wizard")
                #print "*************+++++++++++++++++****************++++++++++******************* WizardSummary", self.skinName
                        #

-               self["text"] = Label("")
+               self["text"] = StaticText("")

                self.onShow.append(self.setCallback)
                
        def setCallback(self):
                self.onShow.append(self.setCallback)
                
        def setCallback(self):


@@ -45,7 +44,7 @@ class WizardSummary(Screen):
        def setText(self, text):
                self["text"].setText(text)
 
        def setText(self, text):
                self["text"].setText(text)
 

-class Wizard(Screen, HelpableScreen):
+class Wizard(Screen):

        def createSummary(self):
                        print "WizardCreateSummary"
                        return WizardSummary
        def createSummary(self):
                        print "WizardCreateSummary"
                        return WizardSummary


@@ -55,12 +54,10 @@ class Wizard(Screen, HelpableScreen):
                        self.isPointsElement, self.isReboundsElement = 0, 0
                        self.wizard = wizard
                        self.currContent = ""
                        self.isPointsElement, self.isReboundsElement = 0, 0
                        self.wizard = wizard
                        self.currContent = ""

-                       self.lastStep = 0
-                       
-               
-               
+                       self.lastStep = 0       
+

                def startElement(self, name, attrs):
                def startElement(self, name, attrs):

-                       print "startElement", name
+                       #print "startElement", name

                        self.currContent = name
                        if (name == "step"):
                                self.lastStep += 1
                        self.currContent = name
                        if (name == "step"):
                                self.lastStep += 1


@@ -68,7 +65,7 @@ class Wizard(Screen, HelpableScreen):
                                        id = str(attrs.get('id'))
                                else:
                                        id = ""
                                        id = str(attrs.get('id'))
                                else:
                                        id = ""

-                               print "id:", id
+                               #print "id:", id

                                if attrs.has_key('nextstep'):
                                        nextstep = str(attrs.get('nextstep'))
                                else:
                                if attrs.has_key('nextstep'):
                                        nextstep = str(attrs.get('nextstep'))
                                else:


@@ -86,73 +83,104 @@ class Wizard(Screen, HelpableScreen):
                                        timeoutstep = str(attrs.get('timeoutstep'))
                                else:
                                        timeoutstep = ''
                                        timeoutstep = str(attrs.get('timeoutstep'))
                                else:
                                        timeoutstep = ''

-                               self.wizard[self.lastStep] = {"id": id, "condition": "", "text": "", "timeout": timeout, "timeoutaction": timeoutaction, "timeoutstep": timeoutstep, "list": [], "config": {"screen": None, "args": None, "type": "" }, "code": "", "codeafter": "", "nextstep": nextstep}
+                               self.wizard[self.lastStep] = {"id": id, "condition": "", "text": "", "timeout": timeout, "timeoutaction": timeoutaction, "timeoutstep": timeoutstep, "list": [], "config": {"screen": None, "args": None, "type": "" }, "code": "", "codeafter": "", "code_async": "", "codeafter_async": "", "nextstep": nextstep}
+                               if attrs.has_key('laststep'):
+                                       self.wizard[self.lastStep]["laststep"] = str(attrs.get('laststep'))

                        elif (name == "text"):
                        elif (name == "text"):

-                               self.wizard[self.lastStep]["text"] = string.replace(str(attrs.get('value')), "\\n", "\n")
+                               self.wizard[self.lastStep]["text"] = str(attrs.get('value')).replace("\\n", "\n")

                        elif (name == "displaytext"):
                        elif (name == "displaytext"):

-                               self.wizard[self.lastStep]["displaytext"] = string.replace(str(attrs.get('value')), "\\n", "\n")
+                               self.wizard[self.lastStep]["displaytext"] = str(attrs.get('value')).replace("\\n", "\n")

                        elif (name == "list"):
                                if (attrs.has_key('type')):
                                        if attrs["type"] == "dynamic":
                                                self.wizard[self.lastStep]["dynamiclist"] = attrs.get("source")
                                        #self.wizard[self.lastStep]["list"].append(("Hallo", "test"))
                                if (attrs.has_key("evaluation")):
                        elif (name == "list"):
                                if (attrs.has_key('type')):
                                        if attrs["type"] == "dynamic":
                                                self.wizard[self.lastStep]["dynamiclist"] = attrs.get("source")
                                        #self.wizard[self.lastStep]["list"].append(("Hallo", "test"))
                                if (attrs.has_key("evaluation")):

-                                       print "evaluation"
+                                       #print "evaluation"

                                        self.wizard[self.lastStep]["listevaluation"] = attrs.get("evaluation")
                                if (attrs.has_key("onselect")):
                                        self.wizard[self.lastStep]["onselect"] = attrs.get("onselect")                  
                        elif (name == "listentry"):
                                self.wizard[self.lastStep]["list"].append((str(attrs.get('caption')), str(attrs.get('step'))))
                        elif (name == "config"):
                                        self.wizard[self.lastStep]["listevaluation"] = attrs.get("evaluation")
                                if (attrs.has_key("onselect")):
                                        self.wizard[self.lastStep]["onselect"] = attrs.get("onselect")                  
                        elif (name == "listentry"):
                                self.wizard[self.lastStep]["list"].append((str(attrs.get('caption')), str(attrs.get('step'))))
                        elif (name == "config"):

-                               exec "from Screens." + str(attrs.get('module')) + " import *"
-                               self.wizard[self.lastStep]["config"]["screen"] = eval(str(attrs.get('screen')))
-                               if (attrs.has_key('args')):
-                                       print "has args"
-                                       self.wizard[self.lastStep]["config"]["args"] = str(attrs.get('args'))
-                               self.wizard[self.lastStep]["config"]["type"] = str(attrs.get('type'))
+                               type = str(attrs.get('type'))
+                               self.wizard[self.lastStep]["config"]["type"] = type
+                               if type == "ConfigList" or type == "standalone":
+                                       try:
+                                               exec "from Screens." + str(attrs.get('module')) + " import *"
+                                       except:
+                                               exec "from " + str(attrs.get('module')) + " import *"
+                               
+                                       self.wizard[self.lastStep]["config"]["screen"] = eval(str(attrs.get('screen')))
+                                       if (attrs.has_key('args')):
+                                               #print "has args"
+                                               self.wizard[self.lastStep]["config"]["args"] = str(attrs.get('args'))
+                               elif type == "dynamic":
+                                       self.wizard[self.lastStep]["config"]["source"] = str(attrs.get('source'))
+                                       if (attrs.has_key('evaluation')):
+                                               self.wizard[self.lastStep]["config"]["evaluation"] = str(attrs.get('evaluation'))

                        elif (name == "code"):
                        elif (name == "code"):

+                               self.async_code = attrs.has_key('async') and str(attrs.get('async')) == "yes"

                                if attrs.has_key('pos') and str(attrs.get('pos')) == "after":
                                        self.codeafter = True
                                else:
                                        self.codeafter = False
                        elif (name == "condition"):
                                pass
                                if attrs.has_key('pos') and str(attrs.get('pos')) == "after":
                                        self.codeafter = True
                                else:
                                        self.codeafter = False
                        elif (name == "condition"):
                                pass

+                       

                def endElement(self, name):
                        self.currContent = ""
                        if name == 'code':
                def endElement(self, name):
                        self.currContent = ""
                        if name == 'code':

-                               if self.codeafter:
-                                       self.wizard[self.lastStep]["codeafter"] = self.wizard[self.lastStep]["codeafter"].strip()
+                               if self.async_code:
+                                       if self.codeafter:
+                                               self.wizard[self.lastStep]["codeafter_async"] = self.wizard[self.lastStep]["codeafter_async"].strip()
+                                       else:
+                                               self.wizard[self.lastStep]["code_async"] = self.wizard[self.lastStep]["code_async"].strip()

                                else:
                                else:

-                                       self.wizard[self.lastStep]["code"] = self.wizard[self.lastStep]["code"].strip()
+                                       if self.codeafter:
+                                               self.wizard[self.lastStep]["codeafter"] = self.wizard[self.lastStep]["codeafter"].strip()
+                                       else:
+                                               self.wizard[self.lastStep]["code"] = self.wizard[self.lastStep]["code"].strip()

                        elif name == 'condition':
                                self.wizard[self.lastStep]["condition"] = self.wizard[self.lastStep]["condition"].strip()
                        elif name == 'step':
                        elif name == 'condition':
                                self.wizard[self.lastStep]["condition"] = self.wizard[self.lastStep]["condition"].strip()
                        elif name == 'step':

-                               print "Step number", self.lastStep, ":", self.wizard[self.lastStep]
+                               #print "Step number", self.lastStep, ":", self.wizard[self.lastStep]
+                               pass

                                                                
                def characters(self, ch):
                        if self.currContent == "code":
                                                                
                def characters(self, ch):
                        if self.currContent == "code":

-                               if self.codeafter:
-                                       self.wizard[self.lastStep]["codeafter"] = self.wizard[self.lastStep]["codeafter"] + ch
+                               if self.async_code:
+                                       if self.codeafter:
+                                               self.wizard[self.lastStep]["codeafter_async"] = self.wizard[self.lastStep]["codeafter_async"] + ch
+                                       else:
+                                               self.wizard[self.lastStep]["code_async"] = self.wizard[self.lastStep]["code_async"] + ch

                                else:
                                else:

-                                       self.wizard[self.lastStep]["code"] = self.wizard[self.lastStep]["code"] + ch
+                                       if self.codeafter:
+                                               self.wizard[self.lastStep]["codeafter"] = self.wizard[self.lastStep]["codeafter"] + ch
+                                       else:
+                                               self.wizard[self.lastStep]["code"] = self.wizard[self.lastStep]["code"] + ch

                        elif self.currContent == "condition":
                                 self.wizard[self.lastStep]["condition"] = self.wizard[self.lastStep]["condition"] + ch
                        elif self.currContent == "condition":
                                 self.wizard[self.lastStep]["condition"] = self.wizard[self.lastStep]["condition"] + ch

-
+       

        def __init__(self, session, showSteps = True, showStepSlider = True, showList = True, showConfig = True):
                Screen.__init__(self, session)
        def __init__(self, session, showSteps = True, showStepSlider = True, showList = True, showConfig = True):
                Screen.__init__(self, session)

-               HelpableScreen.__init__(self)
+               
+               self.isLastWizard = False # can be used to skip a "goodbye"-screen in a wizard

 
                self.stepHistory = []
 
                self.wizard = {}
                parser = make_parser()
 
                self.stepHistory = []
 
                self.wizard = {}
                parser = make_parser()

-               print "Reading " + self.xmlfile
+               if not isinstance(self.xmlfile, list):
+                       self.xmlfile = [self.xmlfile]
+               print "Reading ", self.xmlfile

                wizardHandler = self.parseWizard(self.wizard)
                parser.setContentHandler(wizardHandler)
                wizardHandler = self.parseWizard(self.wizard)
                parser.setContentHandler(wizardHandler)

-               if self.xmlfile[0] != '/':
-                       parser.parse('/usr/share/enigma2/' + self.xmlfile)
-               else:
-                       parser.parse(self.xmlfile)
+               for xmlfile in self.xmlfile:
+                       if xmlfile[0] != '/':
+                               parser.parse('/usr/share/enigma2/' + xmlfile)
+                       else:
+                               parser.parse(xmlfile)

 
                self.showSteps = showSteps
                self.showStepSlider = showStepSlider
 
                self.showSteps = showSteps
                self.showStepSlider = showStepSlider


@@ -160,7 +188,7 @@ class Wizard(Screen, HelpableScreen):
                self.showConfig = showConfig
 
                self.numSteps = len(self.wizard)
                self.showConfig = showConfig
 
                self.numSteps = len(self.wizard)

-               self.currStep = 1
+               self.currStep = self.getStepWithID("start") + 1

                
                self.timeoutTimer = eTimer()
                self.timeoutTimer.callback.append(self.timeoutCounterFired)
                
                self.timeoutTimer = eTimer()
                self.timeoutTimer.callback.append(self.timeoutCounterFired)


@@ -168,7 +196,7 @@ class Wizard(Screen, HelpableScreen):
                self["text"] = Label()
 
                if showConfig:
                self["text"] = Label()
 
                if showConfig:

-                       self["config"] = ConfigList([])
+                       self["config"] = ConfigList([], session = session)

 
                if self.showSteps:
                        self["step"] = Label()
 
                if self.showSteps:
                        self["step"] = Label()


@@ -185,11 +213,15 @@ class Wizard(Screen, HelpableScreen):
                self.onShown.append(self.updateValues)
 
                self.configInstance = None
                self.onShown.append(self.updateValues)
 
                self.configInstance = None

+               self.currentConfigIndex = None

                
                self.lcdCallbacks = []
                
                
                self.lcdCallbacks = []
                

-               self["actions"] = NumberActionMap(["WizardActions", "NumberActions", "ColorActions"],
+               self.disableKeys = False
+               
+               self["actions"] = NumberActionMap(["WizardActions", "NumberActions", "ColorActions", "SetupActions", "InputAsciiActions", "KeyboardInputActions"],

                {
                {

+                       "gotAsciiCode": self.keyGotAscii,

                        "ok": self.ok,
                        "back": self.back,
                        "left": self.left,
                        "ok": self.ok,
                        "back": self.back,
                        "left": self.left,


@@ -200,6 +232,8 @@ class Wizard(Screen, HelpableScreen):
                        "green": self.green,
                        "yellow": self.yellow,
                        "blue":self.blue,
                        "green": self.green,
                        "yellow": self.yellow,
                        "blue":self.blue,

+                       "deleteBackward": self.deleteBackward,
+                       "deleteForward": self.deleteForward,

                        "1": self.keyNumberGlobal,
                        "2": self.keyNumberGlobal,
                        "3": self.keyNumberGlobal,
                        "1": self.keyNumberGlobal,
                        "2": self.keyNumberGlobal,
                        "3": self.keyNumberGlobal,


@@ -211,6 +245,13 @@ class Wizard(Screen, HelpableScreen):
                        "9": self.keyNumberGlobal,
                        "0": self.keyNumberGlobal
                }, -1)
                        "9": self.keyNumberGlobal,
                        "0": self.keyNumberGlobal
                }, -1)

+
+               self["VirtualKB"] = NumberActionMap(["VirtualKeyboardActions"],
+               {
+                       "showVirtualKeyboard": self.KeyText,
+               }, -2)
+               
+               self["VirtualKB"].setEnabled(False)

                
        def red(self):
                print "red"
                
        def red(self):
                print "red"


@@ -228,15 +269,35 @@ class Wizard(Screen, HelpableScreen):
                print "blue"
                pass
        
                print "blue"
                pass
        

+       def deleteForward(self):
+               self.resetCounter()
+               if (self.wizard[self.currStep]["config"]["screen"] != None):
+                       self.configInstance.keyDelete()
+               elif (self.wizard[self.currStep]["config"]["type"] == "dynamic"):
+                       self["config"].handleKey(KEY_DELETE)
+               print "deleteForward"
+
+       def deleteBackward(self):
+               self.resetCounter()
+               if (self.wizard[self.currStep]["config"]["screen"] != None):
+                       self.configInstance.keyBackspace()
+               elif (self.wizard[self.currStep]["config"]["type"] == "dynamic"):
+                       self["config"].handleKey(KEY_BACKSPACE)
+               print "deleteBackward"
+       

        def setLCDTextCallback(self, callback):
                self.lcdCallbacks.append(callback)
 
        def back(self):
        def setLCDTextCallback(self, callback):
                self.lcdCallbacks.append(callback)
 
        def back(self):

+               if self.disableKeys:
+                       return

                print "getting back..."
                print "stepHistory:", self.stepHistory
                if len(self.stepHistory) > 1:
                        self.currStep = self.stepHistory[-2]
                        self.stepHistory = self.stepHistory[:-2]
                print "getting back..."
                print "stepHistory:", self.stepHistory
                if len(self.stepHistory) > 1:
                        self.currStep = self.stepHistory[-2]
                        self.stepHistory = self.stepHistory[:-2]

+               else:
+                       self.session.openWithCallback(self.exitWizardQuestion, MessageBox, (_("Are you sure you want to exit this wizard?") ) )

                if self.currStep < 1:
                        self.currStep = 1
                print "currStep:", self.currStep
                if self.currStep < 1:
                        self.currStep = 1
                print "currStep:", self.currStep


@@ -244,13 +305,18 @@ class Wizard(Screen, HelpableScreen):
                self.updateValues()
                print "after updateValues stepHistory:", self.stepHistory
                
                self.updateValues()
                print "after updateValues stepHistory:", self.stepHistory
                

+       def exitWizardQuestion(self, ret = False):
+               if (ret):
+                       self.markDone()
+                       self.close()
+               

        def markDone(self):
                pass
        
        def getStepWithID(self, id):
                print "getStepWithID:", id
                count = 0
        def markDone(self):
                pass
        
        def getStepWithID(self, id):
                print "getStepWithID:", id
                count = 0

-               for x in self.wizard:
+               for x in self.wizard.keys():

                        if self.wizard[x]["id"] == id:
                                print "result:", count
                                return count
                        if self.wizard[x]["id"] == id:
                                print "result:", count
                                return count


@@ -264,6 +330,10 @@ class Wizard(Screen, HelpableScreen):
 
                if self.updateValues not in self.onShown:
                        self.onShown.append(self.updateValues)
 
                if self.updateValues not in self.onShown:
                        self.onShown.append(self.updateValues)

+                       
+               if self.showConfig:
+                       if self.wizard[currStep]["config"]["type"] == "dynamic":
+                               eval("self." + self.wizard[currStep]["config"]["evaluation"])()

 
                if self.showList:
                        if (len(self.wizard[currStep]["evaluatedlist"]) > 0):
 
                if self.showList:
                        if (len(self.wizard[currStep]["evaluatedlist"]) > 0):


@@ -274,23 +344,29 @@ class Wizard(Screen, HelpableScreen):
                                else:
                                        self.currStep = self.getStepWithID(nextStep)
 
                                else:
                                        self.currStep = self.getStepWithID(nextStep)
 

-               if (currStep == self.numSteps): # wizard finished
+               print_now = True
+               if ((currStep == self.numSteps and self.wizard[currStep]["nextstep"] is None) or self.wizard[currStep]["id"] == "end"): # wizard finished
+                       print "wizard finished"

                        self.markDone()
                        self.close()
                else:
                        self.markDone()
                        self.close()
                else:

+                       self.codeafter = True

                        self.runCode(self.wizard[currStep]["codeafter"])
                        self.runCode(self.wizard[currStep]["codeafter"])

-                       if self.wizard[currStep]["nextstep"] is not None:
-                               self.currStep = self.getStepWithID(self.wizard[currStep]["nextstep"])
-                       if gotoStep is not None:
-                               self.currStep = self.getStepWithID(gotoStep)
-                       self.currStep += 1
-                       self.updateValues()
-
-               print "Now: " + str(self.currStep)
+                       self.prevStep = currStep
+                       self.gotoStep = gotoStep
+                       if not self.runCode(self.wizard[currStep]["codeafter_async"]):
+                               self.afterAsyncCode()
+                       else:
+                               if self.updateValues in self.onShown:
+                                       self.onShown.remove(self.updateValues)

 
 

+               if print_now:
+                       print "Now: " + str(self.currStep)

 
        def ok(self):
                print "OK"
 
        def ok(self):
                print "OK"

+               if self.disableKeys:
+                       return

                currStep = self.currStep
                
                if self.showConfig:
                currStep = self.currStep
                
                if self.showConfig:


@@ -300,7 +376,8 @@ class Wizard(Screen, HelpableScreen):
                                # for this. If there is one, please do a more specific check
                                # and/or a comment in which situation there is no run()
                                if callable(getattr(self.configInstance, "runAsync", None)):
                                # for this. If there is one, please do a more specific check
                                # and/or a comment in which situation there is no run()
                                if callable(getattr(self.configInstance, "runAsync", None)):

-                                       self.onShown.remove(self.updateValues)
+                                       if self.updateValues in self.onShown:
+                                               self.onShown.remove(self.updateValues)

                                        self.configInstance.runAsync(self.finished)
                                        return
                                else:
                                        self.configInstance.runAsync(self.finished)
                                        return
                                else:


@@ -310,23 +387,36 @@ class Wizard(Screen, HelpableScreen):
        def keyNumberGlobal(self, number):
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyNumberGlobal(number)
        def keyNumberGlobal(self, number):
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyNumberGlobal(number)

+               elif (self.wizard[self.currStep]["config"]["type"] == "dynamic"):
+                       self["config"].handleKey(KEY_0 + number)
+
+       def keyGotAscii(self):
+               if (self.wizard[self.currStep]["config"]["screen"] != None):
+                       self["config"].handleKey(KEY_ASCII)
+               elif (self.wizard[self.currStep]["config"]["type"] == "dynamic"):
+                       self["config"].handleKey(KEY_ASCII)

                
        def left(self):
                self.resetCounter()
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyLeft()
                
        def left(self):
                self.resetCounter()
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyLeft()

+               elif (self.wizard[self.currStep]["config"]["type"] == "dynamic"):
+                       self["config"].handleKey(KEY_LEFT)

                print "left"
        
        def right(self):
                self.resetCounter()
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyRight()
                print "left"
        
        def right(self):
                self.resetCounter()
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyRight()

+               elif (self.wizard[self.currStep]["config"]["type"] == "dynamic"):
+                       self["config"].handleKey(KEY_RIGHT)     

                print "right"
 
        def up(self):
                self.resetCounter()
                print "right"
 
        def up(self):
                self.resetCounter()

-               if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None):
-                               self["config"].instance.moveSelection(self["config"].instance.moveUp)
+               if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None  or self.wizard[self.currStep]["config"]["type"] == "dynamic"):
+                       self["config"].instance.moveSelection(self["config"].instance.moveUp)
+                       self.handleInputHelpers()

                elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
                        self["list"].selectPrevious()
                        if self.wizard[self.currStep].has_key("onselect"):
                elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
                        self["list"].selectPrevious()
                        if self.wizard[self.currStep].has_key("onselect"):


@@ -338,8 +428,9 @@ class Wizard(Screen, HelpableScreen):
                
        def down(self):
                self.resetCounter()
                
        def down(self):
                self.resetCounter()

-               if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None):
+               if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None  or self.wizard[self.currStep]["config"]["type"] == "dynamic"):

                        self["config"].instance.moveSelection(self["config"].instance.moveDown)
                        self["config"].instance.moveSelection(self["config"].instance.moveDown)

+                       self.handleInputHelpers()

                elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
                        #self["list"].instance.moveSelection(self["list"].instance.moveDown)
                        self["list"].selectNext()
                elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
                        #self["list"].instance.moveSelection(self["list"].instance.moveDown)
                        self["list"].selectNext()


@@ -356,7 +447,7 @@ class Wizard(Screen, HelpableScreen):
                self.resetCounter()
                
                if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None):
                self.resetCounter()
                
                if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None):

-                               self["config"].instance.moveSelection(self["config"].instance.moveUp)
+                       self["config"].instance.moveSelection(self["config"].instance.moveUp)

                elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
                        if self.wizard[self.currStep].has_key("onselect"):
                                self.selection = self["list"].current[-1]
                elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
                        if self.wizard[self.currStep].has_key("onselect"):
                                self.selection = self["list"].current[-1]


@@ -370,9 +461,14 @@ class Wizard(Screen, HelpableScreen):
                if code != "":
                        print "code", code
                        exec(code)
                if code != "":
                        print "code", code
                        exec(code)

+                       return True
+               return False
+
+       def getTranslation(self, text):
+               return _(text)

                        
        def updateText(self, firstset = False):
                        
        def updateText(self, firstset = False):

-               text = _(self.wizard[self.currStep]["text"])
+               text = self.getTranslation(self.wizard[self.currStep]["text"])

                if text.find("[timeout]") != -1:
                        text = text.replace("[timeout]", str(self.timeoutCounter))
                        self["text"].setText(text)
                if text.find("[timeout]") != -1:
                        text = text.replace("[timeout]", str(self.timeoutCounter))
                        self["text"].setText(text)


@@ -384,7 +480,7 @@ class Wizard(Screen, HelpableScreen):
                print "Updating values in step " + str(self.currStep)
                # calling a step which doesn't exist can only happen if the condition in the last step is not fulfilled
                # if a non-existing step is called, end the wizard 
                print "Updating values in step " + str(self.currStep)
                # calling a step which doesn't exist can only happen if the condition in the last step is not fulfilled
                # if a non-existing step is called, end the wizard 

-               if self.currStep >= len(self.wizard):
+               if self.currStep > len(self.wizard):

                        self.markDone()
                        self.close()
                        return
                        self.markDone()
                        self.close()
                        return


@@ -392,19 +488,35 @@ class Wizard(Screen, HelpableScreen):
                self.timeoutTimer.stop()
                
                if self.configInstance is not None:
                self.timeoutTimer.stop()
                
                if self.configInstance is not None:

+                       # remove callbacks
+                       self.configInstance["config"].onSelectionChanged = []

                        del self.configInstance["config"]
                        self.configInstance.doClose()
                        self.configInstance = None
                        del self.configInstance["config"]
                        self.configInstance.doClose()
                        self.configInstance = None

-               
+

                self.condition = True
                exec (self.wizard[self.currStep]["condition"])
                self.condition = True
                exec (self.wizard[self.currStep]["condition"])

-               if self.condition:
+               if not self.condition:
+                       print "keys*******************:", self.wizard[self.currStep].keys()
+                       if self.wizard[self.currStep].has_key("laststep"): # exit wizard, if condition of laststep doesn't hold
+                               self.markDone()
+                               self.close()
+                               return
+                       else:
+                               self.currStep += 1
+                               self.updateValues()
+               else:
+                       if self.wizard[self.currStep].has_key("displaytext"):
+                               displaytext = self.wizard[self.currStep]["displaytext"]
+                               print "set LCD text"
+                               for x in self.lcdCallbacks:
+                                       x(displaytext)

                        if len(self.stepHistory) == 0 or self.stepHistory[-1] != self.currStep:
                                self.stepHistory.append(self.currStep)
                        print "wizard step:", self.wizard[self.currStep]
                        
                        if self.showSteps:
                        if len(self.stepHistory) == 0 or self.stepHistory[-1] != self.currStep:
                                self.stepHistory.append(self.currStep)
                        print "wizard step:", self.wizard[self.currStep]
                        
                        if self.showSteps:

-                               self["step"].setText(_("Step ") + str(self.currStep) + "/" + str(self.numSteps))
+                               self["step"].setText(self.getTranslation("Step ") + str(self.currStep) + "/" + str(self.numSteps))

                        if self.showStepSlider:
                                self["stepslider"].setValue(self.currStep)
                
                        if self.showStepSlider:
                                self["stepslider"].setValue(self.currStep)
                


@@ -412,7 +524,7 @@ class Wizard(Screen, HelpableScreen):
                                self.resetCounter() 
                                self.timeoutTimer.start(1000)
                        
                                self.resetCounter() 
                                self.timeoutTimer.start(1000)
                        

-                       print "wizard text", _(self.wizard[self.currStep]["text"])
+                       print "wizard text", self.getTranslation(self.wizard[self.currStep]["text"])

                        self.updateText(firstset = True)
                        if self.wizard[self.currStep].has_key("displaytext"):
                                displaytext = self.wizard[self.currStep]["displaytext"]
                        self.updateText(firstset = True)
                        if self.wizard[self.currStep].has_key("displaytext"):
                                displaytext = self.wizard[self.currStep]["displaytext"]


@@ -420,8 +532,27 @@ class Wizard(Screen, HelpableScreen):
                                for x in self.lcdCallbacks:
                                        x(displaytext)
                                
                                for x in self.lcdCallbacks:
                                        x(displaytext)
                                

+                       self.codeafter=False

                        self.runCode(self.wizard[self.currStep]["code"])
                        self.runCode(self.wizard[self.currStep]["code"])

-                       
+                       if self.runCode(self.wizard[self.currStep]["code_async"]):
+                               if self.updateValues in self.onShown:
+                                       self.onShown.remove(self.updateValues)
+                       else:
+                               self.afterAsyncCode()
+
+       def afterAsyncCode(self):
+               if not self.updateValues in self.onShown:
+                       self.onShown.append(self.updateValues)
+
+               if self.codeafter:
+                       if self.wizard[self.prevStep]["nextstep"] is not None:
+                               self.currStep = self.getStepWithID(self.wizard[self.prevStep]["nextstep"])
+                       if self.gotoStep is not None:
+                               self.currStep = self.getStepWithID(self.gotoStep)
+                       self.currStep += 1
+                       self.updateValues()
+                       print "Now: " + str(self.currStep)
+               else:

                        if self.showList:
                                print "showing list,", self.currStep
                                for renderer in self.renderer:
                        if self.showList:
                                print "showing list,", self.currStep
                                for renderer in self.renderer:


@@ -432,7 +563,7 @@ class Wizard(Screen, HelpableScreen):
                                                        print "setZPosition"
                                                        rootrenderer.instance.setZPosition(1)
                                                renderer = renderer.source
                                                        print "setZPosition"
                                                        rootrenderer.instance.setZPosition(1)
                                                renderer = renderer.source

-                                               
+

                                #self["list"].instance.setZPosition(1)
                                self.list = []
                                if (self.wizard[self.currStep].has_key("dynamiclist")):
                                #self["list"].instance.setZPosition(1)
                                self.list = []
                                if (self.wizard[self.currStep].has_key("dynamiclist")):


@@ -446,7 +577,7 @@ class Wizard(Screen, HelpableScreen):
                                if (len(self.wizard[self.currStep]["list"]) > 0):
                                        #self["list"].instance.setZPosition(2)
                                        for x in self.wizard[self.currStep]["list"]:
                                if (len(self.wizard[self.currStep]["list"]) > 0):
                                        #self["list"].instance.setZPosition(2)
                                        for x in self.wizard[self.currStep]["list"]:

-                                               self.list.append((_(x[0]), x[1]))
+                                               self.list.append((self.getTranslation(x[0]), x[1]))

                                self.wizard[self.currStep]["evaluatedlist"] = self.list
                                self["list"].list = self.list
                                self["list"].index = 0
                                self.wizard[self.currStep]["evaluatedlist"] = self.list
                                self["list"].list = self.list
                                self["list"].index = 0


@@ -454,8 +585,13 @@ class Wizard(Screen, HelpableScreen):
                                self["list"].hide()
        
                        if self.showConfig:
                                self["list"].hide()
        
                        if self.showConfig:

+                               print "showing config"

                                self["config"].instance.setZPosition(1)
                                self["config"].instance.setZPosition(1)

-                               if (self.wizard[self.currStep]["config"]["screen"] != None):
+                               if self.wizard[self.currStep]["config"]["type"] == "dynamic":
+                                               print "config type is dynamic"
+                                               self["config"].instance.setZPosition(2)
+                                               self["config"].l.setList(eval("self." + self.wizard[self.currStep]["config"]["source"])())
+                               elif (self.wizard[self.currStep]["config"]["screen"] != None):

                                        if self.wizard[self.currStep]["config"]["type"] == "standalone":
                                                print "Type is standalone"
                                                self.session.openWithCallback(self.ok, self.wizard[self.currStep]["config"]["screen"])
                                        if self.wizard[self.currStep]["config"]["type"] == "standalone":
                                                print "Type is standalone"
                                                self.session.openWithCallback(self.ok, self.wizard[self.currStep]["config"]["screen"])


@@ -467,17 +603,21 @@ class Wizard(Screen, HelpableScreen):
                                                else:
                                                        self.configInstance = self.session.instantiateDialog(self.wizard[self.currStep]["config"]["screen"], eval(self.wizard[self.currStep]["config"]["args"]))
                                                self["config"].l.setList(self.configInstance["config"].list)
                                                else:
                                                        self.configInstance = self.session.instantiateDialog(self.wizard[self.currStep]["config"]["screen"], eval(self.wizard[self.currStep]["config"]["args"]))
                                                self["config"].l.setList(self.configInstance["config"].list)

+                                               callbacks = self.configInstance["config"].onSelectionChanged

                                                self.configInstance["config"].destroy()
                                                self.configInstance["config"].destroy()

+                                               print "clearConfigList", self.configInstance["config"], self["config"]

                                                self.configInstance["config"] = self["config"]
                                                self.configInstance["config"] = self["config"]

+                                               self.configInstance["config"].onSelectionChanged = callbacks
+                                               print "clearConfigList", self.configInstance["config"], self["config"]

                                else:
                                        self["config"].l.setList([])
                                else:
                                        self["config"].l.setList([])

+                                       self.handleInputHelpers()
+                                       
+                                       

                        else:
                                if self.has_key("config"):
                                        self["config"].hide()
                        else:
                                if self.has_key("config"):
                                        self["config"].hide()

-               else: # condition false
-                               self.currStep += 1
-                               self.updateValues()
-                               
+

        def timeoutCounterFired(self):
                self.timeoutCounter -= 1
                print "timeoutCounter:", self.timeoutCounter
        def timeoutCounterFired(self):
                self.timeoutCounter -= 1
                print "timeoutCounter:", self.timeoutCounter


@@ -490,6 +630,45 @@ class Wizard(Screen, HelpableScreen):
                                        self.finished(gotoStep = self.wizard[self.currStep]["timeoutstep"])
                self.updateText()
 
                                        self.finished(gotoStep = self.wizard[self.currStep]["timeoutstep"])
                self.updateText()
 

+       def handleInputHelpers(self):
+               if self["config"].getCurrent() is not None:
+                       if isinstance(self["config"].getCurrent()[1], ConfigText) or isinstance(self["config"].getCurrent()[1], ConfigPassword):
+                               if self.has_key("VKeyIcon"):
+                                       self["VirtualKB"].setEnabled(True)
+                                       self["VKeyIcon"].boolean = True
+                               if self.has_key("HelpWindow"):
+                                       if self["config"].getCurrent()[1].help_window.instance is not None:
+                                               helpwindowpos = self["HelpWindow"].getPosition()
+                                               from enigma import ePoint
+                                               self["config"].getCurrent()[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+                       else:
+                               if self.has_key("VKeyIcon"):
+                                       self["VirtualKB"].setEnabled(False)
+                                       self["VKeyIcon"].boolean = False
+               else:
+                       if self.has_key("VKeyIcon"):
+                               self["VirtualKB"].setEnabled(False)
+                               self["VKeyIcon"].boolean = False
+
+       def KeyText(self):
+               from Screens.VirtualKeyBoard import VirtualKeyBoard
+               self.currentConfigIndex = self["config"].getCurrentIndex()
+               self.session.openWithCallback(self.VirtualKeyBoardCallback, VirtualKeyBoard, title = self["config"].getCurrent()[0], text = self["config"].getCurrent()[1].getValue())
+
+       def VirtualKeyBoardCallback(self, callback = None):
+               if callback is not None and len(callback):
+                       if isinstance(self["config"].getCurrent()[1], ConfigText) or isinstance(self["config"].getCurrent()[1], ConfigPassword):
+                               if self.has_key("HelpWindow"):
+                                       if self["config"].getCurrent()[1].help_window.instance is not None:
+                                               helpwindowpos = self["HelpWindow"].getPosition()
+                                               from enigma import ePoint
+                                               self["config"].getCurrent()[1].help_window.instance.move(ePoint(helpwindowpos[0],helpwindowpos[1]))
+                       self["config"].instance.moveSelectionTo(self.currentConfigIndex)
+                       self["config"].setCurrentIndex(self.currentConfigIndex)
+                       self["config"].getCurrent()[1].setValue(callback)
+                       self["config"].invalidate(self["config"].getCurrent())
+
+

 class WizardManager:
        def __init__(self):
                self.wizards = []
 class WizardManager:
        def __init__(self):
                self.wizards = []


@@ -498,10 +677,11 @@ class WizardManager:
                self.wizards.append((wizard, precondition, priority))
        
        def getWizards(self):
                self.wizards.append((wizard, precondition, priority))
        
        def getWizards(self):

-               list = []
-               for x in self.wizards:
-                       if x[1] == 1: # precondition
-                               list.append((x[2], x[0]))
-               return list
+               # x[1] is precondition
+               for wizard in self.wizards:
+                       wizard[0].isLastWizard = False
+               if len(self.wizards) > 0:
+                       self.wizards[-1][0].isLastWizard = True
+               return [(x[2], x[0]) for x in self.wizards if x[1] == 1]

 
 wizardManager = WizardManager()
 
 wizardManager = WizardManager()