fix non working timer disable for recurring timers,

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

diff --git a/lib/python/Screens/TimerEdit.py b/lib/python/Screens/TimerEdit.py
index babf28fe6cc0e8ba042196432a8f117d2785647e..67c49cc5b03098a9c7d4b291aba2e0d2cdf01e46 100644 (file)
--- a/lib/python/Screens/TimerEdit.py
+++ b/lib/python/Screens/TimerEdit.py
@@ -1,8 +1,8 @@
 from Components.ActionMap import ActionMap
 from Components.Button import Button
 from Components.ActionMap import ActionMap
 from Components.Button import Button

-from Components.Label import Label
+from Components.config import config

 from Components.MenuList import MenuList
 from Components.MenuList import MenuList

-from Components.TimerList import TimerList, TimerEntryComponent
+from Components.TimerList import TimerList

 from Components.TimerSanityCheck import TimerSanityCheck
 from RecordTimer import RecordTimerEntry, parseEvent, AFTEREVENT
 from Screen import Screen
 from Components.TimerSanityCheck import TimerSanityCheck
 from RecordTimer import RecordTimerEntry, parseEvent, AFTEREVENT
 from Screen import Screen


@@ -11,31 +11,46 @@ from Screens.MessageBox import MessageBox
 from ServiceReference import ServiceReference
 from TimerEntry import TimerEntry, TimerLog
 from Tools.BoundFunction import boundFunction
 from ServiceReference import ServiceReference
 from TimerEntry import TimerEntry, TimerLog
 from Tools.BoundFunction import boundFunction

-from time import *
+from time import time

 
 class TimerEditList(Screen):
 
 class TimerEditList(Screen):

+       EMPTY = 0
+       ENABLE = 1
+       DISABLE = 2
+       CLEANUP = 3
+       DELETE = 4
+       

        def __init__(self, session):
                Screen.__init__(self, session)
                
                list = [ ]
                self.list = list
                self.fillTimerList()
        def __init__(self, session):
                Screen.__init__(self, session)
                
                list = [ ]
                self.list = list
                self.fillTimerList()

+               
+               print "EMPTY:",self.EMPTY
+               print "ENABLE:",self.ENABLE
+               print "DISABLE:",self.DISABLE
+               print "CLEANUP:",self.CLEANUP
+               print "DELETE:",self.DELETE

 
                self["timerlist"] = TimerList(list)
                
 
                self["timerlist"] = TimerList(list)
                

-               self["key_red"] = Button(_("Delete"))
+               self.key_red_choice = self.EMPTY
+               self.key_yellow_choice = self.EMPTY
+               self.key_blue_choice = self.EMPTY
+               
+               self["key_red"] = Button(" ")

                self["key_green"] = Button(_("Add"))
                self["key_green"] = Button(_("Add"))

-               self["key_yellow"] = Button("")
-               self["key_blue"] = Button(_("Cleanup"))
+               self["key_yellow"] = Button(" ")
+               self["key_blue"] = Button(" ")
+
+               print "key_red_choice:",self.key_red_choice

 
                self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"], 
                        {
                                "ok": self.openEdit,
                                "cancel": self.leave,
 
                self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"], 
                        {
                                "ok": self.openEdit,
                                "cancel": self.leave,

-                               "red": self.removeTimerQuestion,

                                "green": self.addCurrentTimer,
                                "green": self.addCurrentTimer,

-                               "blue": self.cleanupQuestion,
-                               "yellow": self.toggleDisabledState,

                                "log": self.showLog,
                                "left": self.left,
                                "right": self.right,
                                "log": self.showLog,
                                "left": self.left,
                                "right": self.right,


@@ -64,24 +79,32 @@ class TimerEditList(Screen):
        def toggleDisabledState(self):
                cur=self["timerlist"].getCurrent()
                if cur:
        def toggleDisabledState(self):
                cur=self["timerlist"].getCurrent()
                if cur:

-                       t = cur[0]
-               
+                       t = cur

                        if t.disabled:
                        if t.disabled:

+                               print "try to ENABLE timer"

                                t.enable()
                                t.enable()

-                               self.session.nav.RecordTimer.timeChanged(t)
-
+                               timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, cur)
+                               if not timersanitycheck.check():
+                                       t.disable()
+                                       print "Sanity check failed"
+                                       self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, timersanitycheck.getSimulTimerList())
+                               else:
+                                       print "Sanity check passed"
+                                       if timersanitycheck.doubleCheck():
+                                               t.disable()

                        else:
                        else:

