1 from ChannelSelection import ChannelSelection, BouquetSelector
3 from Components.ActionMap import ActionMap, HelpableActionMap
4 from Components.ActionMap import NumberActionMap
5 from Components.BlinkingPixmap import BlinkingPixmapConditional
6 from Components.Harddisk import harddiskmanager
7 from Components.Input import Input
8 from Components.Label import Label
9 from Components.Pixmap import Pixmap
10 from Components.PluginComponent import plugins
11 from Components.ServiceEventTracker import ServiceEventTracker
12 from Components.Sources.Boolean import Boolean
13 from Components.config import config, ConfigBoolean, ConfigClock
14 from Components.SystemInfo import SystemInfo
15 from EpgSelection import EPGSelection
16 from Plugins.Plugin import PluginDescriptor
18 from Screen import Screen
19 from Screens.ChoiceBox import ChoiceBox
20 from Screens.Dish import Dish
21 from Screens.EventView import EventViewEPGSelect, EventViewSimple
22 from Screens.InputBox import InputBox
23 from Screens.MessageBox import MessageBox
24 from Screens.MinuteInput import MinuteInput
25 from Screens.TimerSelection import TimerSelection
26 from Screens.PictureInPicture import PictureInPicture
27 from Screens.SubtitleDisplay import SubtitleDisplay
28 from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
29 from Screens.SleepTimerEdit import SleepTimerEdit
30 from Screens.TimeDateInput import TimeDateInput
31 from ServiceReference import ServiceReference
33 from Tools import Notifications
34 from Tools.Directories import SCOPE_HDD, resolveFilename
36 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
37 iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
39 from time import time, localtime, strftime
40 from os import stat as os_stat
41 from bisect import insort
44 from Menu import MainMenu, mdom
48 self.dishDialog = self.session.instantiateDialog(Dish)
50 class InfoBarShowHide:
51 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
59 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
61 "toggleShow": self.toggleShow,
63 }, 1) # lower prio to make it possible to override ok and cancel..
65 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
67 iPlayableService.evStart: self.serviceStarted,
70 self.__state = self.STATE_SHOWN
73 self.hideTimer = eTimer()
74 self.hideTimer.callback.append(self.doTimerHide)
75 self.hideTimer.start(5000, True)
77 self.onShow.append(self.__onShow)
78 self.onHide.append(self.__onHide)
80 def serviceStarted(self):
82 if config.usage.show_infobar_on_zap.value:
86 self.__state = self.STATE_SHOWN
89 def startHideTimer(self):
90 if self.__state == self.STATE_SHOWN and not self.__locked:
91 idx = config.usage.infobar_timeout.index
93 self.hideTimer.start(idx*1000, True)
96 self.__state = self.STATE_HIDDEN
100 self.startHideTimer()
102 def doTimerHide(self):
103 self.hideTimer.stop()
104 if self.__state == self.STATE_SHOWN:
107 def toggleShow(self):
108 if self.__state == self.STATE_SHOWN:
110 self.hideTimer.stop()
111 elif self.__state == self.STATE_HIDDEN:
115 self.__locked = self.__locked + 1
118 self.hideTimer.stop()
120 def unlockShow(self):
121 self.__locked = self.__locked - 1
123 self.startHideTimer()
125 # def startShow(self):
126 # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
127 # self.__state = self.STATE_SHOWN
129 # def startHide(self):
130 # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
131 # self.__state = self.STATE_HIDDEN
133 class NumberZap(Screen):
140 self.close(int(self["number"].getText()))
142 def keyNumberGlobal(self, number):
143 self.Timer.start(3000, True) #reset timer
144 self.field = self.field + str(number)
145 self["number"].setText(self.field)
146 if len(self.field) >= 4:
149 def __init__(self, session, number):
150 Screen.__init__(self, session)
151 self.field = str(number)
153 self["channel"] = Label(_("Channel:"))
155 self["number"] = Label(self.field)
157 self["actions"] = NumberActionMap( [ "SetupActions" ],
161 "1": self.keyNumberGlobal,
162 "2": self.keyNumberGlobal,
163 "3": self.keyNumberGlobal,
164 "4": self.keyNumberGlobal,
165 "5": self.keyNumberGlobal,
166 "6": self.keyNumberGlobal,
167 "7": self.keyNumberGlobal,
168 "8": self.keyNumberGlobal,
169 "9": self.keyNumberGlobal,
170 "0": self.keyNumberGlobal
173 self.Timer = eTimer()
174 self.Timer.callback.append(self.keyOK)
175 self.Timer.start(3000, True)
177 class InfoBarNumberZap:
178 """ Handles an initial number for NumberZapping """
180 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
182 "1": self.keyNumberGlobal,
183 "2": self.keyNumberGlobal,
184 "3": self.keyNumberGlobal,
185 "4": self.keyNumberGlobal,
186 "5": self.keyNumberGlobal,
187 "6": self.keyNumberGlobal,
188 "7": self.keyNumberGlobal,
189 "8": self.keyNumberGlobal,
190 "9": self.keyNumberGlobal,
191 "0": self.keyNumberGlobal,
194 def keyNumberGlobal(self, number):
195 # print "You pressed number " + str(number)
197 if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
198 self.pipDoHandle0Action()
200 self.servicelist.recallPrevService()
202 if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
203 self.session.openWithCallback(self.numberEntered, NumberZap, number)
205 def numberEntered(self, retval):
206 # print self.servicelist
208 self.zapToNumber(retval)
210 def searchNumberHelper(self, serviceHandler, num, bouquet):
211 servicelist = serviceHandler.list(bouquet)
212 if not servicelist is None:
214 serviceIterator = servicelist.getNext()
215 if not serviceIterator.valid(): #check end of list
217 playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
220 if not num: #found service with searched number ?
221 return serviceIterator, 0
224 def zapToNumber(self, number):
225 bouquet = self.servicelist.bouquet_root
227 serviceHandler = eServiceCenter.getInstance()
228 if not config.usage.multibouquet.value:
229 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
231 bouquetlist = serviceHandler.list(bouquet)
232 if not bouquetlist is None:
234 bouquet = bouquetlist.getNext()
235 if not bouquet.valid(): #check end of list
237 if bouquet.flags & eServiceReference.isDirectory:
238 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
239 if not service is None:
240 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
241 self.servicelist.clearPath()
242 if self.servicelist.bouquet_root != bouquet:
243 self.servicelist.enterPath(self.servicelist.bouquet_root)
244 self.servicelist.enterPath(bouquet)
245 self.servicelist.setCurrentSelection(service) #select the service in servicelist
246 self.servicelist.zap()
248 config.misc.initialchannelselection = ConfigBoolean(default = True)
250 class InfoBarChannelSelection:
251 """ ChannelSelection - handles the channelSelection dialog and the initial
252 channelChange actions which open the channelSelection dialog """
255 self.servicelist = self.session.instantiateDialog(ChannelSelection)
257 if config.misc.initialchannelselection.value:
258 self.onShown.append(self.firstRun)
260 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
262 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
263 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
264 "zapUp": (self.zapUp, _("previous channel")),
265 "zapDown": (self.zapDown, _("next channel")),
266 "historyBack": (self.historyBack, _("previous channel in history")),
267 "historyNext": (self.historyNext, _("next channel in history")),
268 "openServiceList": (self.openServiceList, _("open servicelist")),
271 def showTvChannelList(self, zap=False):
272 self.servicelist.setModeTv()
274 self.servicelist.zap()
275 self.session.execDialog(self.servicelist)
277 def showRadioChannelList(self, zap=False):
278 self.servicelist.setModeRadio()
280 self.servicelist.zap()
281 self.session.execDialog(self.servicelist)
284 self.onShown.remove(self.firstRun)
285 config.misc.initialchannelselection.value = False
286 config.misc.initialchannelselection.save()
287 self.switchChannelDown()
289 def historyBack(self):
290 self.servicelist.historyBack()
292 def historyNext(self):
293 self.servicelist.historyNext()
295 def switchChannelUp(self):
296 self.servicelist.moveUp()
297 self.session.execDialog(self.servicelist)
299 def switchChannelDown(self):
300 self.servicelist.moveDown()
301 self.session.execDialog(self.servicelist)
303 def openServiceList(self):
304 self.session.execDialog(self.servicelist)
307 if self.servicelist.inBouquet():
308 prev = self.servicelist.getCurrentSelection()
310 prev = prev.toString()
312 if config.usage.quickzap_bouquet_change.value:
313 if self.servicelist.atBegin():
314 self.servicelist.prevBouquet()
315 self.servicelist.moveUp()
316 cur = self.servicelist.getCurrentSelection()
317 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
320 self.servicelist.moveUp()
321 self.servicelist.zap()
324 if self.servicelist.inBouquet():
325 prev = self.servicelist.getCurrentSelection()
327 prev = prev.toString()
329 if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
330 self.servicelist.nextBouquet()
332 self.servicelist.moveDown()
333 cur = self.servicelist.getCurrentSelection()
334 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
337 self.servicelist.moveDown()
338 self.servicelist.zap()
341 """ Handles a menu action, to open the (main) menu """
343 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
345 "mainMenu": (self.mainMenu, _("Enter main menu...")),
347 self.session.infobar = None
350 print "loading mainmenu XML..."
351 menu = mdom.childNodes[0]
352 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
354 self.session.infobar = self
355 # so we can access the currently active infobar from screens opened from within the mainmenu
356 # at the moment used from the SubserviceSelection
358 self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu, menu.childNodes)
360 def mainMenuClosed(self, *val):
361 self.session.infobar = None
363 class InfoBarSimpleEventView:
364 """ Opens the Eventview for now/next """
366 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
368 "showEventInfo": (self.openEventView, _("show event details")),
371 def openEventView(self):
373 service = self.session.nav.getCurrentService()
374 ref = self.session.nav.getCurrentlyPlayingServiceReference()
375 info = service.info()
378 self.epglist.append(ptr)
381 self.epglist.append(ptr)
382 if len(self.epglist) > 0:
383 self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
385 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
386 if len(self.epglist) > 1:
387 tmp = self.epglist[0]
388 self.epglist[0]=self.epglist[1]
390 setEvent(self.epglist[0])
393 """ EPG - Opens an EPG list when the showEPGList action fires """
395 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
397 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
400 self.is_now_next = False
402 self.bouquetSel = None
403 self.eventView = None
404 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
406 "showEventInfo": (self.openEventView, _("show EPG...")),
407 "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
408 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
411 def showEventInfoWhenNotVisible(self):
418 def zapToService(self, service):
419 if not service is None:
420 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
421 self.servicelist.clearPath()
422 if self.servicelist.bouquet_root != self.epg_bouquet:
423 self.servicelist.enterPath(self.servicelist.bouquet_root)
424 self.servicelist.enterPath(self.epg_bouquet)
425 self.servicelist.setCurrentSelection(service) #select the service in servicelist
426 self.servicelist.zap()
428 def getBouquetServices(self, bouquet):
430 servicelist = eServiceCenter.getInstance().list(bouquet)
431 if not servicelist is None:
433 service = servicelist.getNext()
434 if not service.valid(): #check if end of list
436 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
438 services.append(ServiceReference(service))
441 def openBouquetEPG(self, bouquet, withCallback=True):
442 services = self.getBouquetServices(bouquet)
444 self.epg_bouquet = bouquet
446 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
448 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
450 def changeBouquetCB(self, direction, epg):
453 self.bouquetSel.down()
456 bouquet = self.bouquetSel.getCurrent()
457 services = self.getBouquetServices(bouquet)
459 self.epg_bouquet = bouquet
460 epg.setServices(services)
462 def closed(self, ret=False):
463 closedScreen = self.dlg_stack.pop()
464 if self.bouquetSel and closedScreen == self.bouquetSel:
465 self.bouquetSel = None
466 elif self.eventView and closedScreen == self.eventView:
467 self.eventView = None
469 dlgs=len(self.dlg_stack)
471 self.dlg_stack[dlgs-1].close(dlgs > 1)
473 def openMultiServiceEPG(self, withCallback=True):
474 bouquets = self.servicelist.getBouquetList()
479 if cnt > 1: # show bouquet list
481 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
482 self.dlg_stack.append(self.bouquetSel)
484 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
486 self.openBouquetEPG(bouquets[0][1], withCallback)
488 def openSingleServiceEPG(self):
489 ref=self.session.nav.getCurrentlyPlayingServiceReference()
490 self.session.open(EPGSelection, ref)
492 def openSimilarList(self, eventid, refstr):
493 self.session.open(EPGSelection, refstr, None, eventid)
495 def getNowNext(self):
497 service = self.session.nav.getCurrentService()
498 info = service and service.info()
499 ptr = info and info.getEvent(0)
501 self.epglist.append(ptr)
502 ptr = info and info.getEvent(1)
504 self.epglist.append(ptr)
506 def __evEventInfoChanged(self):
507 if self.is_now_next and len(self.dlg_stack) == 1:
509 assert self.eventView
510 if len(self.epglist):
511 self.eventView.setEvent(self.epglist[0])
513 def openEventView(self):
514 ref = self.session.nav.getCurrentlyPlayingServiceReference()
516 if len(self.epglist) == 0:
517 self.is_now_next = False
518 epg = eEPGCache.getInstance()
519 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
521 self.epglist.append(ptr)
522 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
524 self.epglist.append(ptr)
526 self.is_now_next = True
527 if len(self.epglist) > 0:
528 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
529 self.dlg_stack.append(self.eventView)
531 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
532 self.openMultiServiceEPG(False)
534 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
535 if len(self.epglist) > 1:
536 tmp = self.epglist[0]
537 self.epglist[0]=self.epglist[1]
539 setEvent(self.epglist[0])
541 class InfoBarRdsDecoder:
542 """provides RDS and Rass support/display"""
544 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
545 self.rass_interactive = None
547 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
549 iPlayableService.evEnd: self.__serviceStopped,
550 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
553 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
555 "startRassInteractive": self.startRassInteractive
558 self["RdsActions"].setEnabled(False)
560 self.onLayoutFinish.append(self.rds_display.show)
561 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
563 def RassInteractivePossibilityChanged(self, state):
564 self["RdsActions"].setEnabled(state)
566 def RassSlidePicChanged(self):
567 if not self.rass_interactive:
568 service = self.session.nav.getCurrentService()
569 decoder = service and service.rdsDecoder()
571 decoder.showRassSlidePicture()
573 def __serviceStopped(self):
574 if self.rass_interactive is not None:
575 rass_interactive = self.rass_interactive
576 self.rass_interactive = None
577 rass_interactive.close()
579 def startRassInteractive(self):
580 self.rds_display.hide()
581 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
583 def RassInteractiveClosed(self, *val):
584 if self.rass_interactive is not None:
585 self.rass_interactive = None
586 self.RassSlidePicChanged()
587 self.rds_display.show()
590 """handles actions like seeking, pause"""
592 SEEK_STATE_PLAY = (0, 0, 0, ">")
593 SEEK_STATE_PAUSE = (1, 0, 0, "||")
594 SEEK_STATE_EOF = (1, 0, 0, "END")
596 def __init__(self, actionmap = "InfobarSeekActions"):
597 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
599 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
600 iPlayableService.evStart: self.__serviceStarted,
602 iPlayableService.evEOF: self.__evEOF,
603 iPlayableService.evSOF: self.__evSOF,
606 self.eofTimer = eTimer()
607 self.eofTimer.timeout.get().append(self.doEof)
608 self.eofInhibitTimer = eTimer()
609 self.eofInhibitTimer.timeout.get().append(self.inhibitEof)
611 # self.minSpeedBackward = 16
613 class InfoBarSeekActionMap(HelpableActionMap):
614 def __init__(self, screen, *args, **kwargs):
615 HelpableActionMap.__init__(self, screen, *args, **kwargs)
618 def action(self, contexts, action):
619 print "action:", action
620 if action[:5] == "seek:":
621 time = int(action[5:])
622 self.screen.doSeekRelative(time * 90000)
624 elif action[:8] == "seekdef:":
625 key = int(action[8:])
626 time = [-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
627 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
628 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value][key-1]
629 self.screen.doSeekRelative(time * 90000)
632 return HelpableActionMap.action(self, contexts, action)
634 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
636 "playpauseService": self.playpauseService,
637 "pauseService": (self.pauseService, _("pause")),
638 "unPauseService": (self.unPauseService, _("continue")),
640 "seekFwd": (self.seekFwd, _("skip forward")),
641 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
642 "seekBack": (self.seekBack, _("skip backward")),
643 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
645 # give them a little more priority to win over color buttons
647 self["SeekActions"].setEnabled(False)
649 self.seekstate = self.SEEK_STATE_PLAY
650 self.lastseekstate = self.SEEK_STATE_PLAY
652 self.onPlayStateChanged = [ ]
654 self.lockedBecauseOfSkipping = False
656 self.__seekableStatusChanged()
658 def makeStateForward(self, n):
659 minspeed = config.seek.stepwise_minspeed.value
660 repeat = int(config.seek.stepwise_repeat.value)
661 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
662 return (0, n * repeat, repeat, ">> %dx" % n)
664 return (0, n, 0, ">> %dx" % n)
666 def makeStateBackward(self, n):
667 minspeed = config.seek.stepwise_minspeed.value
668 repeat = int(config.seek.stepwise_repeat.value)
669 # if n < self.minSpeedBackward:
670 # r = (self.minSpeedBackward - 1)/ n + 1
671 # if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
673 # return (0, -n * r, r, "<< %dx" % n)
675 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
676 return (0, -n * repeat, repeat, "<< %dx" % n)
678 return (0, -n, 0, "<< %dx" % n)
680 def makeStateSlowMotion(self, n):
681 return (0, 0, n, "/%d" % n)
683 def isStateForward(self, state):
686 def isStateBackward(self, state):
689 def isStateSlowMotion(self, state):
690 return state[1] == 0 and state[2] > 1
692 def getHigher(self, n, lst):
698 def getLower(self, n, lst):
706 def showAfterSeek(self):
707 if isinstance(self, InfoBarShowHide):
717 service = self.session.nav.getCurrentService()
721 seek = service.seek()
723 if seek is None or not seek.isCurrentlySeekable():
728 def isSeekable(self):
729 if self.getSeek() is None:
733 def __seekableStatusChanged(self):
734 print "seekable status changed!"
735 if not self.isSeekable():
736 self["SeekActions"].setEnabled(False)
737 print "not seekable, return to play"
738 self.setSeekState(self.SEEK_STATE_PLAY)
740 self["SeekActions"].setEnabled(True)
743 def __serviceStarted(self):
744 self.seekstate = self.SEEK_STATE_PLAY
745 self.__seekableStatusChanged()
746 if self.eofState != 0:
750 def setSeekState(self, state):
751 service = self.session.nav.getCurrentService()
756 if not self.isSeekable():
757 if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
758 state = self.SEEK_STATE_PLAY
760 pauseable = service.pause()
762 if pauseable is None:
763 print "not pauseable."
764 state = self.SEEK_STATE_PLAY
766 oldstate = self.seekstate
767 self.seekstate = state
770 if oldstate[i] != self.seekstate[i]:
771 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
773 for c in self.onPlayStateChanged:
776 self.checkSkipShowHideLock()
780 def playpauseService(self):
781 if self.seekstate != self.SEEK_STATE_PLAY:
782 self.unPauseService()
786 def pauseService(self):
787 if self.seekstate == self.SEEK_STATE_PAUSE:
788 if config.seek.on_pause.value == "play":
789 self.unPauseService()
790 elif config.seek.on_pause.value == "step":
791 self.doSeekRelative(0)
792 elif config.seek.on_pause.value == "last":
793 self.setSeekState(self.lastseekstate)
794 self.lastseekstate = self.SEEK_STATE_PLAY
796 if self.seekstate != self.SEEK_STATE_EOF:
797 self.lastseekstate = self.seekstate
798 self.setSeekState(self.SEEK_STATE_PAUSE);
800 def unPauseService(self):
802 if self.seekstate == self.SEEK_STATE_PLAY:
804 self.setSeekState(self.SEEK_STATE_PLAY)
806 def doSeek(self, pts):
807 seekable = self.getSeek()
810 prevstate = self.seekstate
811 if self.eofState == 1:
814 if self.seekstate == self.SEEK_STATE_EOF:
815 if prevstate == self.SEEK_STATE_PAUSE:
816 self.setSeekState(self.SEEK_STATE_PAUSE)
818 self.setSeekState(self.SEEK_STATE_PLAY)
819 self.eofInhibitTimer.start(200, True)
822 def doSeekRelative(self, pts):
823 seekable = self.getSeek()
826 prevstate = self.seekstate
827 if self.eofState == 1:
830 if self.seekstate == self.SEEK_STATE_EOF:
831 if prevstate == self.SEEK_STATE_PAUSE:
832 self.setSeekState(self.SEEK_STATE_PAUSE)
834 self.setSeekState(self.SEEK_STATE_PLAY)
835 self.eofInhibitTimer.start(200, True)
836 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
837 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
841 if self.seekstate == self.SEEK_STATE_PLAY:
842 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
843 elif self.seekstate == self.SEEK_STATE_PAUSE:
844 if len(config.seek.speeds_slowmotion.value):
845 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
847 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
848 elif self.seekstate == self.SEEK_STATE_EOF:
850 elif self.isStateForward(self.seekstate):
851 speed = self.seekstate[1]
852 if self.seekstate[2]:
853 speed /= self.seekstate[2]
854 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
855 self.setSeekState(self.makeStateForward(speed))
856 elif self.isStateBackward(self.seekstate):
857 speed = -self.seekstate[1]
858 if self.seekstate[2]:
859 speed /= self.seekstate[2]
860 speed = self.getLower(speed, config.seek.speeds_backward.value)
862 self.setSeekState(self.makeStateBackward(speed))
864 self.setSeekState(self.SEEK_STATE_PLAY)
865 elif self.isStateSlowMotion(self.seekstate):
866 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
867 self.setSeekState(self.makeStateSlowMotion(speed))
870 if self.seekstate == self.SEEK_STATE_PLAY:
871 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
872 elif self.seekstate == self.SEEK_STATE_EOF:
873 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
874 self.doSeekRelative(-6)
875 elif self.seekstate == self.SEEK_STATE_PAUSE:
876 self.doSeekRelative(-3)
877 elif self.isStateForward(self.seekstate):
878 speed = self.seekstate[1]
879 if self.seekstate[2]:
880 speed /= self.seekstate[2]
881 speed = self.getLower(speed, config.seek.speeds_forward.value)
883 self.setSeekState(self.makeStateForward(speed))
885 self.setSeekState(self.SEEK_STATE_PLAY)
886 elif self.isStateBackward(self.seekstate):
887 speed = -self.seekstate[1]
888 if self.seekstate[2]:
889 speed /= self.seekstate[2]
890 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
891 self.setSeekState(self.makeStateBackward(speed))
892 elif self.isStateSlowMotion(self.seekstate):
893 speed = self.getHigher(self.seekstate[2], config.seek.speeds_slowmotion.value)
895 self.setSeekState(self.makeStateSlowMotion(speed))
897 self.setSeekState(self.SEEK_STATE_PAUSE)
899 def seekFwdManual(self):
900 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
902 def fwdSeekTo(self, minutes):
903 print "Seek", minutes, "minutes forward"
904 self.doSeekRelative(minutes * 60 * 90000)
906 def seekBackManual(self):
907 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
909 def rwdSeekTo(self, minutes):
911 self.doSeekRelative(-minutes * 60 * 90000)
913 def checkSkipShowHideLock(self):
914 wantlock = self.seekstate != self.SEEK_STATE_PLAY
916 if config.usage.show_infobar_on_skip.value:
917 if self.lockedBecauseOfSkipping and not wantlock:
919 self.lockedBecauseOfSkipping = False
921 if wantlock and not self.lockedBecauseOfSkipping:
923 self.lockedBecauseOfSkipping = True
925 def calcRemainingTime(self):
926 seekable = self.getSeek()
927 if seekable is not None:
928 len = seekable.getLength()
930 tmp = self.cueGetEndCutPosition()
935 pos = seekable.getPlayPosition()
936 speednom = self.seekstate[1] or 1
937 speedden = self.seekstate[2] or 1
938 if not len[0] and not pos[0]:
941 time = (len[1] - pos[1])*speedden/(90*speednom)
946 if self.eofState == 0 and self.seekstate != self.SEEK_STATE_EOF:
948 time = self.calcRemainingTime()
950 time = 3000 # Failed to calc, use default
952 time = 300 # Passed end, shortest wait
954 self.eofState = -2 # Too long, block eof
957 time += 1000 # Add margin
958 self.eofTimer.start(time, True)
960 def inhibitEof(self):
961 if self.eofState >= 1:
962 self.eofState = -self.eofState
967 if self.seekstate == self.SEEK_STATE_EOF:
969 if self.eofState == -2 or self.isStateBackward(self.seekstate):
973 # if we are seeking, we try to end up ~1s before the end, and pause there.
974 eofstate = self.eofState
975 seekstate = self.seekstate
977 if not self.seekstate == self.SEEK_STATE_PAUSE:
978 self.setSeekState(self.SEEK_STATE_EOF)
979 if eofstate == -1 or not seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
980 seekable = self.getSeek()
981 if seekable is not None:
983 if eofstate == 1 and seekstate == self.SEEK_STATE_PLAY:
984 self.doEofInternal(True)
986 self.doEofInternal(False)
988 def doEofInternal(self, playing):
989 pass # Defined in subclasses
992 self.setSeekState(self.SEEK_STATE_PLAY)
995 from Screens.PVRState import PVRState, TimeshiftState
997 class InfoBarPVRState:
998 def __init__(self, screen=PVRState):
999 self.onPlayStateChanged.append(self.__playStateChanged)
1000 self.pvrStateDialog = self.session.instantiateDialog(screen)
1001 self.onShow.append(self._mayShow)
1002 self.onHide.append(self.pvrStateDialog.hide)
1005 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1006 self.pvrStateDialog.show()
1008 def __playStateChanged(self, state):
1009 playstateString = state[3]
1010 self.pvrStateDialog["state"].setText(playstateString)
1013 class InfoBarTimeshiftState(InfoBarPVRState):
1015 InfoBarPVRState.__init__(self, screen=TimeshiftState)
1018 if self.execing and self.timeshift_enabled:
1019 self.pvrStateDialog.show()
1021 class InfoBarShowMovies:
1023 # i don't really like this class.
1024 # it calls a not further specified "movie list" on up/down/movieList,
1025 # so this is not more than an action map
1027 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1029 "movieList": (self.showMovies, _("movie list")),
1030 "up": (self.showMovies, _("movie list")),
1031 "down": (self.showMovies, _("movie list"))
1034 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1038 # Timeshift works the following way:
1039 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1040 # - normal playback TUNER unused PLAY enable disable disable
1041 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1042 # - user presess pause again FILE record PLAY enable disable enable
1043 # - user fast forwards FILE record FF enable disable enable
1044 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1045 # - user backwards FILE record BACK # !! enable disable enable
1049 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1050 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1051 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1052 # - the user can now PVR around
1053 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1054 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1056 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1057 # - if the user rewinds, or press pause, timeshift will be activated again
1059 # note that a timeshift can be enabled ("recording") and
1060 # activated (currently time-shifting).
1062 class InfoBarTimeshift:
1064 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1066 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1067 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1069 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1071 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1072 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1073 }, prio=-1) # priority over record
1075 self.timeshift_enabled = 0
1076 self.timeshift_state = 0
1077 self.ts_rewind_timer = eTimer()
1078 self.ts_rewind_timer.callback.append(self.rewindService)
1080 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1082 iPlayableService.evStart: self.__serviceStarted,
1083 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1086 def getTimeshift(self):
1087 service = self.session.nav.getCurrentService()
1088 return service and service.timeshift()
1090 def startTimeshift(self):
1091 print "enable timeshift"
1092 ts = self.getTimeshift()
1094 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1095 print "no ts interface"
1098 if self.timeshift_enabled:
1099 print "hu, timeshift already enabled?"
1101 if not ts.startTimeshift():
1102 self.timeshift_enabled = 1
1104 # we remove the "relative time" for now.
1105 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1108 #self.setSeekState(self.SEEK_STATE_PAUSE)
1109 self.activateTimeshiftEnd(False)
1111 # enable the "TimeshiftEnableActions", which will override
1112 # the startTimeshift actions
1113 self.__seekableStatusChanged()
1115 print "timeshift failed"
1117 def stopTimeshift(self):
1118 if not self.timeshift_enabled:
1120 print "disable timeshift"
1121 ts = self.getTimeshift()
1124 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1126 def stopTimeshiftConfirmed(self, confirmed):
1130 ts = self.getTimeshift()
1135 self.timeshift_enabled = 0
1138 self.__seekableStatusChanged()
1140 # activates timeshift, and seeks to (almost) the end
1141 def activateTimeshiftEnd(self, back = True):
1142 ts = self.getTimeshift()
1143 print "activateTimeshiftEnd"
1148 if ts.isTimeshiftActive():
1149 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1153 ts.activateTimeshift() # activate timeshift will automatically pause
1154 self.setSeekState(self.SEEK_STATE_PAUSE)
1157 self.doSeek(-5) # seek some gops before end
1158 self.ts_rewind_timer.start(200, 1)
1160 self.doSeek(-1) # seek 1 gop before end
1162 def rewindService(self):
1163 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1165 # same as activateTimeshiftEnd, but pauses afterwards.
1166 def activateTimeshiftEndAndPause(self):
1167 print "activateTimeshiftEndAndPause"
1168 #state = self.seekstate
1169 self.activateTimeshiftEnd(False)
1171 def __seekableStatusChanged(self):
1174 print "self.isSeekable", self.isSeekable()
1175 print "self.timeshift_enabled", self.timeshift_enabled
1177 # when this service is not seekable, but timeshift
1178 # is enabled, this means we can activate
1180 if not self.isSeekable() and self.timeshift_enabled:
1183 print "timeshift activate:", enabled
1184 self["TimeshiftActivateActions"].setEnabled(enabled)
1186 def __serviceStarted(self):
1187 self.timeshift_enabled = False
1188 self.__seekableStatusChanged()
1190 from Screens.PiPSetup import PiPSetup
1192 class InfoBarExtensions:
1193 EXTENSION_SINGLE = 0
1199 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1201 "extensions": (self.showExtensionSelection, _("view extensions...")),
1204 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1205 self.list.append((type, extension, key))
1207 def updateExtension(self, extension, key = None):
1208 self.extensionsList.append(extension)
1210 if self.extensionKeys.has_key(key):
1214 for x in self.availableKeys:
1215 if not self.extensionKeys.has_key(x):
1220 self.extensionKeys[key] = len(self.extensionsList) - 1
1222 def updateExtensions(self):
1223 self.extensionsList = []
1224 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1225 self.extensionKeys = {}
1227 if x[0] == self.EXTENSION_SINGLE:
1228 self.updateExtension(x[1], x[2])
1231 self.updateExtension(y[0], y[1])
1234 def showExtensionSelection(self):
1235 self.updateExtensions()
1236 extensionsList = self.extensionsList[:]
1239 for x in self.availableKeys:
1240 if self.extensionKeys.has_key(x):
1241 entry = self.extensionKeys[x]
1242 extension = self.extensionsList[entry]
1244 name = str(extension[0]())
1245 list.append((extension[0](), extension))
1247 extensionsList.remove(extension)
1249 extensionsList.remove(extension)
1250 for x in extensionsList:
1251 list.append((x[0](), x))
1252 keys += [""] * len(extensionsList)
1253 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
1255 def extensionCallback(self, answer):
1256 if answer is not None:
1259 from Tools.BoundFunction import boundFunction
1261 # depends on InfoBarExtensions
1262 from Components.PluginComponent import plugins
1264 class InfoBarPlugins:
1266 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1268 def getPluginName(self, name):
1271 def getPluginList(self):
1273 for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
1274 list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
1277 def runPlugin(self, plugin):
1278 plugin(session = self.session, servicelist = self.servicelist)
1280 # depends on InfoBarExtensions
1281 class InfoBarSleepTimer:
1283 self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
1285 def available(self):
1288 def getSleepTimerName(self):
1289 return _("Sleep Timer")
1291 def showSleepTimerSetup(self):
1292 self.session.open(SleepTimerEdit)
1294 # depends on InfoBarExtensions
1297 self.session.pipshown = False
1298 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1299 self.addExtension((self.getShowHideName, self.showPiP, self.available), "blue")
1300 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1301 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1303 def available(self):
1304 return SystemInfo.get("NumVideoDecoders", 1) > 1
1307 return self.session.pipshown
1309 def pipHandles0Action(self):
1310 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1312 def getShowHideName(self):
1313 if self.session.pipshown:
1314 return _("Disable Picture in Picture")
1316 return _("Activate Picture in Picture")
1318 def getSwapName(self):
1319 return _("Swap Services")
1321 def getMoveName(self):
1322 return _("Move Picture in Picture")
1325 if self.session.pipshown:
1326 del self.session.pip
1327 self.session.pipshown = False
1329 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1330 self.session.pip.show()
1331 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1332 if self.session.pip.playService(newservice):
1333 self.session.pipshown = True
1334 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1336 self.session.pipshown = False
1337 del self.session.pip
1338 self.session.nav.playService(newservice)
1341 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1342 if self.session.pip.servicePath:
1343 servicepath = self.servicelist.getCurrentServicePath()
1344 ref=servicepath[len(servicepath)-1]
1345 pipref=self.session.pip.getCurrentService()
1346 self.session.pip.playService(swapservice)
1347 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1348 if pipref.toString() != ref.toString(): # is a subservice ?
1349 self.session.nav.stopService() # stop portal
1350 self.session.nav.playService(pipref) # start subservice
1351 self.session.pip.servicePath=servicepath
1354 self.session.open(PiPSetup, pip = self.session.pip)
1356 def pipDoHandle0Action(self):
1357 use = config.usage.pip_zero_button.value
1360 elif "swapstop" == use:
1366 from RecordTimer import parseEvent
1368 class InfoBarInstantRecord:
1369 """Instant Record - handles the instantRecord action in order to
1370 start/stop instant records"""
1372 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1374 "instantRecord": (self.instantRecord, _("Instant Record...")),
1378 def stopCurrentRecording(self, entry = -1):
1379 if entry is not None and entry != -1:
1380 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1381 self.recording.remove(self.recording[entry])
1383 def startInstantRecording(self, limitEvent = False):
1384 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1386 # try to get event info
1389 service = self.session.nav.getCurrentService()
1390 epg = eEPGCache.getInstance()
1391 event = epg.lookupEventTime(serviceref, -1, 0)
1393 info = service.info()
1394 ev = info.getEvent(0)
1400 end = time() + 3600 * 10
1401 name = "instant record"
1405 if event is not None:
1406 curEvent = parseEvent(event)
1408 description = curEvent[3]
1409 eventid = curEvent[4]
1414 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1416 data = (begin, end, name, description, eventid)
1418 recording = self.session.nav.recordWithTimer(serviceref, *data)
1419 recording.dontSave = True
1420 self.recording.append(recording)
1422 def isInstantRecordRunning(self):
1423 print "self.recording:", self.recording
1424 if len(self.recording) > 0:
1425 for x in self.recording:
1430 def recordQuestionCallback(self, answer):
1431 print "pre:\n", self.recording
1433 if answer is None or answer[1] == "no":
1436 recording = self.recording[:]
1438 if not x in self.session.nav.RecordTimer.timer_list:
1439 self.recording.remove(x)
1440 elif x.dontSave and x.isRunning():
1441 list.append((x, False))
1443 if answer[1] == "changeduration":
1444 if len(self.recording) == 1:
1445 self.changeDuration(0)
1447 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1448 elif answer[1] == "changeendtime":
1449 if len(self.recording) == 1:
1452 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1453 elif answer[1] == "stop":
1454 if len(self.recording) == 1:
1455 self.stopCurrentRecording(0)
1457 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1458 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1459 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1460 if answer[1] == "manualduration":
1461 self.changeDuration(len(self.recording)-1)
1462 elif answer[1] == "manualendtime":
1463 self.setEndtime(len(self.recording)-1)
1464 print "after:\n", self.recording
1466 def setEndtime(self, entry):
1467 if entry is not None:
1468 self.selectedEntry = entry
1469 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1470 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1471 dlg.setTitle(_("Please change recording endtime"))
1473 def TimeDateInputClosed(self, ret):
1476 localendtime = localtime(ret[1])
1477 print "stopping recording at", strftime("%c", localendtime)
1478 self.recording[self.selectedEntry].end = ret[1]
1479 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1481 def changeDuration(self, entry):
1482 if entry is not None:
1483 self.selectedEntry = entry
1484 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1486 def inputCallback(self, value):
1487 if value is not None:
1488 print "stopping recording after", int(value), "minutes."
1489 self.recording[self.selectedEntry].end = time() + 60 * int(value)
1490 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1492 def instantRecord(self):
1494 stat = os_stat(resolveFilename(SCOPE_HDD))
1496 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1499 if self.isInstantRecordRunning():
1500 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1501 title=_("A recording is currently running.\nWhat do you want to do?"), \
1502 list=[(_("stop recording"), "stop"), \
1503 (_("change recording (duration)"), "changeduration"), \
1504 (_("change recording (endtime)"), "changeendtime"), \
1505 (_("add recording (indefinitely)"), "indefinitely"), \
1506 (_("add recording (stop after current event)"), "event"), \
1507 (_("add recording (enter recording duration)"), "manualduration"), \
1508 (_("add recording (enter recording endtime)"), "manualendtime"), \
1509 (_("do nothing"), "no")])
1511 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1512 title=_("Start recording?"), \
1513 list=[(_("add recording (indefinitely)"), "indefinitely"), \
1514 (_("add recording (stop after current event)"), "event"), \
1515 (_("add recording (enter recording duration)"), "manualduration"), \
1516 (_("add recording (enter recording endtime)"), "manualendtime"), \
1517 (_("don't record"), "no")])
1519 from Tools.ISO639 import LanguageCodes
1521 class InfoBarAudioSelection:
1523 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1525 "audioSelection": (self.audioSelection, _("Audio Options...")),
1528 def audioSelection(self):
1529 service = self.session.nav.getCurrentService()
1530 audio = service and service.audioTracks()
1531 self.audioTracks = audio
1532 n = audio and audio.getNumberOfTracks() or 0
1533 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1536 self.audioChannel = service.audioChannel()
1539 i = audio.getTrackInfo(x)
1540 language = i.getLanguage()
1541 description = i.getDescription()
1543 if LanguageCodes.has_key(language):
1544 language = LanguageCodes[language][0]
1546 if len(description):
1547 description += " (" + language + ")"
1549 description = language
1551 tlist.append((description, x))
1553 selectedAudio = audio.getCurrentTrack()
1554 tlist.sort(key=lambda x: x[0])
1558 if x[1] != selectedAudio:
1563 tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
1564 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
1566 del self.audioTracks
1568 def audioSelected(self, audio):
1569 if audio is not None:
1570 if isinstance(audio[1], str):
1571 if audio[1] == "mode":
1572 keys = ["red", "green", "yellow"]
1573 selection = self.audioChannel.getCurrentChannel()
1574 tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
1575 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
1577 del self.audioChannel
1578 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1579 self.audioTracks.selectTrack(audio[1])
1581 del self.audioChannel
1582 del self.audioTracks
1584 def modeSelected(self, mode):
1585 if mode is not None:
1586 self.audioChannel.selectChannel(mode[1])
1587 del self.audioChannel
1589 class InfoBarSubserviceSelection:
1591 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1593 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1596 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1598 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1599 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1601 self["SubserviceQuickzapAction"].setEnabled(False)
1603 self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
1607 def checkSubservicesAvail(self, ev):
1608 if ev == iPlayableService.evUpdatedEventInfo:
1609 service = self.session.nav.getCurrentService()
1610 subservices = service and service.subServices()
1611 if not subservices or subservices.getNumberOfSubservices() == 0:
1612 self["SubserviceQuickzapAction"].setEnabled(False)
1614 def nextSubservice(self):
1615 self.changeSubservice(+1)
1617 def prevSubservice(self):
1618 self.changeSubservice(-1)
1620 def changeSubservice(self, direction):
1621 service = self.session.nav.getCurrentService()
1622 subservices = service and service.subServices()
1623 n = subservices and subservices.getNumberOfSubservices()
1626 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1628 if subservices.getSubservice(x).toString() == ref.toString():
1631 selection += direction
1636 newservice = subservices.getSubservice(selection)
1637 if newservice.valid():
1640 self.session.nav.playService(newservice)
1642 def subserviceSelection(self):
1643 service = self.session.nav.getCurrentService()
1644 subservices = service and service.subServices()
1645 self.bouquets = self.servicelist.getBouquetList()
1646 n = subservices and subservices.getNumberOfSubservices()
1649 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1652 i = subservices.getSubservice(x)
1653 if i.toString() == ref.toString():
1655 tlist.append((i.getName(), i))
1657 if self.bouquets and len(self.bouquets):
1658 keys = ["red", "green", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1659 if config.usage.multibouquet.value:
1660 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1662 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1665 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1666 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1669 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys)
1671 def subserviceSelected(self, service):
1673 if not service is None:
1674 if isinstance(service[1], str):
1675 if service[1] == "quickzap":
1676 from Screens.SubservicesQuickzap import SubservicesQuickzap
1677 self.session.open(SubservicesQuickzap, service[2])
1679 self["SubserviceQuickzapAction"].setEnabled(True)
1680 self.session.nav.playService(service[1])
1682 def addSubserviceToBouquetCallback(self, service):
1683 if len(service) > 1 and isinstance(service[1], eServiceReference):
1684 self.selectedSubservice = service
1685 if self.bouquets is None:
1688 cnt = len(self.bouquets)
1689 if cnt > 1: # show bouquet list
1690 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1691 elif cnt == 1: # add to only one existing bouquet
1692 self.addSubserviceToBouquet(self.bouquets[0][1])
1693 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1695 def bouquetSelClosed(self, confirmed):
1697 del self.selectedSubservice
1699 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1701 def addSubserviceToBouquet(self, dest):
1702 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1704 self.bsel.close(True)
1706 del self.selectedSubservice
1708 class InfoBarAdditionalInfo:
1711 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
1712 self["TimeshiftPossible"] = self["RecordingPossible"]
1713 self["ExtensionsAvailable"] = Boolean(fixed=1)
1715 class InfoBarNotifications:
1717 self.onExecBegin.append(self.checkNotifications)
1718 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1719 self.onClose.append(self.__removeNotification)
1721 def __removeNotification(self):
1722 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1724 def checkNotificationsIfExecing(self):
1726 self.checkNotifications()
1728 def checkNotifications(self):
1729 if len(Notifications.notifications):
1730 n = Notifications.notifications[0]
1732 Notifications.notifications = Notifications.notifications[1:]
1735 if n[3].has_key("onSessionOpenCallback"):
1736 n[3]["onSessionOpenCallback"]()
1737 del n[3]["onSessionOpenCallback"]
1740 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1742 dlg = self.session.open(n[1], *n[2], **n[3])
1744 # remember that this notification is currently active
1746 Notifications.current_notifications.append(d)
1747 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1749 def __notificationClosed(self, d):
1750 Notifications.current_notifications.remove(d)
1752 class InfoBarServiceNotifications:
1754 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1756 iPlayableService.evEnd: self.serviceHasEnded
1759 def serviceHasEnded(self):
1760 print "service end!"
1763 self.setSeekState(self.SEEK_STATE_PLAY)
1767 class InfoBarCueSheetSupport:
1773 ENABLE_RESUME_SUPPORT = False
1775 def __init__(self, actionmap = "InfobarCueSheetActions"):
1776 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1778 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1779 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1780 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1784 self.is_closing = False
1785 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1787 iPlayableService.evStart: self.__serviceStarted,
1790 def __serviceStarted(self):
1793 print "new service started! trying to download cuts!"
1794 self.downloadCuesheet()
1796 if self.ENABLE_RESUME_SUPPORT:
1799 for (pts, what) in self.cut_list:
1800 if what == self.CUT_TYPE_LAST:
1803 if last is not None:
1804 self.resume_point = last
1805 if config.usage.on_movie_start.value == "ask":
1806 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1807 elif config.usage.on_movie_start.value == "resume":
1808 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1809 # TRANSLATORS: at the start of a movie, when the user has selected
1810 # TRANSLATORS: "Resume from last position" as start behavior.
1811 # TRANSLATORS: The purpose is to notify the user that the movie starts
1812 # TRANSLATORS: in the middle somewhere and not from the beginning.
1813 # TRANSLATORS: (Some translators seem to have interpreted it as a
1814 # TRANSLATORS: question or a choice, but it is a statement.)
1815 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1817 def playLastCB(self, answer):
1819 self.doSeek(self.resume_point)
1820 self.hideAfterResume()
1822 def hideAfterResume(self):
1823 if isinstance(self, InfoBarShowHide):
1826 def __getSeekable(self):
1827 service = self.session.nav.getCurrentService()
1830 return service.seek()
1832 def cueGetCurrentPosition(self):
1833 seek = self.__getSeekable()
1836 r = seek.getPlayPosition()
1841 def cueGetEndCutPosition(self):
1844 for cp in self.cut_list:
1845 if cp[1] == self.CUT_TYPE_OUT:
1849 elif cp[1] == self.CUT_TYPE_IN:
1853 def jumpPreviousNextMark(self, cmp, start=False):
1854 current_pos = self.cueGetCurrentPosition()
1855 if current_pos is None:
1857 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
1858 if mark is not None:
1866 def jumpPreviousMark(self):
1867 # we add 2 seconds, so if the play position is <2s after
1868 # the mark, the mark before will be used
1869 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
1871 def jumpNextMark(self):
1872 if not self.jumpPreviousNextMark(lambda x: x):
1875 def getNearestCutPoint(self, pts, cmp=abs, start=False):
1881 bestdiff = cmp(0 - pts)
1883 nearest = [0, False]
1884 for cp in self.cut_list:
1885 if beforecut and cp[1] in [self.CUT_TYPE_IN, self.CUT_TYPE_OUT]:
1887 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
1888 diff = cmp(cp[0] - pts)
1894 if cp[1] in [self.CUT_TYPE_MARK, self.CUT_TYPE_LAST]:
1895 diff = cmp(cp[0] - pts)
1896 if diff >= 0 and (nearest is None or bestdiff > diff):
1901 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
1902 current_pos = self.cueGetCurrentPosition()
1903 if current_pos is None:
1904 print "not seekable"
1907 nearest_cutpoint = self.getNearestCutPoint(current_pos)
1909 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
1911 return nearest_cutpoint
1913 self.removeMark(nearest_cutpoint)
1914 elif not onlyremove and not onlyreturn:
1915 self.addMark((current_pos, self.CUT_TYPE_MARK))
1920 def addMark(self, point):
1921 insort(self.cut_list, point)
1922 self.uploadCuesheet()
1923 self.showAfterCuesheetOperation()
1925 def removeMark(self, point):
1926 self.cut_list.remove(point)
1927 self.uploadCuesheet()
1928 self.showAfterCuesheetOperation()
1930 def showAfterCuesheetOperation(self):
1931 if isinstance(self, InfoBarShowHide):
1934 def __getCuesheet(self):
1935 service = self.session.nav.getCurrentService()
1938 return service.cueSheet()
1940 def uploadCuesheet(self):
1941 cue = self.__getCuesheet()
1944 print "upload failed, no cuesheet interface"
1946 cue.setCutList(self.cut_list)
1948 def downloadCuesheet(self):
1949 cue = self.__getCuesheet()
1952 print "download failed, no cuesheet interface"
1955 self.cut_list = cue.getCutList()
1957 class InfoBarSummary(Screen):
1959 <screen position="0,0" size="132,64">
1960 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
1961 <convert type="ClockToText">WithSeconds</convert>
1963 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
1964 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
1965 <convert type="ConditionalShowHide">Blink</convert>
1967 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
1968 <convert type="ServiceName">Name</convert>
1970 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
1971 <convert type="EventTime">Progress</convert>
1975 # for picon: (path="piconlcd" will use LCD picons)
1976 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
1977 # <convert type="ServiceName">Reference</convert>
1980 def __init__(self, session, parent):
1981 Screen.__init__(self, session, parent = parent)
1983 class InfoBarSummarySupport:
1987 def createSummary(self):
1988 return InfoBarSummary
1990 class InfoBarMoviePlayerSummary(Screen):
1992 <screen position="0,0" size="132,64">
1993 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
1994 <convert type="ClockToText">WithSeconds</convert>
1996 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
1997 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
1998 <convert type="ConditionalShowHide">Blink</convert>
2000 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2001 <convert type="ServiceName">Name</convert>
2003 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2004 <convert type="ServicePosition">Position</convert>
2008 def __init__(self, session, parent):
2009 Screen.__init__(self, session)
2011 class InfoBarMoviePlayerSummarySupport:
2015 def createSummary(self):
2016 return InfoBarMoviePlayerSummary
2018 class InfoBarTeletextPlugin:
2020 self.teletext_plugin = None
2022 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2023 self.teletext_plugin = p
2025 if self.teletext_plugin is not None:
2026 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2028 "startTeletext": (self.startTeletext, _("View teletext..."))
2031 print "no teletext plugin found!"
2033 def startTeletext(self):
2034 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2036 class InfoBarSubtitleSupport(object):
2038 object.__init__(self)
2039 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2040 self.__subtitles_enabled = False
2042 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2044 iPlayableService.evEnd: self.__serviceStopped,
2045 iPlayableService.evUpdatedInfo: self.__updatedInfo
2047 self.cached_subtitle_checked = False
2048 self.__selected_subtitle = None
2050 def __serviceStopped(self):
2051 self.subtitle_window.hide()
2052 self.__subtitles_enabled = False
2053 self.cached_subtitle_checked = False
2055 def __updatedInfo(self):
2056 if not self.cached_subtitle_checked:
2057 subtitle = self.getCurrentServiceSubtitle()
2058 self.cached_subtitle_checked = True
2059 self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()
2060 if self.__selected_subtitle:
2061 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2062 self.subtitle_window.show()
2063 self.__subtitles_enabled = True
2065 def getCurrentServiceSubtitle(self):
2066 service = self.session.nav.getCurrentService()
2067 return service and service.subtitle()
2069 def setSubtitlesEnable(self, enable=True):
2070 subtitle = self.getCurrentServiceSubtitle()
2071 if enable and self.__selected_subtitle is not None:
2072 if subtitle and not self.__subtitles_enabled:
2073 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2074 self.subtitle_window.show()
2075 self.__subtitles_enabled = True
2078 subtitle.disableSubtitles(self.subtitle_window.instance)
2079 self.__subtitles_enabled = False
2080 self.subtitle_window.hide()
2082 def setSelectedSubtitle(self, subtitle):
2083 self.__selected_subtitle = subtitle
2085 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2086 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2088 class InfoBarServiceErrorPopupSupport:
2090 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2092 iPlayableService.evTuneFailed: self.__tuneFailed,
2093 iPlayableService.evStart: self.__serviceStarted
2095 self.__serviceStarted()
2097 def __serviceStarted(self):
2098 self.last_error = None
2099 Notifications.RemovePopup(id = "ZapError")
2101 def __tuneFailed(self):
2102 service = self.session.nav.getCurrentService()
2103 info = service and service.info()
2104 error = info and info.getInfo(iServiceInformation.sDVBState)
2106 if error == self.last_error:
2109 self.last_error = error
2112 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2113 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2114 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2115 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2116 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2117 eDVBServicePMTHandler.eventNewProgramInfo: None,
2118 eDVBServicePMTHandler.eventTuned: None,
2119 eDVBServicePMTHandler.eventSOF: None,
2120 eDVBServicePMTHandler.eventEOF: None,
2121 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2124 error = errors.get(error) #this returns None when the key not exist in the dict
2126 if error is not None:
2127 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2129 Notifications.RemovePopup(id = "ZapError")