code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Screens/TimerEntry.py

   1 from Screen import Screen
   2 import ChannelSelection
   3 from ServiceReference import ServiceReference
   4 from Components.config import config, ConfigSelection, ConfigText, ConfigSubList, ConfigDateTime, ConfigClock, ConfigYesNo, getConfigListEntry
   5 from Components.ActionMap import NumberActionMap
   6 from Components.ConfigList import ConfigListScreen
   7 from Components.MenuList import MenuList
   8 from Components.Button import Button
   9 from Components.Label import Label
  10 from Components.Pixmap import Pixmap
  11 from Components.SystemInfo import SystemInfo
  12 from Components.UsageConfig import defaultMoviePath
  13 from Components.SystemInfo import SystemInfo
  14 from Screens.MovieSelection import getPreferredTagEditor
  15 from Screens.LocationBox import MovieLocationBox
  16 from Screens.ChoiceBox import ChoiceBox
  17 from RecordTimer import AFTEREVENT
  18 from enigma import eEPGCache
  19 from time import localtime, mktime, time, strftime
  20 from datetime import datetime
  21
  22 class TimerEntry(Screen, ConfigListScreen):
  23         def __init__(self, session, timer):
  24                 Screen.__init__(self, session)
  25                 self.timer = timer
  26
  27                 self.entryDate = None
  28                 self.entryService = None
  29
  30                 self["oktext"] = Label(_("OK"))
  31                 self["canceltext"] = Label(_("Cancel"))
  32                 self["ok"] = Pixmap()
  33                 self["cancel"] = Pixmap()
  34
  35                 self.createConfig()
  36
  37                 self["actions"] = NumberActionMap(["SetupActions", "GlobalActions", "PiPSetupActions"],
  38                 {
  39                         "ok": self.keySelect,
  40                         "save": self.keyGo,
  41                         "cancel": self.keyCancel,
  42                         "volumeUp": self.incrementStart,
  43                         "volumeDown": self.decrementStart,
  44                         "size+": self.incrementEnd,
  45                         "size-": self.decrementEnd
  46                 }, -2)
  47
  48                 self.list = []
  49                 ConfigListScreen.__init__(self, self.list, session = session)
  50                 self.createSetup("config")
  51
  52         def createConfig(self):
  53                         justplay = self.timer.justplay
  54
  55                         afterevent = {
  56                                 AFTEREVENT.NONE: "nothing",
  57                                 AFTEREVENT.DEEPSTANDBY: "deepstandby",
  58                                 AFTEREVENT.STANDBY: "standby",
  59                                 AFTEREVENT.AUTO: "auto"
  60                                 }[self.timer.afterEvent]
  61
  62                         weekday_table = ("mon", "tue", "wed", "thu", "fri", "sat", "sun")
  63
  64                         # calculate default values
  65                         day = []
  66                         weekday = 0
  67                         for x in (0, 1, 2, 3, 4, 5, 6):
  68                                 day.append(0)
  69                         if self.timer.repeated: # repeated
  70                                 type = "repeated"
  71                                 if (self.timer.repeated == 31): # Mon-Fri
  72                                         repeated = "weekdays"
  73                                 elif (self.timer.repeated == 127): # daily
  74                                         repeated = "daily"
  75                                 else:
  76                                         flags = self.timer.repeated
  77                                         repeated = "user"
  78                                         count = 0
  79                                         for x in (0, 1, 2, 3, 4, 5, 6):
  80                                                 if flags == 1: # weekly
  81                                                         print "Set to weekday " + str(x)
  82                                                         weekday = x
  83                                                 if flags & 1 == 1: # set user defined flags
  84                                                         day[x] = 1
  85                                                         count += 1
  86                                                 else:
  87                                                         day[x] = 0
  88                                                 flags = flags >> 1
  89                                         if count == 1:
  90                                                 repeated = "weekly"
  91                         else: # once
  92                                 type = "once"
  93                                 repeated = None
  94                                 weekday = (int(strftime("%w", localtime(self.timer.begin))) - 1) % 7
  95                                 day[weekday] = 1
  96
  97                         self.timerentry_justplay = ConfigSelection(choices = [("zap", _("zap")), ("record", _("record"))], default = {0: "record", 1: "zap"}[justplay])
  98                         if SystemInfo["DeepstandbySupport"]:
  99                                 shutdownString = _("go to deep standby")
 100                         else:
 101                                 shutdownString = _("shut down")
 102                         self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")), ("standby", _("go to standby")), ("deepstandby", shutdownString), ("auto", _("auto"))], default = afterevent)
 103                         self.timerentry_type = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = type)
 104                         self.timerentry_name = ConfigText(default = self.timer.name, visible_width = 50, fixed_size = False)
 105                         self.timerentry_description = ConfigText(default = self.timer.description, visible_width = 50, fixed_size = False)
 106                         self.timerentry_tags = self.timer.tags[:]
 107                         self.timerentry_tagsset = ConfigSelection(choices = [not self.timerentry_tags and "None" or " ".join(self.timerentry_tags)])
 108
 109                         self.timerentry_repeated = ConfigSelection(default = repeated, choices = [("daily", _("daily")), ("weekly", _("weekly")), ("weekdays", _("Mon-Fri")), ("user", _("user defined"))])
 110
 111                         self.timerentry_date = ConfigDateTime(default = self.timer.begin, formatstring = _("%d.%B %Y"), increment = 86400)
 112                         self.timerentry_starttime = ConfigClock(default = self.timer.begin)
 113                         self.timerentry_endtime = ConfigClock(default = self.timer.end)
 114
 115                         default = self.timer.dirname or defaultMoviePath()
 116                         tmp = config.movielist.videodirs.value
 117                         if default not in tmp:
 118                                 tmp.append(default)
 119                         self.timerentry_dirname = ConfigSelection(default = default, choices = tmp)
 120
 121                         self.timerentry_repeatedbegindate = ConfigDateTime(default = self.timer.repeatedbegindate, formatstring = _("%d.%B %Y"), increment = 86400)
 122
 123                         self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))])
 124
 125                         self.timerentry_day = ConfigSubList()
 126                         for x in (0, 1, 2, 3, 4, 5, 6):
 127                                 self.timerentry_day.append(ConfigYesNo(default = day[x]))
 128
 129                         # FIXME some service-chooser needed here
 130                         servicename = "N/A"
 131                         try: # no current service available?
 132                                 servicename = str(self.timer.service_ref.getServiceName())
 133                         except:
 134                                 pass
 135                         self.timerentry_service_ref = self.timer.service_ref
 136                         self.timerentry_service = ConfigSelection([servicename])
 137
 138         def createSetup(self, widget):
 139                 self.list = []
 140                 self.list.append(getConfigListEntry(_("Name"), self.timerentry_name))
 141                 self.list.append(getConfigListEntry(_("Description"), self.timerentry_description))
 142                 self.timerJustplayEntry = getConfigListEntry(_("Timer Type"), self.timerentry_justplay)
 143                 self.list.append(self.timerJustplayEntry)
 144                 self.timerTypeEntry = getConfigListEntry(_("Repeat Type"), self.timerentry_type)
 145                 self.list.append(self.timerTypeEntry)
 146
 147                 if self.timerentry_type.value == "once":
 148                         self.frequencyEntry = None
 149                 else: # repeated
 150                         self.frequencyEntry = getConfigListEntry(_("Repeats"), self.timerentry_repeated)
 151                         self.list.append(self.frequencyEntry)
 152                         self.repeatedbegindateEntry = getConfigListEntry(_("Starting on"), self.timerentry_repeatedbegindate)
 153                         self.list.append(self.repeatedbegindateEntry)
 154                         if self.timerentry_repeated.value == "daily":
 155                                 pass
 156                         if self.timerentry_repeated.value == "weekdays":
 157                                 pass
 158                         if self.timerentry_repeated.value == "weekly":
 159                                 self.list.append(getConfigListEntry(_("Weekday"), self.timerentry_weekday))
 160
 161                         if self.timerentry_repeated.value == "user":
 162                                 self.list.append(getConfigListEntry(_("Monday"), self.timerentry_day[0]))
 163                                 self.list.append(getConfigListEntry(_("Tuesday"), self.timerentry_day[1]))
 164                                 self.list.append(getConfigListEntry(_("Wednesday"), self.timerentry_day[2]))
 165                                 self.list.append(getConfigListEntry(_("Thursday"), self.timerentry_day[3]))
 166                                 self.list.append(getConfigListEntry(_("Friday"), self.timerentry_day[4]))
 167                                 self.list.append(getConfigListEntry(_("Saturday"), self.timerentry_day[5]))
 168                                 self.list.append(getConfigListEntry(_("Sunday"), self.timerentry_day[6]))
 169
 170                 self.entryDate = getConfigListEntry(_("Date"), self.timerentry_date)
 171                 if self.timerentry_type.value == "once":
 172                         self.list.append(self.entryDate)
 173
 174                 self.entryStartTime = getConfigListEntry(_("StartTime"), self.timerentry_starttime)
 175                 self.list.append(self.entryStartTime)
 176                 if self.timerentry_justplay.value != "zap":
 177                         self.entryEndTime = getConfigListEntry(_("EndTime"), self.timerentry_endtime)
 178                         self.list.append(self.entryEndTime)
 179                 else:
 180                         self.entryEndTime = None
 181                 self.channelEntry = getConfigListEntry(_("Channel"), self.timerentry_service)
 182                 self.list.append(self.channelEntry)
 183
 184                 self.dirname = getConfigListEntry(_("Location"), self.timerentry_dirname)
 185                 self.tagsSet = getConfigListEntry(_("Tags"), self.timerentry_tagsset)
 186                 if self.timerentry_justplay.value != "zap":
 187                         if config.usage.setup_level.index >= 2: # expert+
 188                                 self.list.append(self.dirname)
 189                         if getPreferredTagEditor():
 190                                 self.list.append(self.tagsSet)
 191                         self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent))
 192
 193                 self[widget].list = self.list
 194                 self[widget].l.setList(self.list)
 195
 196         def newConfig(self):
 197                 print "newConfig", self["config"].getCurrent()
 198                 if self["config"].getCurrent() == self.timerTypeEntry:
 199                         self.createSetup("config")
 200                 if self["config"].getCurrent() == self.timerJustplayEntry:
 201                         self.createSetup("config")
 202                 if self["config"].getCurrent() == self.frequencyEntry:
 203                         self.createSetup("config")
 204
 205         def keyLeft(self):
 206                 if self["config"].getCurrent() in (self.channelEntry, self.tagsSet):
 207                         self.keySelect()
 208                 else:
 209                         ConfigListScreen.keyLeft(self)
 210                         self.newConfig()
 211
 212         def keyRight(self):
 213                 if self["config"].getCurrent() in (self.channelEntry, self.tagsSet):
 214                         self.keySelect()
 215                 else:
 216                         ConfigListScreen.keyRight(self)
 217                         self.newConfig()
 218
 219         def keySelect(self):
 220                 cur = self["config"].getCurrent()
 221                 if cur == self.channelEntry:
 222                         self.session.openWithCallback(
 223                                 self.finishedChannelSelection,
 224                                 ChannelSelection.SimpleChannelSelection,
 225                                 _("Select channel to record from")
 226                         )
 227                 elif config.usage.setup_level.index >= 2 and cur == self.dirname:
 228                         self.session.openWithCallback(
 229                                 self.pathSelected,
 230                                 MovieLocationBox,
 231                                 _("Choose target folder"),
 232                                 self.timerentry_dirname.value,
 233                                 minFree = 100 # We require at least 100MB free space
 234                         )
 235                 elif getPreferredTagEditor() and cur == self.tagsSet:
 236                         self.session.openWithCallback(
 237                                 self.tagEditFinished,
 238                                 getPreferredTagEditor(),
 239                                 self.timerentry_tags
 240                         )
 241                 else:
 242                         self.keyGo()
 243
 244         def finishedChannelSelection(self, *args):
 245                 if args:
 246                         self.timerentry_service_ref = ServiceReference(args[0])
 247                         self.timerentry_service.setCurrentText(self.timerentry_service_ref.getServiceName())
 248                         self["config"].invalidate(self.channelEntry)
 249
 250         def getTimestamp(self, date, mytime):
 251                 d = localtime(date)
 252                 dt = datetime(d.tm_year, d.tm_mon, d.tm_mday, mytime[0], mytime[1])
 253                 return int(mktime(dt.timetuple()))
 254
 255         def getBeginEnd(self):
 256                 date = self.timerentry_date.value
 257                 endtime = self.timerentry_endtime.value
 258                 starttime = self.timerentry_starttime.value
 259
 260                 begin = self.getTimestamp(date, starttime)
 261                 end = self.getTimestamp(date, endtime)
 262
 263                 # if the endtime is less than the starttime, add 1 day.
 264                 if end < begin:
 265                         end += 86400
 266                 return begin, end
 267
 268         def keyGo(self):
 269                 self.timer.name = self.timerentry_name.value
 270                 self.timer.description = self.timerentry_description.value
 271                 self.timer.justplay = self.timerentry_justplay.value == "zap"
 272                 self.timer.resetRepeated()
 273                 self.timer.afterEvent = {
 274                         "nothing": AFTEREVENT.NONE,
 275                         "deepstandby": AFTEREVENT.DEEPSTANDBY,
 276                         "standby": AFTEREVENT.STANDBY,
 277                         "auto": AFTEREVENT.AUTO
 278                         }[self.timerentry_afterevent.value]
 279                 self.timer.service_ref = self.timerentry_service_ref
 280                 self.timer.tags = self.timerentry_tags
 281
 282                 if self.timer.dirname or self.timerentry_dirname.value != defaultMoviePath():
 283                         self.timer.dirname = self.timerentry_dirname.value
 284                         config.movielist.last_timer_videodir.value = self.timer.dirname
 285                         config.movielist.last_timer_videodir.save()
 286
 287                 if self.timerentry_type.value == "once":
 288                         self.timer.begin, self.timer.end = self.getBeginEnd()
 289                 if self.timerentry_type.value == "repeated":
 290                         if self.timerentry_repeated.value == "daily":
 291                                 for x in (0, 1, 2, 3, 4, 5, 6):
 292                                         self.timer.setRepeated(x)
 293
 294                         if self.timerentry_repeated.value == "weekly":
 295                                 self.timer.setRepeated(self.timerentry_weekday.index)
 296
 297                         if self.timerentry_repeated.value == "weekdays":
 298                                 for x in (0, 1, 2, 3, 4):
 299                                         self.timer.setRepeated(x)
 300
 301                         if self.timerentry_repeated.value == "user":
 302                                 for x in (0, 1, 2, 3, 4, 5, 6):
 303                                         if self.timerentry_day[x].value:
 304                                                 self.timer.setRepeated(x)
 305
 306                         self.timer.repeatedbegindate = self.getTimestamp(self.timerentry_repeatedbegindate.value, self.timerentry_starttime.value)
 307                         if self.timer.repeated:
 308                                 self.timer.begin = self.getTimestamp(self.timerentry_repeatedbegindate.value, self.timerentry_starttime.value)
 309                                 self.timer.end = self.getTimestamp(self.timerentry_repeatedbegindate.value, self.timerentry_endtime.value)
 310                         else:
 311                                 self.timer.begin = self.getTimestamp(time.time(), self.timerentry_starttime.value)
 312                                 self.timer.end = self.getTimestamp(time.time(), self.timerentry_endtime.value)
 313
 314                         # when a timer end is set before the start, add 1 day
 315                         if self.timer.end < self.timer.begin:
 316                                 self.timer.end += 86400
 317
 318                 if self.timer.eit is not None:
 319                         event = eEPGCache.getInstance().lookupEventId(self.timer.service_ref.ref, self.timer.eit)
 320                         if event:
 321                                 n = event.getNumOfLinkageServices()
 322                                 if n > 1:
 323                                         tlist = []
 324                                         ref = self.session.nav.getCurrentlyPlayingServiceReference()
 325                                         parent = self.timer.service_ref.ref
 326                                         selection = 0
 327                                         for x in range(n):
 328                                                 i = event.getLinkageService(parent, x)
 329                                                 if i.toString() == ref.toString():
 330                                                         selection = x
 331                                                 tlist.append((i.getName(), i))
 332                                         self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice to record..."), list = tlist, selection = selection)
 333                                         return
 334                                 elif n > 0:
 335                                         parent = self.timer.service_ref.ref
 336                                         self.timer.service_ref = ServiceReference(event.getLinkageService(parent, 0))
 337                 self.saveTimer()
 338                 self.close((True, self.timer))
 339
 340         def incrementStart(self):
 341                 self.timerentry_starttime.increment()
 342                 self["config"].invalidate(self.entryStartTime)
 343
 344         def decrementStart(self):
 345                 self.timerentry_starttime.decrement()
 346                 self["config"].invalidate(self.entryStartTime)
 347
 348         def incrementEnd(self):
 349                 if self.entryEndTime is not None:
 350                         self.timerentry_endtime.increment()
 351                         self["config"].invalidate(self.entryEndTime)
 352
 353         def decrementEnd(self):
 354                 if self.entryEndTime is not None:
 355                         self.timerentry_endtime.decrement()
 356                         self["config"].invalidate(self.entryEndTime)
 357
 358         def subserviceSelected(self, service):
 359                 if not service is None:
 360                         self.timer.service_ref = ServiceReference(service[1])
 361                 self.saveTimer()
 362                 self.close((True, self.timer))
 363
 364         def saveTimer(self):
 365                 self.session.nav.RecordTimer.saveTimer()
 366
 367         def keyCancel(self):
 368                 self.close((False,))
 369
 370         def pathSelected(self, res):
 371                 if res is not None:
 372                         if config.movielist.videodirs.value != self.timerentry_dirname.choices:
 373                                 self.timerentry_dirname.setChoices(config.movielist.videodirs.value, default=res)
 374                         self.timerentry_dirname.value = res
 375
 376         def tagEditFinished(self, ret):
 377                 if ret is not None:
 378                         self.timerentry_tags = ret
 379                         self.timerentry_tagsset.setChoices([not ret and "None" or " ".join(ret)])
 380                         self["config"].invalidate(self.tagsSet)
 381
 382 class TimerLog(Screen):
 383         def __init__(self, session, timer):
 384                 Screen.__init__(self, session)
 385                 self.timer = timer;
 386                 self.log_entries = self.timer.log_entries[:]
 387
 388                 self.fillLogList()
 389
 390                 self["loglist"] = MenuList(self.list)
 391                 self["logentry"] = Label()
 392
 393                 self["key_red"] = Button(_("Delete entry"))
 394                 self["key_green"] = Button()
 395                 self["key_yellow"] = Button("")
 396                 self["key_blue"] = Button(_("Clear log"))
 397
 398                 self.onShown.append(self.updateText)
 399
 400                 self["actions"] = NumberActionMap(["OkCancelActions", "DirectionActions", "ColorActions"],
 401                 {
 402                         "ok": self.keyClose,
 403                         "cancel": self.keyClose,
 404                         "up": self.up,
 405                         "down": self.down,
 406                         "left": self.left,
 407                         "right": self.right,
 408                         "red": self.deleteEntry,
 409                         "blue": self.clearLog
 410                 }, -1)
 411
 412         def deleteEntry(self):
 413                 cur = self["loglist"].getCurrent()
 414                 if cur is None:
 415                         return
 416                 self.log_entries.remove(cur[1])
 417                 self.fillLogList()
 418                 self["loglist"].l.setList(self.list)
 419                 self.updateText()
 420
 421         def fillLogList(self):
 422                 self.list = [(str(strftime("%Y-%m-%d %H-%M", localtime(x[0])) + " - " + x[2]), x) for x in self.log_entries]
 423
 424         def clearLog(self):
 425                 self.log_entries = []
 426                 self.fillLogList()
 427                 self["loglist"].l.setList(self.list)
 428                 self.updateText()
 429
 430         def keyClose(self):
 431                 if self.timer.log_entries != self.log_entries:
 432                         self.timer.log_entries = self.log_entries
 433                         self.close((True, self.timer))
 434                 else:
 435                         self.close((False,))
 436
 437         def up(self):
 438                 self["loglist"].instance.moveSelection(self["loglist"].instance.moveUp)
 439                 self.updateText()
 440
 441         def down(self):
 442                 self["loglist"].instance.moveSelection(self["loglist"].instance.moveDown)
 443                 self.updateText()
 444
 445         def left(self):
 446                 self["loglist"].instance.moveSelection(self["loglist"].instance.pageUp)
 447                 self.updateText()
 448
 449         def right(self):
 450                 self["loglist"].instance.moveSelection(self["loglist"].instance.pageDown)
 451                 self.updateText()
 452
 453         def updateText(self):
 454                 if self.list:
 455                         self["logentry"].setText(str(self["loglist"].getCurrent()[1][2]))
 456                 else:
 457                         self["logentry"].setText("")