-                               if t.isRunning() and t.repeated:
-                                       list = []
-                                       list.append((_("Stop current event but not coming events"), "stoponlycurrent"))
-                                       list.append((_("Stop current event and disable coming events"), "stopall"))
-                                       list.append((_("Don't stop current event but disable coming events"), "stoponlycoming"))
-                                       self.session.openWithCallback(boundFunction(self.runningEventCallback, t), ChoiceBox, title=_("Repeating event currently recording... What do you want to do?"), list = list)
+                               if t.isRunning():
+                                       if t.repeated:
+                                               list = []
+                                               list.append((_("Stop current event but not coming events"), "stoponlycurrent"))
+                                               list.append((_("Stop current event and disable coming events"), "stopall"))
+                                               list.append((_("Don't stop current event but disable coming events"), "stoponlycoming"))
+                                               self.session.openWithCallback(boundFunction(self.runningEventCallback, t), ChoiceBox, title=_("Repeating event currently recording... What do you want to do?"), list = list)

                                else:
                                        t.disable()
                                else:
                                        t.disable()

-                                       self.session.nav.RecordTimer.timeChanged(t)
-                       self.updateState()
+                       self.session.nav.RecordTimer.timeChanged(t)

                        self.refill()
                        self.refill()

+                       self.updateState()

 
        def runningEventCallback(self, t, result):
                if result is not None:
 
        def runningEventCallback(self, t, result):
                if result is not None:


@@ -92,37 +115,83 @@ class TimerEditList(Screen):
                        if result[1] == "stoponlycoming" or result[1] == "stopall":
                                t.disable()
                        self.session.nav.RecordTimer.timeChanged(t)
                        if result[1] == "stoponlycoming" or result[1] == "stopall":
                                t.disable()
                        self.session.nav.RecordTimer.timeChanged(t)

-
-                       self.updateState()

                        self.refill()
                        self.refill()

+                       self.updateState()

                
        def updateState(self):
                
        def updateState(self):

-               if len(self.list) > 0:
-                       if self["timerlist"].getCurrent()[0].disabled:
+               cur = self["timerlist"].getCurrent()
+               if cur:
+                       if self.key_red_choice != self.DELETE:
+                               self["actions"].actions.update({"red":self.removeTimerQuestion})
+                               self["key_red"].setText(_("Delete"))
+                               self["key_red"].instance.invalidate()
+                               self.key_red_choice = self.DELETE
+                       
+                       if cur.disabled and (self.key_yellow_choice != self.ENABLE):
+                               self["actions"].actions.update({"yellow":self.toggleDisabledState})

                                self["key_yellow"].setText(_("Enable"))
                                self["key_yellow"].setText(_("Enable"))

-                       else:
+                               self["key_yellow"].instance.invalidate()
+                               self.key_yellow_choice = self.ENABLE
+                       elif cur.isRunning() and not cur.repeated and (self.key_yellow_choice != self.EMPTY):
+                               del self["actions"].actions["yellow"]
+                               self["key_yellow"].setText(" ")
+                               self["key_yellow"].instance.invalidate()
+                               self.key_yellow_choice = self.EMPTY
+                       elif ((not cur.isRunning())or cur.repeated ) and (not cur.disabled) and (self.key_yellow_choice != self.DISABLE):
+                               self["actions"].actions.update({"yellow":self.toggleDisabledState})

                                self["key_yellow"].setText(_("Disable"))
                                self["key_yellow"].setText(_("Disable"))

