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