add timeroverlap detection made by adenin (thanks for the great work!)
[enigma2.git] / lib / python / Plugins / Extensions / GraphMultiEPG / GraphMultiEpg.py
1 from skin import parseColor
2 from Components.config import config, ConfigClock, ConfigInteger
3 from Components.Pixmap import Pixmap
4 from Components.Button import Button
5 from Components.ActionMap import ActionMap
6 from Components.HTMLComponent import HTMLComponent
7 from Components.GUIComponent import GUIComponent
8 from Components.EpgList import Rect
9 from Components.Sources.Event import Event
10 from Components.MultiContent import MultiContentEntryText, MultiContentEntryPixmapAlphaTest
11 from Components.TimerList import TimerList
12 from Screens.Screen import Screen
13 from Screens.EventView import EventViewSimple
14 from Screens.TimeDateInput import TimeDateInput
15 from Screens.TimerEntry import TimerEntry
16 from Screens.EpgSelection import EPGSelection
17 from Screens.TimerEdit import TimerSanityConflict
18 from Tools.Directories import resolveFilename, SCOPE_SKIN_IMAGE
19 from RecordTimer import RecordTimerEntry, parseEvent
20 from ServiceReference import ServiceReference
21 from Tools.LoadPixmap import LoadPixmap
22 from enigma import eEPGCache, eListbox, gFont, eListboxPythonMultiContent, \
23         RT_HALIGN_LEFT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, RT_WRAP, eRect, eTimer
24
25 from time import localtime, time, strftime
26
27 class EPGList(HTMLComponent, GUIComponent):
28         def __init__(self, selChangedCB=None, timer = None, time_epoch = 120, overjump_empty=True):
29                 self.cur_event = None
30                 self.cur_service = None
31                 self.offs = 0
32                 self.timer = timer
33                 self.onSelChanged = [ ]
34                 if selChangedCB is not None:
35                         self.onSelChanged.append(selChangedCB)
36                 GUIComponent.__init__(self)
37                 self.l = eListboxPythonMultiContent()
38                 self.l.setItemHeight(54);
39                 self.l.setBuildFunc(self.buildEntry)
40                 if overjump_empty:
41                         self.l.setSelectableFunc(self.isSelectable)
42                 self.epgcache = eEPGCache.getInstance()
43                 self.clock_pixmap = LoadPixmap(resolveFilename(SCOPE_SKIN_IMAGE, 'skin_default/icons/epgclock.png'))
44                 self.time_base = None
45                 self.time_epoch = time_epoch
46                 self.list = None
47                 self.event_rect = None
48
49                 self.foreColor = None
50                 self.foreColorSelected = None
51                 self.borderColor = None
52                 self.backColor = 0x586d88
53                 self.backColorSelected = 0x808080
54                 self.foreColorService = None
55                 self.backColorService = None
56
57         def applySkin(self, desktop, screen):
58                 if self.skinAttributes is not None:
59                         attribs = [ ]
60                         for (attrib, value) in self.skinAttributes:
61                                 if attrib == "EntryForegroundColor":
62                                         self.foreColor = parseColor(value).argb()
63                                 elif attrib == "EntryForegroundColorSelected":
64                                         self.foreColorSelected = parseColor(value).argb()
65                                 elif attrib == "EntryBorderColor":
66                                         self.borderColor = parseColor(value).argb()
67                                 elif attrib == "EntryBackgroundColor":
68                                         self.backColor = parseColor(value).argb()
69                                 elif attrib == "EntryBackgroundColorSelected":
70                                         self.backColorSelected = parseColor(value).argb()
71                                 elif attrib == "ServiceNameForegroundColor":
72                                         self.foreColorService = parseColor(value).argb()
73                                 elif attrib == "ServiceNameBackgroundColor":
74                                         self.backColorService = parseColor(value).argb()
75                                 else:
76                                         attribs.append((attrib,value))
77                         self.skinAttributes = attribs
78                 return GUIComponent.applySkin(self, desktop, screen)
79
80         def isSelectable(self, service, sname, event_list):
81                 return (event_list and len(event_list) and True) or False
82
83         def setEpoch(self, epoch):
84                 if self.cur_event is not None and self.cur_service is not None:
85                         self.offs = 0
86                         self.time_epoch = epoch
87                         self.fillMultiEPG(None) # refill
88
89         def getEventFromId(self, service, eventid):
90                 event = None
91                 if self.epgcache is not None and eventid is not None:
92                         event = self.epgcache.lookupEventId(service.ref, eventid)
93                 return event
94
95         def getCurrent(self):
96                 if self.cur_service is None or self.cur_event is None:
97                         return ( None, None )
98                 old_service = self.cur_service  #(service, service_name, events)
99                 events = self.cur_service[2]
100                 refstr = self.cur_service[0]
101                 if not events or not len(events):
102                         return ( None, None )
103                 event = events[self.cur_event] #(event_id, event_title, begin_time, duration)
104                 eventid = event[0]
105                 service = ServiceReference(refstr)
106                 event = self.getEventFromId(service, eventid)
107                 return ( event, service )
108
109         def connectSelectionChanged(func):
110                 if not self.onSelChanged.count(func):
111                         self.onSelChanged.append(func)
112
113         def disconnectSelectionChanged(func):
114                 self.onSelChanged.remove(func)
115
116         def serviceChanged(self):
117                 cur_sel = self.l.getCurrentSelection()
118                 if cur_sel:
119                         self.findBestEvent()
120
121         def findBestEvent(self):
122                 old_service = self.cur_service  #(service, service_name, events)
123                 cur_service = self.cur_service = self.l.getCurrentSelection()
124                 last_time = 0;
125                 time_base = self.getTimeBase()
126                 if old_service and self.cur_event is not None:
127                         events = old_service[2]
128                         cur_event = events[self.cur_event] #(event_id, event_title, begin_time, duration)
129                         last_time = cur_event[2]
130                         if last_time < time_base:
131                                 last_time = time_base
132                 if cur_service:
133                         self.cur_event = 0
134                         events = cur_service[2]
135                         if events and len(events):
136                                 if last_time:
137                                         best_diff = 0
138                                         best = len(events) #set invalid
139                                         idx = 0
140                                         for event in events: #iterate all events
141                                                 ev_time = event[2]
142                                                 if ev_time < time_base:
143                                                         ev_time = time_base
144                                                 diff = abs(ev_time-last_time)
145                                                 if (best == len(events)) or (diff < best_diff):
146                                                         best = idx
147                                                         best_diff = diff
148                                                 idx += 1
149                                         if best != len(events):
150                                                 self.cur_event = best
151                         else:
152                                 self.cur_event = None
153                 self.selEntry(0)
154
155         def selectionChanged(self):
156                 for x in self.onSelChanged:
157                         if x is not None:
158                                 try:
159                                         x()
160                                 except: # FIXME!!!
161                                         print "FIXME in EPGList.selectionChanged"
162                                         pass
163
164         GUI_WIDGET = eListbox
165
166         def postWidgetCreate(self, instance):
167                 instance.setWrapAround(True)
168                 instance.selectionChanged.get().append(self.serviceChanged)
169                 instance.setContent(self.l)
170                 self.l.setFont(0, gFont("Regular", 20))
171                 self.l.setFont(1, gFont("Regular", 14))
172                 self.l.setSelectionClip(eRect(0,0,0,0), False)
173
174         def preWidgetRemove(self, instance):
175                 instance.selectionChanged.get().remove(self.serviceChanged)
176                 instance.setContent(None)
177
178         def recalcEntrySize(self):
179                 esize = self.l.getItemSize()
180                 width = esize.width()
181                 height = esize.height()
182                 xpos = 0;
183                 w = width/10*2;
184                 self.service_rect = Rect(xpos, 0, w-10, height)
185                 xpos += w;
186                 w = width/10*8;
187                 self.event_rect = Rect(xpos, 0, w, height)
188
189         def calcEntryPosAndWidthHelper(self, stime, duration, start, end, width):
190                 xpos = (stime - start) * width / (end - start)
191                 ewidth = (stime + duration - start) * width / (end - start)
192                 ewidth -= xpos;
193                 if xpos < 0:
194                         ewidth += xpos;
195                         xpos = 0;
196                 if (xpos+ewidth) > width:
197                         ewidth = width - xpos
198                 return xpos, ewidth
199
200         def calcEntryPosAndWidth(self, event_rect, time_base, time_epoch, ev_start, ev_duration):
201                 xpos, width = self.calcEntryPosAndWidthHelper(ev_start, ev_duration, time_base, time_base + time_epoch * 60, event_rect.width())
202                 return xpos+event_rect.left(), width
203
204         def buildEntry(self, service, service_name, events):
205                 r1=self.service_rect
206                 r2=self.event_rect
207                 res = [ None, MultiContentEntryText(pos = (r1.left(),r1.top()), size = (r1.width(), r1.height()), font = 0, flags = RT_HALIGN_LEFT | RT_VALIGN_CENTER, text = service_name, color = self.foreColorService, backcolor = self.backColorService) ]
208
209                 if events:
210                         start = self.time_base+self.offs*self.time_epoch*60
211                         end = start + self.time_epoch * 60
212                         left = r2.left()
213                         top = r2.top()
214                         width = r2.width()
215                         height = r2.height()
216                         foreColor = self.foreColor
217                         foreColorSelected = self.foreColorSelected
218                         backColor = self.backColor
219                         backColorSelected = self.backColorSelected
220                         borderColor = self.borderColor
221
222                         for ev in events:  #(event_id, event_title, begin_time, duration)
223                                 rec=ev[2] and self.timer.isInTimer(ev[0], ev[2], ev[3], service) > ((ev[3]/10)*8)
224                                 xpos, ewidth = self.calcEntryPosAndWidthHelper(ev[2], ev[3], start, end, width)
225                                 res.append(MultiContentEntryText(pos = (left+xpos, top), size = (ewidth, height), font = 1, flags = RT_HALIGN_CENTER | RT_VALIGN_CENTER | RT_WRAP, text = ev[1], color = foreColor, color_sel = foreColorSelected, backcolor = backColor, backcolor_sel = backColorSelected, border_width = 1, border_color = borderColor))
226                                 if rec and ewidth > 23:
227                                         res.append(MultiContentEntryPixmapAlphaTest(pos = (left+xpos+ewidth-22, top+height-22), size = (21, 21), png = self.clock_pixmap, backcolor = backColor, backcolor_sel = backColorSelected))
228                 return res
229
230         def selEntry(self, dir, visible=True):
231                 cur_service = self.cur_service #(service, service_name, events)
232                 self.recalcEntrySize()
233                 valid_event = self.cur_event is not None
234                 if cur_service:
235                         update = True
236                         entries = cur_service[2]
237                         if dir == 0: #current
238                                 update = False
239                         elif dir == +1: #next
240                                 if valid_event and self.cur_event+1 < len(entries):
241                                         self.cur_event+=1
242                                 else:
243                                         self.offs += 1
244                                         self.fillMultiEPG(None) # refill
245                                         return True
246                         elif dir == -1: #prev
247                                 if valid_event and self.cur_event-1 >= 0:
248                                         self.cur_event-=1
249                                 elif self.offs > 0:
250                                         self.offs -= 1
251                                         self.fillMultiEPG(None) # refill
252                                         return True
253                 if cur_service and valid_event:
254                         entry = entries[self.cur_event] #(event_id, event_title, begin_time, duration)
255                         time_base = self.time_base+self.offs*self.time_epoch*60
256                         xpos, width = self.calcEntryPosAndWidth(self.event_rect, time_base, self.time_epoch, entry[2], entry[3])
257                         self.l.setSelectionClip(eRect(xpos, 0, width, self.event_rect.height()), visible and update)
258                 else:
259                         self.l.setSelectionClip(eRect(self.event_rect.left(), self.event_rect.top(), self.event_rect.width(), self.event_rect.height()), False)
260                 self.selectionChanged()
261                 return False
262
263         def queryEPG(self, list, buildFunc=None):
264                 if self.epgcache is not None:
265                         if buildFunc is not None:
266                                 return self.epgcache.lookupEvent(list, buildFunc)
267                         else:
268                                 return self.epgcache.lookupEvent(list)
269                 return [ ]
270
271         def fillMultiEPG(self, services, stime=-1):
272                 if services is None:
273                         time_base = self.time_base+self.offs*self.time_epoch*60
274                         test = [ (service[0], 0, time_base, self.time_epoch) for service in self.list ]
275                 else:
276                         self.cur_event = None
277                         self.cur_service = None
278                         self.time_base = int(stime)
279                         test = [ (service.ref.toString(), 0, self.time_base, self.time_epoch) for service in services ]
280                 test.insert(0, 'XRnITBD')
281                 epg_data = self.queryEPG(test)
282
283                 self.list = [ ]
284                 tmp_list = None
285                 service = ""
286                 sname = ""
287                 for x in epg_data:
288                         if service != x[0]:
289                                 if tmp_list is not None:
290                                         self.list.append((service, sname, tmp_list[0][0] is not None and tmp_list or None))
291                                 service = x[0]
292                                 sname = x[1]
293                                 tmp_list = [ ]
294                         tmp_list.append((x[2], x[3], x[4], x[5]))
295                 if tmp_list and len(tmp_list):
296                         self.list.append((service, sname, tmp_list[0][0] is not None and tmp_list or None))
297
298                 self.l.setList(self.list)
299                 self.findBestEvent()
300
301         def getEventRect(self):
302                 rc = self.event_rect
303                 return Rect( rc.left() + (self.instance and self.instance.position().x() or 0), rc.top(), rc.width(), rc.height() )
304
305         def getTimeEpoch(self):
306                 return self.time_epoch
307
308         def getTimeBase(self):
309                 return self.time_base + (self.offs * self.time_epoch * 60)
310
311         def resetOffset(self):
312                 self.offs = 0
313
314 class TimelineText(HTMLComponent, GUIComponent):
315         def __init__(self):
316                 GUIComponent.__init__(self)
317                 self.l = eListboxPythonMultiContent()
318                 self.l.setSelectionClip(eRect(0,0,0,0))
319                 self.l.setItemHeight(25);
320                 self.l.setFont(0, gFont("Regular", 20))
321
322         GUI_WIDGET = eListbox
323
324         def postWidgetCreate(self, instance):
325                 instance.setContent(self.l)
326
327         def setEntries(self, entries):
328                 res = [ None ] # no private data needed
329                 for x in entries:
330                         tm = x[0]
331                         xpos = x[1]
332                         str = strftime("%H:%M", localtime(tm))
333                         res.append((eListboxPythonMultiContent.TYPE_TEXT, xpos-30, 0, 60, 25, 0, RT_HALIGN_CENTER|RT_VALIGN_CENTER, str))
334                 self.l.setList([res])
335
336 config.misc.graph_mepg_prev_time=ConfigClock(default = time())
337 config.misc.graph_mepg_prev_time_period=ConfigInteger(default=120, limits=(60,300))
338
339 class GraphMultiEPG(Screen):
340         def __init__(self, session, services, zapFunc=None, bouquetChangeCB=None):
341                 Screen.__init__(self, session)
342                 self.bouquetChangeCB = bouquetChangeCB
343                 now = time()
344                 tmp = now % 900
345                 self.ask_time = now - tmp
346                 self.closeRecursive = False
347                 self["key_red"] = Button("")
348                 self["key_green"] = Button(_("Add timer"))
349                 self["timeline_text"] = TimelineText()
350                 self["Event"] = Event()
351                 self.time_lines = [ ]
352                 for x in (0,1,2,3,4,5):
353                         pm = Pixmap()
354                         self.time_lines.append(pm)
355                         self["timeline%d"%(x)] = pm
356                 self["timeline_now"] = Pixmap()
357                 self.services = services
358                 self.zapFunc = zapFunc
359
360                 self["list"] = EPGList(selChangedCB = self.onSelectionChanged, timer = self.session.nav.RecordTimer, time_epoch = config.misc.graph_mepg_prev_time_period.value )
361
362                 self["actions"] = ActionMap(["EPGSelectActions", "OkCancelActions"],
363                         {
364                                 "cancel": self.closeScreen,
365                                 "ok": self.eventSelected,
366                                 "timerAdd": self.timerAdd,
367                                 "info": self.infoKeyPressed,
368                                 "red": self.zapTo,
369                                 "input_date_time": self.enterDateTime,
370                                 "nextBouquet": self.nextBouquet,
371                                 "prevBouquet": self.prevBouquet,
372                         })
373                 self["actions"].csel = self
374
375                 self["input_actions"] = ActionMap(["InputActions"],
376                         {
377                                 "left": self.leftPressed,
378                                 "right": self.rightPressed,
379                                 "1": self.key1,
380                                 "2": self.key2,
381                                 "3": self.key3,
382                                 "4": self.key4,
383                                 "5": self.key5,
384                         },-1)
385
386                 self.updateTimelineTimer = eTimer()
387                 self.updateTimelineTimer.callback.append(self.moveTimeLines)
388                 self.updateTimelineTimer.start(60*1000)
389                 self.onLayoutFinish.append(self.onCreate)
390
391         def leftPressed(self):
392                 self.prevEvent()
393
394         def rightPressed(self):
395                 self.nextEvent()
396
397         def nextEvent(self, visible=True):
398                 ret = self["list"].selEntry(+1, visible)
399                 if ret:
400                         self.moveTimeLines(True)
401
402         def prevEvent(self, visible=True):
403                 ret = self["list"].selEntry(-1, visible)
404                 if ret:
405                         self.moveTimeLines(True)
406
407         def key1(self):
408                 self["list"].setEpoch(60)
409                 config.misc.graph_mepg_prev_time_period.value = 60
410                 self.moveTimeLines()
411
412         def key2(self):
413                 self["list"].setEpoch(120)
414                 config.misc.graph_mepg_prev_time_period.value = 120
415                 self.moveTimeLines()
416
417         def key3(self):
418                 self["list"].setEpoch(180)
419                 config.misc.graph_mepg_prev_time_period.value = 180
420                 self.moveTimeLines()
421
422         def key4(self):
423                 self["list"].setEpoch(240)
424                 config.misc.graph_mepg_prev_time_period.value = 240
425                 self.moveTimeLines()
426
427         def key5(self):
428                 self["list"].setEpoch(300)
429                 config.misc.graph_mepg_prev_time_period.value = 300
430                 self.moveTimeLines()
431
432         def nextBouquet(self):
433                 if self.bouquetChangeCB:
434                         self.bouquetChangeCB(1, self)
435
436         def prevBouquet(self):
437                 if self.bouquetChangeCB:
438                         self.bouquetChangeCB(-1, self)
439
440         def enterDateTime(self):
441                 self.session.openWithCallback(self.onDateTimeInputClosed, TimeDateInput, config.misc.graph_mepg_prev_time )
442
443         def onDateTimeInputClosed(self, ret):
444                 if len(ret) > 1:
445                         if ret[0]:
446                                 self.ask_time=ret[1]
447                                 l = self["list"]
448                                 l.resetOffset()
449                                 l.fillMultiEPG(self.services, ret[1])
450                                 self.moveTimeLines(True)
451
452         def closeScreen(self):
453                 self.close(self.closeRecursive)
454
455         def infoKeyPressed(self):
456                 cur = self["list"].getCurrent()
457                 event = cur[0]
458                 service = cur[1]
459                 if event is not None:
460                         self.session.open(EventViewSimple, event, service, self.eventViewCallback, self.openSimilarList)
461
462         def openSimilarList(self, eventid, refstr):
463                 self.session.open(EPGSelection, refstr, None, eventid)
464
465         def setServices(self, services):
466                 self.services = services
467                 self.onCreate()
468
469         #just used in multipeg
470         def onCreate(self):
471                 self["list"].fillMultiEPG(self.services, self.ask_time)
472                 self.moveTimeLines()
473
474         def eventViewCallback(self, setEvent, setService, val):
475                 l = self["list"]
476                 old = l.getCurrent()
477                 if val == -1:
478                         self.prevEvent(False)
479                 elif val == +1:
480                         self.nextEvent(False)
481                 cur = l.getCurrent()
482                 if cur[0] is None and cur[1].ref != old[1].ref:
483                         self.eventViewCallback(setEvent, setService, val)
484                 else:
485                         setService(cur[1])
486                         setEvent(cur[0])
487
488         def zapTo(self):
489                 if self.zapFunc and self["key_red"].getText() == "Zap":
490                         self.closeRecursive = True
491                         ref = self["list"].getCurrent()[1]
492                         self.zapFunc(ref.ref)
493
494         def eventSelected(self):
495                 self.infoKeyPressed()
496
497         def timerAdd(self):
498                 cur = self["list"].getCurrent()
499                 event = cur[0]
500                 serviceref = cur[1]
501                 if event is None:
502                         return
503                 newEntry = RecordTimerEntry(serviceref, checkOldTimers = True, *parseEvent(event))
504                 self.session.openWithCallback(self.finishedAdd, TimerEntry, newEntry)
505
506         def finishedAdd(self, answer):
507                 print "finished add"
508                 if answer[0]:
509                         entry = answer[1]
510                         simulTimerList = self.session.nav.RecordTimer.record(entry)
511                         if simulTimerList is not None:
512                                 if (len(simulTimerList) == 2) and (simulTimerList[1].dontSave) and (simulTimerList[1].autoincrease):
513                                         simulTimerList[1].end = entry.begin - 30
514                                         self.session.nav.RecordTimer.timeChanged(simulTimerList[1])
515                                         self.session.nav.RecordTimer.record(entry)
516                                 else:
517                                         self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
518                 else:
519                         print "Timeredit aborted"               
520         
521         def finishSanityCorrection(self, answer):
522                 self.finishedAdd(answer)
523
524         def onSelectionChanged(self):
525                 evt = self["list"].getCurrent()
526                 self["Event"].newEvent(evt and evt[0])
527                 if evt and evt[0]:
528                         evt = evt[0]
529                         now = time()
530                         start = evt.getBeginTime()
531                         end = start + evt.getDuration()
532                         if now >= start and now <= end:
533                                 self["key_red"].setText("Zap")
534                         else:
535                                 self["key_red"].setText("")
536
537         def moveTimeLines(self, force=False):
538                 l = self["list"]
539                 event_rect = l.getEventRect()
540                 time_epoch = l.getTimeEpoch()
541                 time_base = l.getTimeBase()
542                 if event_rect is None or time_epoch is None or time_base is None:
543                         return
544                 time_steps = time_epoch > 180 and 60 or 30
545                 num_lines = time_epoch/time_steps
546                 incWidth=event_rect.width()/num_lines
547                 pos=event_rect.left()
548                 timeline_entries = [ ]
549                 x = 0
550                 changecount = 0
551                 for line in self.time_lines:
552                         old_pos = line.position
553                         new_pos = (x == num_lines and event_rect.left()+event_rect.width() or pos, old_pos[1])
554                         if not x or x >= num_lines:
555                                 line.visible = False
556                         else:
557                                 if old_pos != new_pos:
558                                         line.setPosition(new_pos[0], new_pos[1])
559                                         changecount += 1
560                                 line.visible = True
561                         if not x or line.visible:
562                                 timeline_entries.append((time_base + x * time_steps * 60, new_pos[0]))
563                         x += 1
564                         pos += incWidth
565
566                 if changecount or force:
567                         self["timeline_text"].setEntries(timeline_entries)
568
569                 now=time()
570                 timeline_now = self["timeline_now"]
571                 if now >= time_base and now < (time_base + time_epoch * 60):
572                         bla = (event_rect.width() * 1000) / time_epoch
573                         xpos = ((now/60) - (time_base/60)) * bla / 1000
574                         old_pos = timeline_now.position
575                         new_pos = (xpos+event_rect.left(), old_pos[1])
576                         if old_pos != new_pos:
577                                 timeline_now.setPosition(new_pos[0], new_pos[1])
578                         timeline_now.visible = True
579                 else:
580                         timeline_now.visible = False