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