-                       self["key_yellow"].instance.invalidate()
+                               self["key_yellow"].instance.invalidate()
+                               self.key_yellow_choice = self.DISABLE
+               else:
+                       if self.key_red_choice != self.EMPTY:
+                               del self["actions"].actions["red"]
+                               self["key_red"].setText(" ")
+                               self["key_red"].instance.invalidate()
+                               self.key_red_choice = self.EMPTY
+                       if self.key_yellow_choice != self.EMPTY:
+                               del self["actions"].actions["yellow"]
+                               self["key_yellow"].setText(" ")
+                               self["key_yellow"].instance.invalidate()
+                               self.key_yellow_choice = self.EMPTY
+               
+               showCleanup = True
+               for x in self.list:
+                       if (not x[0].disabled) and (x[1] == True):
+                               break
+               else:
+                       showCleanup = False
+               
+               if showCleanup and (self.key_blue_choice != self.CLEANUP):
+                       self["actions"].actions.update({"blue":self.cleanupQuestion})
+                       self["key_blue"].setText(_("Cleanup"))
+                       self["key_blue"].instance.invalidate()
+                       self.key_blue_choice = self.CLEANUP
+               elif (not showCleanup) and (self.key_blue_choice != self.EMPTY):
+                       del self["actions"].actions["blue"]
+                       self["key_blue"].setText(" ")
+                       self["key_blue"].instance.invalidate()
+                       self.key_blue_choice = self.EMPTY
+

 
        def fillTimerList(self):
                del self.list[:]
                
                for timer in self.session.nav.RecordTimer.timer_list:
 
        def fillTimerList(self):
                del self.list[:]
                
                for timer in self.session.nav.RecordTimer.timer_list:

-                       self.list.append(TimerEntryComponent(timer, processed=False))
+                       self.list.append((timer, False))

                
                for timer in self.session.nav.RecordTimer.processed_timers:
                
                for timer in self.session.nav.RecordTimer.processed_timers:

-                       self.list.append(TimerEntryComponent(timer, processed=True))
+                       self.list.append((timer, True))

                self.list.sort(cmp = lambda x, y: x[0].begin < y[0].begin)
 
        def showLog(self):
                cur=self["timerlist"].getCurrent()
                if cur:
                self.list.sort(cmp = lambda x, y: x[0].begin < y[0].begin)
 
        def showLog(self):
                cur=self["timerlist"].getCurrent()
                if cur:

-                       self.session.openWithCallback(self.finishedEdit, TimerLog, cur[0])
+                       self.session.openWithCallback(self.finishedEdit, TimerLog, cur)

 
        def openEdit(self):
                cur=self["timerlist"].getCurrent()
                if cur:
 
        def openEdit(self):
                cur=self["timerlist"].getCurrent()
                if cur:

-                       self.session.openWithCallback(self.finishedEdit, TimerEntry, cur[0])
+                       self.session.openWithCallback(self.finishedEdit, TimerEntry, cur)

 
        def cleanupQuestion(self):
                self.session.openWithCallback(self.cleanupTimer, MessageBox, _("Really delete done timers?"))
 
        def cleanupQuestion(self):
                self.session.openWithCallback(self.cleanupTimer, MessageBox, _("Really delete done timers?"))


@@ -131,24 +200,48 @@ class TimerEditList(Screen):
                if delete:
                        self.session.nav.RecordTimer.cleanup()
                        self.refill()
                if delete:
                        self.session.nav.RecordTimer.cleanup()
                        self.refill()

-       
+                       self.updateState()
+

        def removeTimerQuestion(self):
        def removeTimerQuestion(self):

+               if not self["timerlist"].getCurrent():
+                       return

                self.session.openWithCallback(self.removeTimer, MessageBox, _("Really delete this timer?"))
                self.session.openWithCallback(self.removeTimer, MessageBox, _("Really delete this timer?"))

-               
+

        def removeTimer(self, result):
                if not result:
                        return
                list = self["timerlist"]
                cur = list.getCurrent()
                if cur:
        def removeTimer(self, result):
                if not result:
                        return
                list = self["timerlist"]
                cur = list.getCurrent()
                if cur:

-                       timer = cur[0]
+                       timer = cur

                        timer.afterEvent = AFTEREVENT.NONE
                        self.session.nav.RecordTimer.removeEntry(timer)
                        timer.afterEvent = AFTEREVENT.NONE
                        self.session.nav.RecordTimer.removeEntry(timer)

