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["actions"].actions.update({"red":self.removeTimerQuestion})
 111                                 self["key_red"].setText(_("Delete"))
 112                                 self["key_red"].instance.invalidate()
 113
 114                         if cur.disabled and (self["key_yellow"].getText()!=(_("Enable"))):
 115                                 self["actions"].actions.update({"yellow":self.toggleDisabledState})
 116                                 self["key_yellow"].setText(_("Enable"))
 117                                 self["key_yellow"].instance.invalidate()
 118                         elif cur.isRunning() and (self["key_yellow"].getText()!=(_(" "))):
 119                                 del self["actions"].actions["yellow"]
 120                                 self["key_yellow"].setText(_(" "))
 121                                 self["key_yellow"].instance.invalidate()
 122                         elif (not cur.isRunning()) and (not cur.disabled) and (self["key_yellow"].getText()!=(_("Disable"))):
 123                                 self["actions"].actions.update({"yellow":self.toggleDisabledState})
 124                                 self["key_yellow"].setText(_("Disable"))
 125                                 self["key_yellow"].instance.invalidate()
 126                 else:
 127                         if self["key_red"].getText()!=(_(" ")):
 128                                 del self["actions"].actions["red"]
 129                                 self["key_red"].setText(_(" "))
 130                                 self["key_red"].instance.invalidate()
 131                         if self["key_yellow"].getText()!=(_(" ")):
 132                                 del self["actions"].actions["yellow"]
 133                                 self["key_yellow"].setText(_(" "))
 134                                 self["key_yellow"].instance.invalidate()
 135
 136                 showCleanup = True
 137                 for x in self.list:
 138                         if (not x[0].disabled) and (x[1] == True):
 139                                 break
 140                 else:
 141                         showCleanup = False
 142
 143                 if showCleanup and (self["key_blue"].getText()!=(_("Cleanup"))):
 144                         self["actions"].actions.update({"blue":self.cleanupQuestion})
 145                         self["key_blue"].setText(_("Cleanup"))
 146                         self["key_blue"].instance.invalidate()
 147                 elif (not showCleanup) and (self["key_blue"].getText()!=(_(" "))):
 148                         del self["actions"].actions["blue"]
 149                         self["key_blue"].setText(_(" "))
 150                         self["key_blue"].instance.invalidate()
 151
 152
 153         def fillTimerList(self):
 154                 del self.list[:]
 155
 156                 for timer in self.session.nav.RecordTimer.timer_list:
 157                         self.list.append((timer, False))
 158
 159                 for timer in self.session.nav.RecordTimer.processed_timers:
 160                         self.list.append((timer, True))
 161                 self.list.sort(cmp = lambda x, y: x[0].begin < y[0].begin)
 162
 163         def showLog(self):
 164                 cur=self["timerlist"].getCurrent()
 165                 if cur:
 166                         self.session.openWithCallback(self.finishedEdit, TimerLog, cur)
 167
 168         def openEdit(self):
 169                 cur=self["timerlist"].getCurrent()
 170                 if cur:
 171                         self.session.openWithCallback(self.finishedEdit, TimerEntry, cur)
 172
 173         def cleanupQuestion(self):
 174                 self.session.openWithCallback(self.cleanupTimer, MessageBox, _("Really delete done timers?"))
 175
 176         def cleanupTimer(self, delete):
 177                 if delete:
 178                         self.session.nav.RecordTimer.cleanup()
 179                         self.refill()
 180                         self.updateState()
 181
 182         def removeTimerQuestion(self):
 183                 if not self["timerlist"].getCurrent():
 184                         return
 185                 self.session.openWithCallback(self.removeTimer, MessageBox, _("Really delete this timer?"))
 186
 187         def removeTimer(self, result):
 188                 if not result:
 189                         return
 190                 list = self["timerlist"]
 191                 cur = list.getCurrent()
 192                 if cur:
 193                         timer = cur
 194                         timer.afterEvent = AFTEREVENT.NONE
 195                         self.session.nav.RecordTimer.removeEntry(timer)
 196                         if not timer.dontSave:
 197                                 for timer in self.session.nav.RecordTimer.timer_list:
 198                                         if timer.dontSave and timer.autoincrease:
 199                                                 timer.end = timer.begin + (3600 * 24 * 356 * 1)
 200                                                 self.session.nav.RecordTimer.timeChanged(timer)
 201                                                 timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list,timer)
 202                                                 if not timersanitycheck.check():
 203                                                         tsc_list = timersanitycheck.getSimulTimerList()
 204                                                         if len(tsc_list) > 1:
 205                                                                 timer.end = tsc_list[1].begin - 30
 206                                                                 self.session.nav.RecordTimer.timeChanged(timer)
 207
 208                         self.refill()
 209                         self.updateState()
 210
 211
 212         def refill(self):
 213                 oldsize = len(self.list)
 214                 self.fillTimerList()
 215                 lst = self["timerlist"]
 216                 newsize = len(self.list)
 217                 if oldsize and oldsize != newsize:
 218                         idx = lst.getCurrentIndex()
 219                         lst.entryRemoved(idx)
 220                 else:
 221                         lst.invalidate()
 222
 223         def addCurrentTimer(self):
 224                 event = None
 225                 service = self.session.nav.getCurrentService()
 226                 if service is not None:
 227                         info = service.info()
 228                         if info is not None:
 229                                 event = info.getEvent(0)
 230
 231                 # FIXME only works if already playing a service
 232                 serviceref = ServiceReference(self.session.nav.getCurrentlyPlayingServiceReference())
 233
 234                 if event is None:
 235                         data = (int(time()), int(time() + 60), "", "", None)
 236                 else:
 237                         data = parseEvent(event, description = False)
 238
 239                 self.addTimer(RecordTimerEntry(serviceref, checkOldTimers = True, dirname = config.movielist.last_timer_videodir.value, *data))
 240
 241         def addTimer(self, timer):
 242                 self.session.openWithCallback(self.finishedAdd, TimerEntry, timer)
 243
 244         def finishedEdit(self, answer):
 245                 print "finished edit"
 246
 247                 if answer[0]:
 248                         print "Edited timer"
 249                         entry = answer[1]
 250                         timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, entry)
 251                         if not timersanitycheck.check():
 252                                 simulTimerList = timersanitycheck.getSimulTimerList()
 253                                 if (len(simulTimerList) == 2) and (simulTimerList[1].dontSave) and (simulTimerList[1].autoincrease):
 254                                         simulTimerList[1].end = entry.begin - 30
 255                                         self.session.nav.RecordTimer.timeChanged(simulTimerList[1])
 256                                         self.session.nav.RecordTimer.timeChanged(entry)
 257                                 else:
 258                                         print "Sanity check failed"
 259                                         self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, timersanitycheck.getSimulTimerList())
 260                         else:
 261                                 print "Sanity check passed"
 262                                 if not timersanitycheck.doubleCheck():
 263                                         self.session.nav.RecordTimer.timeChanged(entry)
 264                         self.fillTimerList()
 265                         self.updateState()
 266                 else:
 267                         print "Timeredit aborted"
 268
 269         def finishedAdd(self, answer):
 270                 print "finished add"
 271                 if answer[0]:
 272                         entry = answer[1]
 273                         simulTimerList = self.session.nav.RecordTimer.record(entry)
 274                         if simulTimerList is not None:
 275                                 if (len(simulTimerList) == 2) and (simulTimerList[1].dontSave) and (simulTimerList[1].autoincrease):
 276                                         simulTimerList[1].end = entry.begin - 30
 277                                         self.session.nav.RecordTimer.timeChanged(simulTimerList[1])
 278                                         self.session.nav.RecordTimer.record(entry)
 279                                 else:
 280                                         self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
 281                         self.fillTimerList()
 282                         self.updateState()
 283                 else:
 284                         print "Timeredit aborted"
 285
 286         def finishSanityCorrection(self, answer):
 287                 self.finishedAdd(answer)
 288
 289         def leave(self):
 290                 self.session.nav.RecordTimer.on_state_change.remove(self.onStateChange)
 291                 self.close()
 292
 293         def onStateChange(self, entry):
 294                 self.refill()
 295                 self.updateState()
 296
 297 class TimerSanityConflict(Screen):
 298         def __init__(self, session, timer):
 299                 Screen.__init__(self, session)
 300                 self.timer = timer
 301                 print "TimerSanityConflict"
 302
 303                 self["timer1"] = TimerList(self.getTimerList(timer[0]))
 304                 self.list = []
 305                 self.list2 = []
 306                 count = 0
 307                 for x in timer:
 308                         if count != 0:
 309                                 self.list.append((_("Conflicting timer") + " " + str(count), x))
 310                                 self.list2.append((timer[count], False))
 311                         count += 1
 312
 313                 self["list"] = MenuList(self.list)
 314                 self["timer2"] = TimerList(self.list2)
 315
 316                 self["key_red"] = Button("Edit")
 317                 self["key_green"] = Button("")
 318                 self["key_yellow"] = Button("Edit")
 319                 self["key_blue"] = Button("")
 320
 321                 self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"],
 322                         {
 323                                 "ok": self.leave_ok,
 324                                 "cancel": self.leave_cancel,
 325                                 "red": self.editTimer1,
 326                                 "green": self.toggleTimer1,
 327                                 "yellow": self.editTimer2,
 328                                 "blue": self.toggleTimer2,
 329                                 #"log": self.showLog,
 330                                 #"left": self.left,
 331                                 #"right": self.right,
 332                                 "up": self.up,
 333                                 "down": self.down
 334                         }, -1)
 335                 self.onShown.append(self.updateState)
 336
 337         def getTimerList(self, timer):
 338                 return [(timer, False)]
 339
 340         def editTimer1(self):
 341                 self.session.openWithCallback(self.finishedEdit, TimerEntry, self["timer1"].getCurrent())
 342
 343         def toggleTimer1(self):
 344                 if self.timer[0].disabled:
 345                         self.timer[0].disabled = False
 346                 else:
 347                         if not self.timer[0].isRunning():
 348                                 self.timer[0].disabled = True
 349                 self.finishedEdit((True, self.timer[0]))
 350
 351         def editTimer2(self):
 352                 self.session.openWithCallback(self.finishedEdit, TimerEntry, self["timer2"].getCurrent())
 353
 354         def toggleTimer2(self):
 355                 x = self["list"].getSelectedIndex() + 1 # the first is the new timer so we do +1 here
 356                 if self.timer[x].disabled:
 357                         self.timer[x].disabled = False
 358                 elif not self.timer[x].isRunning():
 359                                 self.timer[x].disabled = True
 360                 self.finishedEdit((True, self.timer[0]))
 361
 362         def finishedEdit(self, answer):
 363                 self.leave_ok()
 364
 365         def leave_ok(self):
 366                 self.close((True, self.timer[0]))
 367
 368         def leave_cancel(self):
 369                 self.close((False, self.timer[0]))
 370
 371         def up(self):
 372                 self["list"].instance.moveSelection(self["list"].instance.moveUp)
 373                 self["timer2"].moveToIndex(self["list"].getSelectedIndex())
 374
 375         def down(self):
 376                 self["list"].instance.moveSelection(self["list"].instance.moveDown)
 377                 self["timer2"].moveToIndex(self["list"].getSelectedIndex())
 378
 379         def updateState(self):
 380                 if self.timer[0] is not None:
 381                         green_text = self["key_green"].getText()
 382                         if self.timer[0].disabled and green_text != _("Enable"):
 383                                 self["actions"].actions.update({"green":self.toggleTimer1})
 384                                 self["key_green"].setText(_("Enable"))
 385                                 self["key_green"].instance.invalidate()
 386                         elif self.timer[0].isRunning() and green_text != "":
 387                                 del self["actions"].actions["green"]
 388                                 self["key_green"].setText("")
 389                                 self["key_green"].instance.invalidate()
 390                         elif not self.timer[0].disabled and green_text != _("Disable"):
 391                                 self["actions"].actions.update({"green":self.toggleTimer1})
 392                                 self["key_green"].setText(_("Disable"))
 393                                 self["key_green"].instance.invalidate()
 394                 if len(self.timer) > 1:
 395                         x = self["list"].getSelectedIndex()
 396                         if self.timer[x] is not None:
 397                                 blue_text = self["key_blue"].getText()
 398                                 if self.timer[x].disabled and blue_text != _("Enable"):
 399                                         self["actions"].actions.update({"blue":self.toggleTimer2})
 400                                         self["key_blue"].setText(_("Enable"))
 401                                         self["key_blue"].instance.invalidate()
 402                                 elif self.timer[x].isRunning() and blue_text != "":
 403                                         del self["actions"].actions["blue"]
 404                                         self["key_blue"].setText("")
 405                                         self["key_blue"].instance.invalidate()
 406                                 elif not self.timer[x].disabled and blue_text != _("Disable"):
 407                                         self["actions"].actions.update({"blue":self.toggleTimer2})
 408                                         self["key_blue"].setText(_("Disable"))
 409                                         self["key_blue"].instance.invalidate()
 410                 else:
 411 #FIXME.... this doesnt hide the buttons self.... just the text
 412                         del self["actions"].actions["yellow"]
 413                         self["key_yellow"].setText("")
 414                         self["key_yellow"].instance.invalidate()
 415                         del self["actions"].actions["blue"]
 416                         self["key_blue"].setText("")
 417                         self["key_blue"].instance.invalidate()