git.cweiske.de / enigma2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
install Console.py
[enigma2.git] / lib / python / Screens / TimerEdit.py
diff --git a/lib/python/Screens/TimerEdit.py b/lib/python/Screens/TimerEdit.py
index 08bc12b324e9e2b3db57ece70515fb0c8dd3bf73..5e486272a51698ed6631e5662ce74528d5fdb683 100644 (file)
--- a/lib/python/Screens/TimerEdit.py
+++ b/lib/python/Screens/TimerEdit.py
@@ -1,7 +1,8 @@
 from Components.ActionMap import ActionMap
 from Components.Button import Button
 from Components.ActionMap import ActionMap
 from Components.Button import Button
+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
@@ -63,24 +64,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:
@@ -91,37 +100,75 @@ 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"].getText()!=(_("Delete")):
+                               self["actions"].actions.update({"red":self.removeTimerQuestion})
+                               self["key_red"].setText(_("Delete"))
+                               self["key_red"].instance.invalidate()
+                       
+                       if cur.disabled and (self["key_yellow"].getText()!=(_("Enable"))):
+                               self["actions"].actions.update({"yellow":self.toggleDisabledState})
                                self["key_yellow"].setText(_("Enable"))
                                self["key_yellow"].setText(_("Enable"))
-                       else:
+                               self["key_yellow"].instance.invalidate()
+                       elif cur.isRunning() and (self["key_yellow"].getText()!=(_(" "))):
+                               del self["actions"].actions["yellow"]
+                               self["key_yellow"].setText(_(" "))
+                               self["key_yellow"].instance.invalidate()
+                       elif (not cur.isRunning()) and (not cur.disabled) and (self["key_yellow"].getText()!=(_("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()
+               else:
+                       if self["key_red"].getText()!=(_(" ")):
+                               del self["actions"].actions["red"]
+                               self["key_red"].setText(_(" "))
+                               self["key_red"].instance.invalidate()
+                       if self["key_yellow"].getText()!=(_(" ")):
+                               del self["actions"].actions["yellow"]
+                               self["key_yellow"].setText(_(" "))
+                               self["key_yellow"].instance.invalidate()
+               
+               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"].getText()!=(_("Cleanup"))):
+                       self["actions"].actions.update({"blue":self.cleanupQuestion})
+                       self["key_blue"].setText(_("Cleanup"))
+                       self["key_blue"].instance.invalidate()
+               elif (not showCleanup) and (self["key_blue"].getText()!=(_(" "))):
+                       del self["actions"].actions["blue"]
+                       self["key_blue"].setText(_(" "))
+                       self["key_blue"].instance.invalidate()
+
 
        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?"))
@@ -130,24 +177,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
@@ -165,7 +236,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)
@@ -175,102 +246,172 @@ 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):
        def __init__(self, session, timer):
                Screen.__init__(self, session)
                self.timer = timer
 class TimerSanityConflict(Screen):
        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["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,
+                               "green": self.toggleTimer1,
+                               "yellow": self.editTimer2,
+                               "blue": self.toggleTimer2,
                                #"log": self.showLog,
                                #"left": self.left,
                                #"right": self.right,
                                "up": self.up,
                                "down": self.down
                        }, -1)
                                #"log": self.showLog,
                                #"left": self.left,
                                #"right": self.right,
                                "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:
+                       green_text = self["key_green"].getText()
+                       if self.timer[0].disabled and green_text != _("Enable"):
+                               self["actions"].actions.update({"green":self.toggleTimer1})
+                               self["key_green"].setText(_("Enable"))
+                               self["key_green"].instance.invalidate()
+                       elif self.timer[0].isRunning() and green_text != "":
+                               del self["actions"].actions["green"]
+                               self["key_green"].setText("")
+                               self["key_green"].instance.invalidate()
+                       elif not self.timer[0].disabled and green_text != _("Disable"):
+                               self["actions"].actions.update({"green":self.toggleTimer1})
+                               self["key_green"].setText(_("Disable"))
+                               self["key_green"].instance.invalidate()
+               if len(self.timer) > 1:
+                       x = self["list"].getSelectedIndex()
+                       if self.timer[x] is not None:
+                               blue_text = self["key_blue"].getText()
+                               if self.timer[x].disabled and blue_text != _("Enable"):
+                                       self["actions"].actions.update({"blue":self.toggleTimer2})
+                                       self["key_blue"].setText(_("Enable"))
+                                       self["key_blue"].instance.invalidate()
+                               elif self.timer[x].isRunning() and blue_text != "":
+                                       del self["actions"].actions["blue"]
+                                       self["key_blue"].setText("")
+                                       self["key_blue"].instance.invalidate()
+                               elif not self.timer[x].disabled and blue_text != _("Disable"):
+                                       self["actions"].actions.update({"blue":self.toggleTimer2})
+                                       self["key_blue"].setText(_("Disable"))
+                                       self["key_blue"].instance.invalidate()
+               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()
+                       del self["actions"].actions["blue"]
+                       self["key_blue"].setText("")
+                       self["key_blue"].instance.invalidate()
Clone of git://git.opendreambox.org/git/enigma2.git before dream multimedia removed all the engima2 sources