+                       if not timer.dontSave:
+                               for timer in self.session.nav.RecordTimer.timer_list:
+                                       if timer.dontSave and timer.autoincrease:
+                                               timer.end = timer.begin + (3600 * 24 * 356 * 1)
+                                               self.session.nav.RecordTimer.timeChanged(timer)
+                                               timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list,timer)
+                                               if not timersanitycheck.check():
+                                                       tsc_list = timersanitycheck.getSimulTimerList()
+                                                       if len(tsc_list) > 1:
+                                                               timer.end = tsc_list[1].begin - 30
+                                                               self.session.nav.RecordTimer.timeChanged(timer)
+

                        self.refill()
                        self.refill()

+                       self.updateState()
+

        
        def refill(self):
        
        def refill(self):

+               oldsize = len(self.list)

                self.fillTimerList()
                self.fillTimerList()

-               self["timerlist"].invalidate()
+               lst = self["timerlist"]
+               newsize = len(self.list)
+               if oldsize and oldsize != newsize:
+                       idx = lst.getCurrentIndex()
+                       lst.entryRemoved(idx)
+               else:
+                       lst.invalidate()

        
        def addCurrentTimer(self):
                event = None
        
        def addCurrentTimer(self):
                event = None


@@ -166,7 +259,7 @@ class TimerEditList(Screen):
                else:
                        data = parseEvent(event, description = False)
 
                else:
                        data = parseEvent(event, description = False)
 

-               self.addTimer(RecordTimerEntry(serviceref, checkOldTimers = True, *data))
+               self.addTimer(RecordTimerEntry(serviceref, checkOldTimers = True, dirname = config.movielist.last_timer_videodir.value, *data))

                
        def addTimer(self, timer):
                self.session.openWithCallback(self.finishedAdd, TimerEntry, timer)
                
        def addTimer(self, timer):
                self.session.openWithCallback(self.finishedAdd, TimerEntry, timer)


@@ -176,102 +269,179 @@ class TimerEditList(Screen):
                
                if answer[0]:
                        print "Edited timer"
                
                if answer[0]:
                        print "Edited timer"

-                       timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, answer[1])
+                       entry = answer[1]
+                       timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, entry)

                        if not timersanitycheck.check():
                        if not timersanitycheck.check():

-                               print "Sanity check failed"
+                               simulTimerList = timersanitycheck.getSimulTimerList()
+                               if (len(simulTimerList) == 2) and (simulTimerList[1].dontSave) and (simulTimerList[1].autoincrease):
+                                       simulTimerList[1].end = entry.begin - 30
+                                       self.session.nav.RecordTimer.timeChanged(simulTimerList[1])
+                                       self.session.nav.RecordTimer.timeChanged(entry)
+                               else:
+                                       print "Sanity check failed"
+                                       self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, timersanitycheck.getSimulTimerList())

                        else:
                                print "Sanity check passed"
                        else:
                                print "Sanity check passed"

-                       self.session.nav.RecordTimer.timeChanged(answer[1])
+                               if not timersanitycheck.doubleCheck():
+                                       self.session.nav.RecordTimer.timeChanged(entry)

                        self.fillTimerList()
                        self.fillTimerList()

+                       self.updateState()

                else:
                        print "Timeredit aborted"
 
        def finishedAdd(self, answer):
                print "finished add"
                if answer[0]:
                else:
                        print "Timeredit aborted"
 
        def finishedAdd(self, answer):
                print "finished add"
                if answer[0]:

-                       timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, answer[1])
-                       if not timersanitycheck.check():
-                               print "Sanity check failed"
-                               self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, timersanitycheck.getSimulTimerList())
-                       else:
-                               print "Sanity check passed"
-                               entry = answer[1]
-                               self.session.nav.RecordTimer.record(entry)
-                               self.fillTimerList()
+                       entry = answer[1]
+                       simulTimerList = self.session.nav.RecordTimer.record(entry)
+                       if simulTimerList is not None:
+                               if (len(simulTimerList) == 2) and (simulTimerList[1].dontSave) and (simulTimerList[1].autoincrease):
+                                       simulTimerList[1].end = entry.begin - 30
+                                       self.session.nav.RecordTimer.timeChanged(simulTimerList[1])
+                                       self.session.nav.RecordTimer.record(entry)
+                               else:
+                                       self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
+                       self.fillTimerList()
+                       self.updateState()

                else:
                else:

