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