bf60496fbe5399652e89ecc1b03c01521c9b81b5
[enigma2.git] / lib / python / Screens / TimerEdit.py
1 from Components.ActionMap import ActionMap
2 from Components.Button import Button
3 from Components.config import config
4 from Components.MenuList import MenuList
5 from Components.TimerList import TimerList
6 from Components.TimerSanityCheck import TimerSanityCheck
7 from Components.UsageConfig import preferredTimerPath
8 from RecordTimer import RecordTimerEntry, parseEvent, AFTEREVENT
9 from Screen import Screen
10 from Screens.ChoiceBox import ChoiceBox
11 from Screens.MessageBox import MessageBox
12 from ServiceReference import ServiceReference
13 from TimerEntry import TimerEntry, TimerLog
14 from Tools.BoundFunction import boundFunction
15 from time import time
16
17 class TimerEditList(Screen):
18         EMPTY = 0
19         ENABLE = 1
20         DISABLE = 2
21         CLEANUP = 3
22         DELETE = 4
23         
24         def __init__(self, session):
25                 Screen.__init__(self, session)
26                 
27                 list = [ ]
28                 self.list = list
29                 self.fillTimerList()
30                 
31                 print "EMPTY:",self.EMPTY
32                 print "ENABLE:",self.ENABLE
33                 print "DISABLE:",self.DISABLE
34                 print "CLEANUP:",self.CLEANUP
35                 print "DELETE:",self.DELETE
36
37                 self["timerlist"] = TimerList(list)
38                 
39                 self.key_red_choice = self.EMPTY
40                 self.key_yellow_choice = self.EMPTY
41                 self.key_blue_choice = self.EMPTY
42                 
43                 self["key_red"] = Button(" ")
44                 self["key_green"] = Button(_("Add"))
45                 self["key_yellow"] = Button(" ")
46                 self["key_blue"] = Button(" ")
47
48                 print "key_red_choice:",self.key_red_choice
49
50                 self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"], 
51                         {
52                                 "ok": self.openEdit,
53                                 "cancel": self.leave,
54                                 "green": self.addCurrentTimer,
55                                 "log": self.showLog,
56                                 "left": self.left,
57                                 "right": self.right,
58                                 "up": self.up,
59                                 "down": self.down
60                         }, -1)
61                 self.session.nav.RecordTimer.on_state_change.append(self.onStateChange)
62                 self.onShown.append(self.updateState)
63
64         def up(self):
65                 self["timerlist"].instance.moveSelection(self["timerlist"].instance.moveUp)
66                 self.updateState()
67                 
68         def down(self):
69                 self["timerlist"].instance.moveSelection(self["timerlist"].instance.moveDown)
70                 self.updateState()
71
72         def left(self):
73                 self["timerlist"].instance.moveSelection(self["timerlist"].instance.pageUp)
74                 self.updateState()
75                 
76         def right(self):
77                 self["timerlist"].instance.moveSelection(self["timerlist"].instance.pageDown)
78                 self.updateState()
79                 
80         def toggleDisabledState(self):
81                 cur=self["timerlist"].getCurrent()
82                 if cur:
83                         t = cur
84                         if t.disabled:
85                                 print "try to ENABLE timer"
86                                 t.enable()
87                                 timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, cur)
88                                 if not timersanitycheck.check():
89                                         t.disable()
90                                         print "Sanity check failed"
91                                         self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, timersanitycheck.getSimulTimerList())
92                                 else:
93                                         print "Sanity check passed"
94                                         if timersanitycheck.doubleCheck():
95                                                 t.disable()
96                         else:
97                                 if t.isRunning():
98                                         if t.repeated:
99                                                 list = (
100                                                         (_("Stop current event but not coming events"), "stoponlycurrent"),
101                                                         (_("Stop current event and disable coming events"), "stopall"),
102                                                         (_("Don't stop current event but disable coming events"), "stoponlycoming")
103                                                 )
104                                                 self.session.openWithCallback(boundFunction(self.runningEventCallback, t), ChoiceBox, title=_("Repeating event currently recording... What do you want to do?"), list = list)
105                                 else:
106                                         t.disable()
107                         self.session.nav.RecordTimer.timeChanged(t)
108                         self.refill()
109                         self.updateState()
110
111         def runningEventCallback(self, t, result):
112                 if result is not None:
113                         if result[1] == "stoponlycurrent" or result[1] == "stopall":
114                                 t.enable()
115                                 t.processRepeated(findRunningEvent = False)
116                                 self.session.nav.RecordTimer.doActivate(t)
117                         if result[1] == "stoponlycoming" or result[1] == "stopall":
118                                 t.disable()
119                         self.session.nav.RecordTimer.timeChanged(t)
120                         self.refill()
121                         self.updateState()
122
123         def removeAction(self, descr):
124                 actions = self["actions"].actions
125                 if descr in actions:
126                         del actions[descr]
127
128         def updateState(self):
129                 cur = self["timerlist"].getCurrent()
130                 if cur:
131                         if self.key_red_choice != self.DELETE:
132                                 self["actions"].actions.update({"red":self.removeTimerQuestion})
133                                 self["key_red"].setText(_("Delete"))
134                                 self.key_red_choice = self.DELETE
135                         
136                         if cur.disabled and (self.key_yellow_choice != self.ENABLE):
137                                 self["actions"].actions.update({"yellow":self.toggleDisabledState})
138                                 self["key_yellow"].setText(_("Enable"))
139                                 self.key_yellow_choice = self.ENABLE
140                         elif cur.isRunning() and not cur.repeated and (self.key_yellow_choice != self.EMPTY):
141                                 self.removeAction("yellow")
142                                 self["key_yellow"].setText(" ")
143                                 self.key_yellow_choice = self.EMPTY
144                         elif ((not cur.isRunning())or cur.repeated ) and (not cur.disabled) and (self.key_yellow_choice != self.DISABLE):
145                                 self["actions"].actions.update({"yellow":self.toggleDisabledState})
146                                 self["key_yellow"].setText(_("Disable"))
147                                 self.key_yellow_choice = self.DISABLE
148                 else:
149                         if self.key_red_choice != self.EMPTY:
150                                 self.removeAction("red")
151                                 self["key_red"].setText(" ")
152                                 self.key_red_choice = self.EMPTY
153                         if self.key_yellow_choice != self.EMPTY:
154                                 self.removeAction("yellow")
155                                 self["key_yellow"].setText(" ")
156                                 self.key_yellow_choice = self.EMPTY
157                 
158                 showCleanup = True
159                 for x in self.list:
160                         if (not x[0].disabled) and (x[1] == True):
161                                 break
162                 else:
163                         showCleanup = False
164                 
165                 if showCleanup and (self.key_blue_choice != self.CLEANUP):
166                         self["actions"].actions.update({"blue":self.cleanupQuestion})
167                         self["key_blue"].setText(_("Cleanup"))
168                         self.key_blue_choice = self.CLEANUP
169                 elif (not showCleanup) and (self.key_blue_choice != self.EMPTY):
170                         self.removeAction("blue")
171                         self["key_blue"].setText(" ")
172                         self.key_blue_choice = self.EMPTY
173
174         def fillTimerList(self):
175                 list = self.list
176                 del list[:]
177                 list.extend([(timer, False) for timer in self.session.nav.RecordTimer.timer_list])
178                 list.extend([(timer, True) for timer in self.session.nav.RecordTimer.processed_timers])
179                 list.sort(key = lambda x: x[0].begin)
180
181         def showLog(self):
182                 cur=self["timerlist"].getCurrent()
183                 if cur:
184                         self.session.openWithCallback(self.finishedEdit, TimerLog, cur)
185
186         def openEdit(self):
187                 cur=self["timerlist"].getCurrent()
188                 if cur:
189                         self.session.openWithCallback(self.finishedEdit, TimerEntry, cur)
190
191         def cleanupQuestion(self):
192                 self.session.openWithCallback(self.cleanupTimer, MessageBox, _("Really delete done timers?"))
193         
194         def cleanupTimer(self, delete):
195                 if delete:
196                         self.session.nav.RecordTimer.cleanup()
197                         self.refill()
198                         self.updateState()
199
200         def removeTimerQuestion(self):
201                 cur = self["timerlist"].getCurrent()
202                 if not cur:
203                         return
204
205                 self.session.openWithCallback(self.removeTimer, MessageBox, _("Do you really want to delete %s?") % (cur.name))
206
207         def removeTimer(self, result):
208                 if not result:
209                         return
210                 list = self["timerlist"]
211                 cur = list.getCurrent()
212                 if cur:
213                         timer = cur
214                         timer.afterEvent = AFTEREVENT.NONE
215                         self.session.nav.RecordTimer.removeEntry(timer)
216                         self.refill()
217                         self.updateState()
218
219         
220         def refill(self):
221                 oldsize = len(self.list)
222                 self.fillTimerList()
223                 lst = self["timerlist"]
224                 newsize = len(self.list)
225                 if oldsize and oldsize != newsize:
226                         idx = lst.getCurrentIndex()
227                         lst.entryRemoved(idx)
228                 else:
229                         lst.invalidate()
230         
231         def addCurrentTimer(self):
232                 event = None
233                 service = self.session.nav.getCurrentService()
234                 if service is not None:
235                         info = service.info()
236                         if info is not None:
237                                 event = info.getEvent(0)
238
239                 # FIXME only works if already playing a service
240                 serviceref = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference())
241                 
242                 if event is None:       
243                         data = (int(time()), int(time() + 60), "", "", None)
244                 else:
245                         data = parseEvent(event, description = False)
246
247                 self.addTimer(RecordTimerEntry(serviceref, checkOldTimers = True, dirname = preferredTimerPath(), *data))
248                 
249         def addTimer(self, timer):
250                 self.session.openWithCallback(self.finishedAdd, TimerEntry, timer)
251                         
252                 
253         def finishedEdit(self, answer):
254                 print "finished edit"
255                 
256                 if answer[0]:
257                         print "Edited timer"
258                         entry = answer[1]
259                         timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, entry)
260                         success = False
261                         if not timersanitycheck.check():
262                                 simulTimerList = timersanitycheck.getSimulTimerList()
263                                 if simulTimerList is not None:
264                                         for x in simulTimerList:
265                                                 if x.setAutoincreaseEnd(entry):
266                                                         self.session.nav.RecordTimer.timeChanged(x)
267                                         if not timersanitycheck.check():
268                                                 simulTimerList = timersanitycheck.getSimulTimerList()
269                                                 if simulTimerList is not None:
270                                                         self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, timersanitycheck.getSimulTimerList())
271                                         else:
272                                                 success = True
273                         else:
274                                 success = True
275                         if success:
276                                 print "Sanity check passed"
277                                 self.session.nav.RecordTimer.timeChanged(entry)
278                         
279                         self.fillTimerList()
280                         self.updateState()
281                 else:
282                         print "Timeredit aborted"
283
284         def finishedAdd(self, answer):
285                 print "finished add"
286                 if answer[0]:
287                         entry = answer[1]
288                         simulTimerList = self.session.nav.RecordTimer.record(entry)
289                         if simulTimerList is not None:
290                                 for x in simulTimerList:
291                                         if x.setAutoincreaseEnd(entry):
292                                                 self.session.nav.RecordTimer.timeChanged(x)
293                                 simulTimerList = self.session.nav.RecordTimer.record(entry)
294                                 if simulTimerList is not None:
295                                         self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
296                         self.fillTimerList()
297                         self.updateState()
298                 else:
299                         print "Timeredit aborted"
300
301         def finishSanityCorrection(self, answer):
302                 self.finishedAdd(answer)
303
304         def leave(self):
305                 self.session.nav.RecordTimer.on_state_change.remove(self.onStateChange)
306                 self.close()
307
308         def onStateChange(self, entry):
309                 self.refill()
310                 self.updateState()
311
312 class TimerSanityConflict(Screen):
313         EMPTY = 0
314         ENABLE = 1
315         DISABLE = 2
316         EDIT = 3
317         
318         def __init__(self, session, timer):
319                 Screen.__init__(self, session)
320                 self.timer = timer
321                 print "TimerSanityConflict"
322                         
323                 self["timer1"] = TimerList(self.getTimerList(timer[0]))
324                 self.list = []
325                 self.list2 = []
326                 count = 0
327                 for x in timer:
328                         if count != 0:
329                                 self.list.append((_("Conflicting timer") + " " + str(count), x))
330                                 self.list2.append((timer[count], False))
331                         count += 1
332                 if count == 1:
333                         self.list.append((_("Channel not in services list")))
334
335                 self["list"] = MenuList(self.list)
336                 self["timer2"] = TimerList(self.list2)
337
338                 self["key_red"] = Button("Edit")
339                 self["key_green"] = Button(" ")
340                 self["key_yellow"] = Button(" ")
341                 self["key_blue"] = Button(" ")
342
343                 self.key_green_choice = self.EMPTY
344                 self.key_yellow_choice = self.EMPTY
345                 self.key_blue_choice = self.EMPTY
346
347                 self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"], 
348                         {
349                                 "ok": self.leave_ok,
350                                 "cancel": self.leave_cancel,
351                                 "red": self.editTimer1,
352                                 "up": self.up,
353                                 "down": self.down
354                         }, -1)
355                 self.onShown.append(self.updateState)
356
357         def getTimerList(self, timer):
358                 return [(timer, False)]
359
360         def editTimer1(self):
361                 self.session.openWithCallback(self.finishedEdit, TimerEntry, self["timer1"].getCurrent())
362
363         def toggleTimer1(self):
364                 if self.timer[0].disabled:
365                         self.timer[0].disabled = False
366                 else:
367                         if not self.timer[0].isRunning():
368                                 self.timer[0].disabled = True
369                 self.finishedEdit((True, self.timer[0]))
370         
371         def editTimer2(self):
372                 self.session.openWithCallback(self.finishedEdit, TimerEntry, self["timer2"].getCurrent())
373
374         def toggleTimer2(self):
375                 x = self["list"].getSelectedIndex() + 1 # the first is the new timer so we do +1 here
376                 if self.timer[x].disabled:
377                         self.timer[x].disabled = False
378                 elif not self.timer[x].isRunning():
379                                 self.timer[x].disabled = True
380                 self.finishedEdit((True, self.timer[0]))
381         
382         def finishedEdit(self, answer):
383                 self.leave_ok()
384         
385         def leave_ok(self):
386                 self.close((True, self.timer[0]))
387         
388         def leave_cancel(self):
389                 self.close((False, self.timer[0]))
390
391         def up(self):
392                 self["list"].instance.moveSelection(self["list"].instance.moveUp)
393                 self["timer2"].moveToIndex(self["list"].getSelectedIndex())
394                 
395         def down(self):
396                 self["list"].instance.moveSelection(self["list"].instance.moveDown)
397                 self["timer2"].moveToIndex(self["list"].getSelectedIndex())
398
399         def removeAction(self, descr):
400                 actions = self["actions"].actions
401                 if descr in actions:
402                         del actions[descr]
403
404         def updateState(self):
405                 if self.timer[0] is not None:
406                         if self.timer[0].disabled and self.key_green_choice != self.ENABLE:
407                                 self["actions"].actions.update({"green":self.toggleTimer1})
408                                 self["key_green"].setText(_("Enable"))
409                                 self.key_green_choice = self.ENABLE
410                         elif self.timer[0].isRunning() and not self.timer[0].repeated and self.key_green_choice != self.EMPTY:
411                                 self.removeAction("green")
412                                 self["key_green"].setText(" ")
413                                 self.key_green_choice = self.EMPTY
414                         elif (not self.timer[0].isRunning() or self.timer[0].repeated ) and self.key_green_choice != self.DISABLE:
415                                 self["actions"].actions.update({"green":self.toggleTimer1})
416                                 self["key_green"].setText(_("Disable"))
417                                 self.key_green_choice = self.DISABLE
418                 
419                 if len(self.timer) > 1:
420                         x = self["list"].getSelectedIndex()
421                         if self.timer[x] is not None:
422                                 if self.key_yellow_choice == self.EMPTY:
423                                         self["actions"].actions.update({"yellow":self.editTimer2})
424                                         self["key_yellow"].setText(_("Edit"))
425                                         self.key_yellow_choice = self.EDIT
426                                 if self.timer[x].disabled and self.key_blue_choice != self.ENABLE:
427                                         self["actions"].actions.update({"blue":self.toggleTimer2})
428                                         self["key_blue"].setText(_("Enable"))
429                                         self.key_blue_choice = self.ENABLE
430                                 elif self.timer[x].isRunning() and not self.timer[x].repeated and self.key_blue_choice != self.EMPTY:
431                                         self.removeAction("blue")
432                                         self["key_blue"].setText(" ")
433                                         self.key_blue_choice = self.EMPTY
434                                 elif (not self.timer[x].isRunning() or self.timer[x].repeated ) and self.key_blue_choice != self.DISABLE:
435                                         self["actions"].actions.update({"blue":self.toggleTimer2})
436                                         self["key_blue"].setText(_("Disable"))
437                                         self.key_blue_choice = self.DISABLE
438                 else:
439 #FIXME.... this doesnt hide the buttons self.... just the text
440                         if self.key_yellow_choice != self.EMPTY:
441                                 self.removeAction("yellow")
442                                 self["key_yellow"].setText(" ")
443                                 self.key_yellow_choice = self.EMPTY
444                         if self.key_blue_choice != self.EMPTY:
445                                 self.removeAction("blue")
446                                 self["key_blue"].setText(" ")
447                                 self.key_blue_choice = self.EMPTY