-                       print "Timeredit aborted"               
+                       print "Timeredit aborted"

 
        def finishSanityCorrection(self, answer):
                self.finishedAdd(answer)
 
        def leave(self):
 
        def finishSanityCorrection(self, answer):
                self.finishedAdd(answer)
 
        def leave(self):

-               self.session.nav.RecordTimer.saveTimer()

                self.session.nav.RecordTimer.on_state_change.remove(self.onStateChange)
                self.close()
 
        def onStateChange(self, entry):
                self.refill()
                self.session.nav.RecordTimer.on_state_change.remove(self.onStateChange)
                self.close()
 
        def onStateChange(self, entry):
                self.refill()

-               
+               self.updateState()
+

 class TimerSanityConflict(Screen):
 class TimerSanityConflict(Screen):

+       EMPTY = 0
+       ENABLE = 1
+       DISABLE = 2
+       

        def __init__(self, session, timer):
                Screen.__init__(self, session)
                self.timer = timer
        def __init__(self, session, timer):
                Screen.__init__(self, session)
                self.timer = timer

-               print "TimerSanityConflict", timer
+               print "TimerSanityConflict"

                        
                self["timer1"] = TimerList(self.getTimerList(timer[0]))
                        
                self["timer1"] = TimerList(self.getTimerList(timer[0]))

-               if len(timer) > 1:
-                       self["timer2"] = TimerList(self.getTimerList(timer[1]))
-               else:
-                       self["timer2"] = TimerList([])
-               

                self.list = []
                self.list = []

+               self.list2 = []

                count = 0
                for x in timer:
                        if count != 0:
                                self.list.append((_("Conflicting timer") + " " + str(count), x))
                count = 0
                for x in timer:
                        if count != 0:
                                self.list.append((_("Conflicting timer") + " " + str(count), x))

+                               self.list2.append((timer[count], False))

                        count += 1
 
                self["list"] = MenuList(self.list)
                        count += 1
 
                self["list"] = MenuList(self.list)

-               
+               self["timer2"] = TimerList(self.list2)
+

                self["key_red"] = Button("Edit")
                self["key_red"] = Button("Edit")

-               self["key_green"] = Button("Disable")
+               self["key_green"] = Button(" ")

                self["key_yellow"] = Button("Edit")
                self["key_yellow"] = Button("Edit")

-               self["key_blue"] = Button("Disable")
+               self["key_blue"] = Button(" ")
+
+               self.key_green_choice = self.EMPTY
+               self.key_blue_choice = self.EMPTY

 
                self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"], 
                        {
 
                self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"], 
                        {

-                               "ok": self.close,
-                               #"cancel": self.leave,
+                               "ok": self.leave_ok,
+                               "cancel": self.leave_cancel,

                                "red": self.editTimer1,
                                "red": self.editTimer1,

-                               "green": self.disableTimer1,
-#                              "yellow": self.editTimer2,
-#                              "blue": self.disableTimer2,
-                               #"log": self.showLog,
-                               #"left": self.left,
-                               #"right": self.right,

                                "up": self.up,
                                "down": self.down
                        }, -1)
                                "up": self.up,
                                "down": self.down
                        }, -1)

+               self.onShown.append(self.updateState)

 
        def getTimerList(self, timer):
 
        def getTimerList(self, timer):

-               return [TimerEntryComponent(timer, processed=False)]
+               return [(timer, False)]

 
        def editTimer1(self):
 
        def editTimer1(self):

-               self.session.openWithCallback(self.finishedEdit, TimerEntry, self["timer1"].getCurrent()[0])
+               self.session.openWithCallback(self.finishedEdit, TimerEntry, self["timer1"].getCurrent())

 
 

-       def disableTimer1(self):
-               self.timer[0].disabled = True
+       def toggleTimer1(self):
+               if self.timer[0].disabled:
+                       self.timer[0].disabled = False
+               else:
+                       if not self.timer[0].isRunning():
+                               self.timer[0].disabled = True

                self.finishedEdit((True, self.timer[0]))
                self.finishedEdit((True, self.timer[0]))

