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