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