+       
+       def editTimer2(self):
+               self.session.openWithCallback(self.finishedEdit, TimerEntry, self["timer2"].getCurrent())

 
 

+       def toggleTimer2(self):
+               x = self["list"].getSelectedIndex() + 1 # the first is the new timer so we do +1 here
+               if self.timer[x].disabled:
+                       self.timer[x].disabled = False
+               elif not self.timer[x].isRunning():
+                               self.timer[x].disabled = True
+               self.finishedEdit((True, self.timer[0]))
+       

        def finishedEdit(self, answer):
        def finishedEdit(self, answer):

+               self.leave_ok()
+       
+       def leave_ok(self):

                self.close((True, self.timer[0]))
                self.close((True, self.timer[0]))

+       
+       def leave_cancel(self):
+               self.close((False, self.timer[0]))

 
        def up(self):
                self["list"].instance.moveSelection(self["list"].instance.moveUp)
 
        def up(self):
                self["list"].instance.moveSelection(self["list"].instance.moveUp)

-               self["timer2"].l.setList(self.getTimerList(self["list"].getCurrent()[1]))
+               self["timer2"].moveToIndex(self["list"].getSelectedIndex())

                
        def down(self):
                self["list"].instance.moveSelection(self["list"].instance.moveDown)
                
        def down(self):
                self["list"].instance.moveSelection(self["list"].instance.moveDown)

-               self["timer2"].l.setList(self.getTimerList(self["list"].getCurrent()[1]))
-                       
-               
\ No newline at end of file
+               self["timer2"].moveToIndex(self["list"].getSelectedIndex())
+       
+       def updateState(self):
+               if self.timer[0] is not None:
+                       if self.timer[0].disabled and self.key_green_choice != self.ENABLE:
+                               self["actions"].actions.update({"green":self.toggleTimer1})
+                               self["key_green"].setText(_("Enable"))
+                               self["key_green"].instance.invalidate()
+                               self.key_green_choice = self.ENABLE
+                       elif self.timer[0].isRunning() and not timer[0].repeated and self.key_green_choice != self.EMPTY:
+                               del self["actions"].actions["green"]
+                               self["key_green"].setText(" ")
+                               self["key_green"].instance.invalidate()
+                               self.key_green_choice = self.EMPTY
+                       elif (not self.timer[0].isRunning() or self.timer[0].repeated ) and self.key_green_choice != self.DISABLE:
+                               self["actions"].actions.update({"green":self.toggleTimer1})
+                               self["key_green"].setText(_("Disable"))
+                               self["key_green"].instance.invalidate()
+                               self.key_green_choice = self.DISABLE
+               if len(self.timer) > 1:
+                       x = self["list"].getSelectedIndex()
+                       if self.timer[x] is not None:
+                               if self.timer[x].disabled and self.key_blue_choice != self.ENABLE:
+                                       self["actions"].actions.update({"blue":self.toggleTimer2})
+                                       self["key_blue"].setText(_("Enable"))
+                                       self["key_blue"].instance.invalidate()
+                                       self.key_blue_choice = self.ENABLE
+                               elif self.timer[x].isRunning() and not timer[x].repeated and self.key_blue_choice != self.EMPTY:
+                                       del self["actions"].actions["blue"]
+                                       self["key_blue"].setText(" ")
+                                       self["key_blue"].instance.invalidate()
+                                       self.key_blue_choice = self.EMPTY
+                               elif (not self.timer[x].isRunning() or self.timer[x].repeated ) and self.key_blue_choice != self.DISABLE:
+                                       self["actions"].actions.update({"blue":self.toggleTimer2})
+                                       self["key_blue"].setText(_("Disable"))
+                                       self["key_blue"].instance.invalidate()
+                                       self.key_blue_choice = self.DISABLE
+               else:
+#FIXME.... this doesnt hide the buttons self.... just the text
+                       del self["actions"].actions["yellow"]
+                       self["key_yellow"].setText(" ")
+                       self["key_yellow"].instance.invalidate()
+                       self.key_yellow_choice = self.EMPTY
+                       del self["actions"].actions["blue"]
+                       self["key_blue"].setText(" ")
+                       self["key_blue"].instance.invalidate()
+                       self.key_blue_choice = self.EMPTY