remove onSelectionChanged callbacks before deleting the configInstance["config"]...
[enigma2.git] / lib / python / Screens / Wizard.py
index 1900e9a..9f87ee3 100644 (file)
@@ -3,27 +3,62 @@ from Screen import Screen
 import string
 
 from Screens.HelpMenu import HelpableScreen
 import string
 
 from Screens.HelpMenu import HelpableScreen
-from Components.config import config
+from Components.config import config, KEY_LEFT, KEY_RIGHT, KEY_DELETE, KEY_BACKSPACE
 from Components.Label import Label
 from Components.Slider import Slider
 from Components.ActionMap import NumberActionMap
 from Components.MenuList import MenuList
 from Components.ConfigList import ConfigList
 from Components.Label import Label
 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 xml.sax.handler import ContentHandler
 
 
 from xml.sax import make_parser
 from xml.sax.handler import ContentHandler
 
-class Wizard(Screen, HelpableScreen):
+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">
+                       <convert type="StringListSelection" />
+               </widget>
+       </screen>"""
+       
+       def __init__(self, session, parent):
+               Screen.__init__(self, session, parent)
+               
+               #names = parent.skinName
+               #if not isinstance(names, list):
+                       #names = [names]
+#                      
+               #self.skinName = [x + "_summary" for x in names ]
+               #self.skinName.append("Wizard")
+               #print "*************+++++++++++++++++****************++++++++++******************* WizardSummary", self.skinName
+                       #
+               self["text"] = Label("")
+               self.onShow.append(self.setCallback)
+               
+       def setCallback(self):
+               self.parent.setLCDTextCallback(self.setText)
+               
+       def setText(self, text):
+               self["text"].setText(text)
+
+class Wizard(Screen):
+       def createSummary(self):
+                       print "WizardCreateSummary"
+                       return WizardSummary
 
        class parseWizard(ContentHandler):
                def __init__(self, wizard):
                        self.isPointsElement, self.isReboundsElement = 0, 0
                        self.wizard = wizard
                        self.currContent = ""
 
        class parseWizard(ContentHandler):
                def __init__(self, wizard):
                        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
@@ -31,22 +66,58 @@ class Wizard(Screen, HelpableScreen):
                                        id = str(attrs.get('id'))
                                else:
                                        id = ""
                                        id = str(attrs.get('id'))
                                else:
                                        id = ""
+                               #print "id:", id
                                if attrs.has_key('nextstep'):
                                        nextstep = str(attrs.get('nextstep'))
                                else:
                                        nextstep = None
                                if attrs.has_key('nextstep'):
                                        nextstep = str(attrs.get('nextstep'))
                                else:
                                        nextstep = None
-                               self.wizard[self.lastStep] = {"id": id, "condition": "", "text": "", "list": [], "config": {"screen": None, "args": None, "type": "" }, "code": "", "codeafter": "", "nextstep": nextstep}
+                               if attrs.has_key('timeout'):
+                                       timeout = int(attrs.get('timeout'))
+                               else:
+                                       timeout = None
+                               if attrs.has_key('timeoutaction'):
+                                       timeoutaction = str(attrs.get('timeoutaction'))
+                               else:
+                                       timeoutaction = 'nextpage'
+
+                               if attrs.has_key('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}
                        elif (name == "text"):
                                self.wizard[self.lastStep]["text"] = string.replace(str(attrs.get('value')), "\\n", "\n")
                        elif (name == "text"):
                                self.wizard[self.lastStep]["text"] = string.replace(str(attrs.get('value')), "\\n", "\n")
+                       elif (name == "displaytext"):
+                               self.wizard[self.lastStep]["displaytext"] = string.replace(str(attrs.get('value')), "\\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")):
+                                       #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"):
                        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"):
                                if attrs.has_key('pos') and str(attrs.get('pos')) == "after":
                                        self.codeafter = True
                        elif (name == "code"):
                                if attrs.has_key('pos') and str(attrs.get('pos')) == "after":
                                        self.codeafter = True
@@ -54,6 +125,7 @@ class Wizard(Screen, HelpableScreen):
                                        self.codeafter = False
                        elif (name == "condition"):
                                pass
                                        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':
@@ -63,6 +135,9 @@ class Wizard(Screen, HelpableScreen):
                                        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()
                                        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':
+                               #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":
@@ -75,16 +150,21 @@ class Wizard(Screen, HelpableScreen):
 
        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.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)
-               parser.parse('/usr/share/enigma2/' + 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
@@ -92,12 +172,15 @@ 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["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()
@@ -107,13 +190,19 @@ class Wizard(Screen, HelpableScreen):
                
                if self.showList:
                        self.list = []
                
                if self.showList:
                        self.list = []
-                       self["list"] = MenuList(self.list)
+                       self["list"] = List(self.list, enableWrapAround = True)
+                       self["list"].onSelectionChanged.append(self.selChanged)
+                       #self["list"] = MenuList(self.list, enableWrapAround = True)
 
                self.onShown.append(self.updateValues)
 
                self.configInstance = None
                
 
                self.onShown.append(self.updateValues)
 
                self.configInstance = None
                
-               self["actions"] = NumberActionMap(["WizardActions", "NumberActions"],
+               self.lcdCallbacks = []
+               
+               self.disableKeys = False
+               
+               self["actions"] = NumberActionMap(["WizardActions", "NumberActions", "ColorActions", "SetupActions"],
                {
                        "ok": self.ok,
                        "back": self.back,
                {
                        "ok": self.ok,
                        "back": self.back,
@@ -121,6 +210,12 @@ class Wizard(Screen, HelpableScreen):
                        "right": self.right,
                        "up": self.up,
                        "down": self.down,
                        "right": self.right,
                        "up": self.up,
                        "down": self.down,
+                       "red": self.red,
+                       "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,
@@ -132,45 +227,101 @@ class Wizard(Screen, HelpableScreen):
                        "9": self.keyNumberGlobal,
                        "0": self.keyNumberGlobal
                }, -1)
                        "9": self.keyNumberGlobal,
                        "0": self.keyNumberGlobal
                }, -1)
+               
+       def red(self):
+               print "red"
+               pass
+
+       def green(self):
+               print "green"
+               pass
+       
+       def yellow(self):
+               print "yellow"
+               pass
+       
+       def blue(self):
+               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 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]
                if self.currStep < 1:
                        self.currStep = 1
                if len(self.stepHistory) > 1:
                        self.currStep = self.stepHistory[-2]
                        self.stepHistory = self.stepHistory[:-2]
                if self.currStep < 1:
                        self.currStep = 1
+               print "currStep:", self.currStep
+               print "new stepHistory:", self.stepHistory
                self.updateValues()
                self.updateValues()
+               print "after updateValues stepHistory:", self.stepHistory
                
        def markDone(self):
                pass
        
        def getStepWithID(self, id):
                
        def markDone(self):
                pass
        
        def getStepWithID(self, id):
+               print "getStepWithID:", id
                count = 0
                count = 0
-               for x in self.wizard:
+               for x in self.wizard.keys():
                        if self.wizard[x]["id"] == id:
                        if self.wizard[x]["id"] == id:
+                               print "result:", count
                                return count
                        count += 1
                                return count
                        count += 1
+               print "result: nothing"
                return 0
 
                return 0
 
-       def finished(self, *args, **kwargs):
+       def finished(self, gotoStep = None, *args, **kwargs):
                print "finished"
                currStep = self.currStep
 
                if self.updateValues not in self.onShown:
                        self.onShown.append(self.updateValues)
                print "finished"
                currStep = self.currStep
 
                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 self.showList:
-                       if (len(self.wizard[currStep]["list"]) > 0):
-                               nextStep = self.wizard[currStep]["list"][self["list"].l.getCurrentSelectionIndex()][1]
-                               self.currStep = self.getStepWithID(nextStep)
+                       if (len(self.wizard[currStep]["evaluatedlist"]) > 0):
+                               print "current:", self["list"].current
+                               nextStep = self["list"].current[1]
+                               if (self.wizard[currStep].has_key("listevaluation")):
+                                       exec("self." + self.wizard[self.currStep]["listevaluation"] + "('" + nextStep + "')")
+                               else:
+                                       self.currStep = self.getStepWithID(nextStep)
 
 
-               if (currStep == self.numSteps): # wizard finished
+               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.runCode(self.wizard[currStep]["codeafter"])
                        if self.wizard[currStep]["nextstep"] is not None:
                                self.currStep = self.getStepWithID(self.wizard[currStep]["nextstep"])
                        self.markDone()
                        self.close()
                else:
                        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()
 
                        self.currStep += 1
                        self.updateValues()
 
@@ -179,6 +330,8 @@ class Wizard(Screen, HelpableScreen):
 
        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:
@@ -200,40 +353,95 @@ class Wizard(Screen, HelpableScreen):
                        self.configInstance.keyNumberGlobal(number)
                
        def left(self):
                        self.configInstance.keyNumberGlobal(number)
                
        def left(self):
+               self.resetCounter()
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyLeft()
                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):
                print "left"
        
        def right(self):
+               self.resetCounter()
                if (self.wizard[self.currStep]["config"]["screen"] != None):
                        self.configInstance.keyRight()
                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):
                print "right"
 
        def up(self):
-               if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None):
+               self.resetCounter()
+               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["config"].instance.moveSelection(self["config"].instance.moveUp)
-               elif (self.showList and len(self.wizard[self.currStep]["list"]) > 0):
-                       self["list"].instance.moveSelection(self["list"].instance.moveUp)
+               elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
+                       self["list"].selectPrevious()
+                       if self.wizard[self.currStep].has_key("onselect"):
+                               print "current:", self["list"].current
+                               self.selection = self["list"].current[-1]
+                               #self.selection = self.wizard[self.currStep]["evaluatedlist"][self["list"].l.getCurrentSelectionIndex()][1]
+                               exec("self." + self.wizard[self.currStep]["onselect"] + "()")
                print "up"
                
        def down(self):
                print "up"
                
        def down(self):
-               if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None):
+               self.resetCounter()
+               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)
-               elif (self.showList and len(self.wizard[self.currStep]["list"]) > 0):
-                       self["list"].instance.moveSelection(self["list"].instance.moveDown)
+               elif (self.showList and len(self.wizard[self.currStep]["evaluatedlist"]) > 0):
+                       #self["list"].instance.moveSelection(self["list"].instance.moveDown)
+                       self["list"].selectNext()
+                       if self.wizard[self.currStep].has_key("onselect"):
+                               print "current:", self["list"].current
+                               #self.selection = self.wizard[self.currStep]["evaluatedlist"][self["list"].l.getCurrentSelectionIndex()][1]
+                               #exec("self." + self.wizard[self.currStep]["onselect"] + "()")
+                               self.selection = self["list"].current[-1]
+                               #self.selection = self.wizard[self.currStep]["evaluatedlist"][self["list"].l.getCurrentSelectionIndex()][1]
+                               exec("self." + self.wizard[self.currStep]["onselect"] + "()")
                print "down"
                
                print "down"
                
+       def selChanged(self):
+               self.resetCounter()
+               
+               if (self.showConfig and self.wizard[self.currStep]["config"]["screen"] != None):
+                       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]
+                               print "self.selection:", self.selection
+                               exec("self." + self.wizard[self.currStep]["onselect"] + "()")
+               
+       def resetCounter(self):
+               self.timeoutCounter = self.wizard[self.currStep]["timeout"]
+               
        def runCode(self, code):
                if code != "":
                        print "code", code
                        exec(code)
        def runCode(self, code):
                if code != "":
                        print "code", code
                        exec(code)
+                       
+       def getTranslation(self, text):
+               return _(text)
+                       
+       def updateText(self, firstset = False):
+               text = self.getTranslation(self.wizard[self.currStep]["text"])
+               if text.find("[timeout]") != -1:
+                       text = text.replace("[timeout]", str(self.timeoutCounter))
+                       self["text"].setText(text)
+               else:
+                       if firstset:
+                               self["text"].setText(text)
                
        def updateValues(self):
                print "Updating values in step " + str(self.currStep)
                
        def updateValues(self):
                print "Updating values in step " + str(self.currStep)
-               
-               self.stepHistory.append(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):
+                       self.markDone()
+                       self.close()
+                       return
+
+               self.timeoutTimer.stop()
                
                if self.configInstance is not None:
                
                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
@@ -241,29 +449,68 @@ class Wizard(Screen, HelpableScreen):
                self.condition = True
                exec (self.wizard[self.currStep]["condition"])
                if self.condition:
                self.condition = True
                exec (self.wizard[self.currStep]["condition"])
                if self.condition:
+                       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 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)
                
-                       print "wizard text", _(self.wizard[self.currStep]["text"])
-                       self["text"].setText(_(self.wizard[self.currStep]["text"]))
-       
+                       if self.wizard[self.currStep]["timeout"] is not None:
+                               self.resetCounter() 
+                               self.timeoutTimer.start(1000)
+                       
+                       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"]
+                               print "set LCD text"
+                               for x in self.lcdCallbacks:
+                                       x(displaytext)
+                               
                        self.runCode(self.wizard[self.currStep]["code"])
                        
                        if self.showList:
                        self.runCode(self.wizard[self.currStep]["code"])
                        
                        if self.showList:
-                               self["list"].instance.setZPosition(1)
+                               print "showing list,", self.currStep
+                               for renderer in self.renderer:
+                                       rootrenderer = renderer
+                                       while renderer.source is not None:
+                                               print "self.list:", self["list"]
+                                               if renderer.source is self["list"]:
+                                                       print "setZPosition"
+                                                       rootrenderer.instance.setZPosition(1)
+                                               renderer = renderer.source
+                                               
+                               #self["list"].instance.setZPosition(1)
                                self.list = []
                                self.list = []
+                               if (self.wizard[self.currStep].has_key("dynamiclist")):
+                                       print "dynamic list, calling",  self.wizard[self.currStep]["dynamiclist"]
+                                       newlist = eval("self." + self.wizard[self.currStep]["dynamiclist"] + "()")
+                                       #self.wizard[self.currStep]["evaluatedlist"] = []
+                                       for entry in newlist:
+                                               #self.wizard[self.currStep]["evaluatedlist"].append(entry)
+                                               self.list.append(entry)
+                                       #del self.wizard[self.currStep]["dynamiclist"]
                                if (len(self.wizard[self.currStep]["list"]) > 0):
                                if (len(self.wizard[self.currStep]["list"]) > 0):
-                                       self["list"].instance.setZPosition(2)
+                                       #self["list"].instance.setZPosition(2)
                                        for x in self.wizard[self.currStep]["list"]:
                                        for x in self.wizard[self.currStep]["list"]:
-                                               self.list.append((_(x[0]), None))
-                               self["list"].l.setList(self.list)
-                               self["list"].moveToIndex(0)
+                                               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
+                       else:
+                               self["list"].hide()
        
                        if self.showConfig:
        
                        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"])
@@ -276,25 +523,42 @@ class Wizard(Screen, HelpableScreen):
                                                        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)
                                                self.configInstance["config"].destroy()
                                                        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)
                                                self.configInstance["config"].destroy()
+                                               print "clearConfigList", self.configInstance["config"], self["config"] 
                                                self.configInstance["config"] = self["config"]
                                                self.configInstance["config"] = self["config"]
+                                               print "clearConfigList", self.configInstance["config"], self["config"]
                                else:
                                        self["config"].l.setList([])
                                else:
                                        self["config"].l.setList([])
+                       else:
+                               if self.has_key("config"):
+                                       self["config"].hide()
                else: # condition false
                                self.currStep += 1
                                self.updateValues()
                else: # condition false
                                self.currStep += 1
                                self.updateValues()
+                               
+       def timeoutCounterFired(self):
+               self.timeoutCounter -= 1
+               print "timeoutCounter:", self.timeoutCounter
+               if self.timeoutCounter == 0:
+                       if self.wizard[self.currStep]["timeoutaction"] == "selectnext":
+                               print "selection next item"
+                               self.down()
+                       else:
+                               if self.wizard[self.currStep]["timeoutaction"] == "changestep":
+                                       self.finished(gotoStep = self.wizard[self.currStep]["timeoutstep"])
+               self.updateText()
 
 class WizardManager:
        def __init__(self):
                self.wizards = []
        
 
 class WizardManager:
        def __init__(self):
                self.wizards = []
        
-       def registerWizard(self, wizard, precondition):
-               self.wizards.append((wizard, precondition))
+       def registerWizard(self, wizard, precondition, priority = 0):
+               self.wizards.append((wizard, precondition, priority))
        
        def getWizards(self):
                list = []
                for x in self.wizards:
                        if x[1] == 1: # precondition
        
        def getWizards(self):
                list = []
                for x in self.wizards:
                        if x[1] == 1: # precondition
-                               list.append(x[0])
+                               list.append((x[2], x[0]))
                return list
 
 wizardManager = WizardManager()
                return list
 
 wizardManager = WizardManager()