1 from ChannelSelection import ChannelSelection, BouquetSelector
3 from Components.ActionMap import ActionMap, HelpableActionMap
4 from Components.ActionMap import NumberActionMap
5 from Components.Harddisk import harddiskmanager
6 from Components.Input import Input
7 from Components.Label import Label
8 from Components.PluginComponent import plugins
9 from Components.ServiceEventTracker import ServiceEventTracker
10 from Components.Sources.Boolean import Boolean
11 from Components.config import config, ConfigBoolean, ConfigClock
12 from Components.SystemInfo import SystemInfo
13 from Components.UsageConfig import preferredInstantRecordPath, defaultMoviePath
14 from EpgSelection import EPGSelection
15 from Plugins.Plugin import PluginDescriptor
17 from Screen import Screen
18 from Screens.ChoiceBox import ChoiceBox
19 from Screens.Dish import Dish
20 from Screens.EventView import EventViewEPGSelect, EventViewSimple
21 from Screens.InputBox import InputBox
22 from Screens.MessageBox import MessageBox
23 from Screens.MinuteInput import MinuteInput
24 from Screens.TimerSelection import TimerSelection
25 from Screens.PictureInPicture import PictureInPicture
26 from Screens.SubtitleDisplay import SubtitleDisplay
27 from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
28 from Screens.TimeDateInput import TimeDateInput
29 from Screens.UnhandledKey import UnhandledKey
30 from ServiceReference import ServiceReference
32 from Tools import Notifications
33 from Tools.Directories import fileExists
35 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
36 iPlayableService, eServiceReference, eEPGCache, eActionMap
38 from time import time, localtime, strftime
39 from os import stat as os_stat
40 from bisect import insort
42 from RecordTimer import RecordTimerEntry, RecordTimer
45 from Menu import MainMenu, mdom
49 self.dishDialog = self.session.instantiateDialog(Dish)
51 class InfoBarUnhandledKey:
53 self.unhandledKeyDialog = self.session.instantiateDialog(UnhandledKey)
54 self.hideTimer = eTimer()
55 self.hideTimer.callback.append(self.unhandledKeyDialog.hide)
56 self.checkUnusedTimer = eTimer()
57 self.checkUnusedTimer.callback.append(self.checkUnused)
58 self.onLayoutFinish.append(self.unhandledKeyDialog.hide)
59 eActionMap.getInstance().bindAction('', -0x7FFFFFFF, self.actionA) #highest prio
60 eActionMap.getInstance().bindAction('', 0x7FFFFFFF, self.actionB) #lowest prio
65 #this function is called on every keypress!
66 def actionA(self, key, flag):
70 self.flags = self.uflags = 0
71 self.flags |= (1<<flag)
73 self.checkUnusedTimer.start(0, True)
76 #this function is only called when no other action has handled this key
77 def actionB(self, key, flag):
79 self.uflags |= (1<<flag)
81 def checkUnused(self):
82 if self.flags == self.uflags:
83 self.unhandledKeyDialog.show()
84 self.hideTimer.start(2000, True)
86 class InfoBarShowHide:
87 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
95 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
97 "toggleShow": self.toggleShow,
99 }, 1) # lower prio to make it possible to override ok and cancel..
101 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
103 iPlayableService.evStart: self.serviceStarted,
106 self.__state = self.STATE_SHOWN
109 self.hideTimer = eTimer()
110 self.hideTimer.callback.append(self.doTimerHide)
111 self.hideTimer.start(5000, True)
113 self.onShow.append(self.__onShow)
114 self.onHide.append(self.__onHide)
116 def serviceStarted(self):
118 if config.usage.show_infobar_on_zap.value:
122 self.__state = self.STATE_SHOWN
123 self.startHideTimer()
125 def startHideTimer(self):
126 if self.__state == self.STATE_SHOWN and not self.__locked:
127 idx = config.usage.infobar_timeout.index
129 self.hideTimer.start(idx*1000, True)
132 self.__state = self.STATE_HIDDEN
136 self.startHideTimer()
138 def doTimerHide(self):
139 self.hideTimer.stop()
140 if self.__state == self.STATE_SHOWN:
143 def toggleShow(self):
144 if self.__state == self.STATE_SHOWN:
146 self.hideTimer.stop()
147 elif self.__state == self.STATE_HIDDEN:
151 self.__locked = self.__locked + 1
154 self.hideTimer.stop()
156 def unlockShow(self):
157 self.__locked = self.__locked - 1
159 self.startHideTimer()
161 # def startShow(self):
162 # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
163 # self.__state = self.STATE_SHOWN
165 # def startHide(self):
166 # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
167 # self.__state = self.STATE_HIDDEN
169 class NumberZap(Screen):
176 self.close(int(self["number"].getText()))
178 def keyNumberGlobal(self, number):
179 self.Timer.start(3000, True) #reset timer
180 self.field = self.field + str(number)
181 self["number"].setText(self.field)
182 if len(self.field) >= 4:
185 def __init__(self, session, number):
186 Screen.__init__(self, session)
187 self.field = str(number)
189 self["channel"] = Label(_("Channel:"))
191 self["number"] = Label(self.field)
193 self["actions"] = NumberActionMap( [ "SetupActions" ],
197 "1": self.keyNumberGlobal,
198 "2": self.keyNumberGlobal,
199 "3": self.keyNumberGlobal,
200 "4": self.keyNumberGlobal,
201 "5": self.keyNumberGlobal,
202 "6": self.keyNumberGlobal,
203 "7": self.keyNumberGlobal,
204 "8": self.keyNumberGlobal,
205 "9": self.keyNumberGlobal,
206 "0": self.keyNumberGlobal
209 self.Timer = eTimer()
210 self.Timer.callback.append(self.keyOK)
211 self.Timer.start(3000, True)
213 class InfoBarNumberZap:
214 """ Handles an initial number for NumberZapping """
216 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
218 "1": self.keyNumberGlobal,
219 "2": self.keyNumberGlobal,
220 "3": self.keyNumberGlobal,
221 "4": self.keyNumberGlobal,
222 "5": self.keyNumberGlobal,
223 "6": self.keyNumberGlobal,
224 "7": self.keyNumberGlobal,
225 "8": self.keyNumberGlobal,
226 "9": self.keyNumberGlobal,
227 "0": self.keyNumberGlobal,
230 def keyNumberGlobal(self, number):
231 # print "You pressed number " + str(number)
233 if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
234 self.pipDoHandle0Action()
236 self.servicelist.recallPrevService()
238 if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
239 self.session.openWithCallback(self.numberEntered, NumberZap, number)
241 def numberEntered(self, retval):
242 # print self.servicelist
244 self.zapToNumber(retval)
246 def searchNumberHelper(self, serviceHandler, num, bouquet):
247 servicelist = serviceHandler.list(bouquet)
248 if not servicelist is None:
250 serviceIterator = servicelist.getNext()
251 if not serviceIterator.valid(): #check end of list
253 playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
256 if not num: #found service with searched number ?
257 return serviceIterator, 0
260 def zapToNumber(self, number):
261 bouquet = self.servicelist.bouquet_root
263 serviceHandler = eServiceCenter.getInstance()
264 if not config.usage.multibouquet.value:
265 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
267 bouquetlist = serviceHandler.list(bouquet)
268 if not bouquetlist is None:
270 bouquet = bouquetlist.getNext()
271 if not bouquet.valid(): #check end of list
273 if bouquet.flags & eServiceReference.isDirectory:
274 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
275 if not service is None:
276 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
277 self.servicelist.clearPath()
278 if self.servicelist.bouquet_root != bouquet:
279 self.servicelist.enterPath(self.servicelist.bouquet_root)
280 self.servicelist.enterPath(bouquet)
281 self.servicelist.setCurrentSelection(service) #select the service in servicelist
282 self.servicelist.zap()
284 config.misc.initialchannelselection = ConfigBoolean(default = True)
286 class InfoBarChannelSelection:
287 """ ChannelSelection - handles the channelSelection dialog and the initial
288 channelChange actions which open the channelSelection dialog """
291 self.servicelist = self.session.instantiateDialog(ChannelSelection)
293 if config.misc.initialchannelselection.value:
294 self.onShown.append(self.firstRun)
296 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
298 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
299 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
300 "zapUp": (self.zapUp, _("previous channel")),
301 "zapDown": (self.zapDown, _("next channel")),
302 "historyBack": (self.historyBack, _("previous channel in history")),
303 "historyNext": (self.historyNext, _("next channel in history")),
304 "openServiceList": (self.openServiceList, _("open servicelist")),
307 def showTvChannelList(self, zap=False):
308 self.servicelist.setModeTv()
310 self.servicelist.zap()
311 self.session.execDialog(self.servicelist)
313 def showRadioChannelList(self, zap=False):
314 self.servicelist.setModeRadio()
316 self.servicelist.zap()
317 self.session.execDialog(self.servicelist)
320 self.onShown.remove(self.firstRun)
321 config.misc.initialchannelselection.value = False
322 config.misc.initialchannelselection.save()
323 self.switchChannelDown()
325 def historyBack(self):
326 self.servicelist.historyBack()
328 def historyNext(self):
329 self.servicelist.historyNext()
331 def switchChannelUp(self):
332 self.servicelist.moveUp()
333 self.session.execDialog(self.servicelist)
335 def switchChannelDown(self):
336 self.servicelist.moveDown()
337 self.session.execDialog(self.servicelist)
339 def openServiceList(self):
340 self.session.execDialog(self.servicelist)
343 if self.servicelist.inBouquet():
344 prev = self.servicelist.getCurrentSelection()
346 prev = prev.toString()
348 if config.usage.quickzap_bouquet_change.value:
349 if self.servicelist.atBegin():
350 self.servicelist.prevBouquet()
351 self.servicelist.moveUp()
352 cur = self.servicelist.getCurrentSelection()
353 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
356 self.servicelist.moveUp()
357 self.servicelist.zap()
360 if self.servicelist.inBouquet():
361 prev = self.servicelist.getCurrentSelection()
363 prev = prev.toString()
365 if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
366 self.servicelist.nextBouquet()
368 self.servicelist.moveDown()
369 cur = self.servicelist.getCurrentSelection()
370 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
373 self.servicelist.moveDown()
374 self.servicelist.zap()
377 """ Handles a menu action, to open the (main) menu """
379 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
381 "mainMenu": (self.mainMenu, _("Enter main menu...")),
383 self.session.infobar = None
386 print "loading mainmenu XML..."
387 menu = mdom.getroot()
388 assert menu.tag == "menu", "root element in menu must be 'menu'!"
390 self.session.infobar = self
391 # so we can access the currently active infobar from screens opened from within the mainmenu
392 # at the moment used from the SubserviceSelection
394 self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)
396 def mainMenuClosed(self, *val):
397 self.session.infobar = None
399 class InfoBarSimpleEventView:
400 """ Opens the Eventview for now/next """
402 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
404 "showEventInfo": (self.openEventView, _("show event details")),
405 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
408 def showEventInfoWhenNotVisible(self):
415 def openEventView(self):
417 self.epglist = epglist
418 service = self.session.nav.getCurrentService()
419 ref = self.session.nav.getCurrentlyPlayingServiceReference()
420 info = service.info()
428 self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
430 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
431 epglist = self.epglist
434 epglist[0] = epglist[1]
438 class SimpleServicelist:
439 def __init__(self, services):
440 self.services = services
441 self.length = len(services)
444 def selectService(self, service):
450 while self.services[self.current].ref != service:
452 if self.current >= self.length:
456 def nextService(self):
459 if self.current+1 < self.length:
464 def prevService(self):
467 if self.current-1 > -1:
470 self.current = self.length - 1
472 def currentService(self):
473 if not self.length or self.current >= self.length:
475 return self.services[self.current]
478 """ EPG - Opens an EPG list when the showEPGList action fires """
480 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
482 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
485 self.is_now_next = False
487 self.bouquetSel = None
488 self.eventView = None
489 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
491 "showEventInfo": (self.openEventView, _("show EPG...")),
492 "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
493 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
496 def showEventInfoWhenNotVisible(self):
503 def zapToService(self, service):
504 if not service is None:
505 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
506 self.servicelist.clearPath()
507 if self.servicelist.bouquet_root != self.epg_bouquet:
508 self.servicelist.enterPath(self.servicelist.bouquet_root)
509 self.servicelist.enterPath(self.epg_bouquet)
510 self.servicelist.setCurrentSelection(service) #select the service in servicelist
511 self.servicelist.zap()
513 def getBouquetServices(self, bouquet):
515 servicelist = eServiceCenter.getInstance().list(bouquet)
516 if not servicelist is None:
518 service = servicelist.getNext()
519 if not service.valid(): #check if end of list
521 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
523 services.append(ServiceReference(service))
526 def openBouquetEPG(self, bouquet, withCallback=True):
527 services = self.getBouquetServices(bouquet)
529 self.epg_bouquet = bouquet
531 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
533 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
535 def changeBouquetCB(self, direction, epg):
538 self.bouquetSel.down()
541 bouquet = self.bouquetSel.getCurrent()
542 services = self.getBouquetServices(bouquet)
544 self.epg_bouquet = bouquet
545 epg.setServices(services)
547 def closed(self, ret=False):
548 closedScreen = self.dlg_stack.pop()
549 if self.bouquetSel and closedScreen == self.bouquetSel:
550 self.bouquetSel = None
551 elif self.eventView and closedScreen == self.eventView:
552 self.eventView = None
554 dlgs=len(self.dlg_stack)
556 self.dlg_stack[dlgs-1].close(dlgs > 1)
558 def openMultiServiceEPG(self, withCallback=True):
559 bouquets = self.servicelist.getBouquetList()
564 if cnt > 1: # show bouquet list
566 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
567 self.dlg_stack.append(self.bouquetSel)
569 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
571 self.openBouquetEPG(bouquets[0][1], withCallback)
573 def changeServiceCB(self, direction, epg):
576 self.serviceSel.nextService()
578 self.serviceSel.prevService()
579 epg.setService(self.serviceSel.currentService())
581 def SingleServiceEPGClosed(self, ret=False):
582 self.serviceSel = None
584 def openSingleServiceEPG(self):
585 ref=self.session.nav.getCurrentlyPlayingServiceReference()
587 if self.servicelist.getMutableList() is not None: # bouquet in channellist
588 current_path = self.servicelist.getRoot()
589 services = self.getBouquetServices(current_path)
590 self.serviceSel = SimpleServicelist(services)
591 if self.serviceSel.selectService(ref):
592 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
594 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref)
596 self.session.open(EPGSelection, ref)
598 def showEventInfoPlugins(self):
599 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
602 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
603 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
605 self.openSingleServiceEPG()
607 def runPlugin(self, plugin):
608 plugin(session = self.session, servicelist = self.servicelist)
610 def EventInfoPluginChosen(self, answer):
611 if answer is not None:
614 def openSimilarList(self, eventid, refstr):
615 self.session.open(EPGSelection, refstr, None, eventid)
617 def getNowNext(self):
619 service = self.session.nav.getCurrentService()
620 info = service and service.info()
621 ptr = info and info.getEvent(0)
624 ptr = info and info.getEvent(1)
627 self.epglist = epglist
629 def __evEventInfoChanged(self):
630 if self.is_now_next and len(self.dlg_stack) == 1:
632 assert self.eventView
634 self.eventView.setEvent(self.epglist[0])
636 def openEventView(self):
637 ref = self.session.nav.getCurrentlyPlayingServiceReference()
639 epglist = self.epglist
641 self.is_now_next = False
642 epg = eEPGCache.getInstance()
643 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
646 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
650 self.is_now_next = True
652 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
653 self.dlg_stack.append(self.eventView)
655 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
656 self.openMultiServiceEPG(False)
658 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
659 epglist = self.epglist
662 epglist[0]=epglist[1]
666 class InfoBarRdsDecoder:
667 """provides RDS and Rass support/display"""
669 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
670 self.rass_interactive = None
672 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
674 iPlayableService.evEnd: self.__serviceStopped,
675 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
678 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
680 "startRassInteractive": self.startRassInteractive
683 self["RdsActions"].setEnabled(False)
685 self.onLayoutFinish.append(self.rds_display.show)
686 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
688 def RassInteractivePossibilityChanged(self, state):
689 self["RdsActions"].setEnabled(state)
691 def RassSlidePicChanged(self):
692 if not self.rass_interactive:
693 service = self.session.nav.getCurrentService()
694 decoder = service and service.rdsDecoder()
696 decoder.showRassSlidePicture()
698 def __serviceStopped(self):
699 if self.rass_interactive is not None:
700 rass_interactive = self.rass_interactive
701 self.rass_interactive = None
702 rass_interactive.close()
704 def startRassInteractive(self):
705 self.rds_display.hide()
706 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
708 def RassInteractiveClosed(self, *val):
709 if self.rass_interactive is not None:
710 self.rass_interactive = None
711 self.RassSlidePicChanged()
712 self.rds_display.show()
715 """handles actions like seeking, pause"""
717 SEEK_STATE_PLAY = (0, 0, 0, ">")
718 SEEK_STATE_PAUSE = (1, 0, 0, "||")
719 SEEK_STATE_EOF = (1, 0, 0, "END")
721 def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
722 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
724 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
725 iPlayableService.evStart: self.__serviceStarted,
727 iPlayableService.evEOF: self.__evEOF,
728 iPlayableService.evSOF: self.__evSOF,
730 self.fast_winding_hint_message_showed = False
732 class InfoBarSeekActionMap(HelpableActionMap):
733 def __init__(self, screen, *args, **kwargs):
734 HelpableActionMap.__init__(self, screen, *args, **kwargs)
737 def action(self, contexts, action):
738 print "action:", action
739 if action[:5] == "seek:":
740 time = int(action[5:])
741 self.screen.doSeekRelative(time * 90000)
743 elif action[:8] == "seekdef:":
744 key = int(action[8:])
745 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
746 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
747 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
748 self.screen.doSeekRelative(time * 90000)
751 return HelpableActionMap.action(self, contexts, action)
753 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
755 "playpauseService": self.playpauseService,
756 "pauseService": (self.pauseService, _("pause")),
757 "unPauseService": (self.unPauseService, _("continue")),
759 "seekFwd": (self.seekFwd, _("skip forward")),
760 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
761 "seekBack": (self.seekBack, _("skip backward")),
762 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
764 # give them a little more priority to win over color buttons
766 self["SeekActions"].setEnabled(False)
768 self.seekstate = self.SEEK_STATE_PLAY
769 self.lastseekstate = self.SEEK_STATE_PLAY
771 self.onPlayStateChanged = [ ]
773 self.lockedBecauseOfSkipping = False
775 self.__seekableStatusChanged()
777 def makeStateForward(self, n):
778 # minspeed = config.seek.stepwise_minspeed.value
779 # repeat = int(config.seek.stepwise_repeat.value)
780 # if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
781 # return (0, n * repeat, repeat, ">> %dx" % n)
783 return (0, n, 0, ">> %dx" % n)
785 def makeStateBackward(self, n):
786 # minspeed = config.seek.stepwise_minspeed.value
787 # repeat = int(config.seek.stepwise_repeat.value)
788 # if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
789 # return (0, -n * repeat, repeat, "<< %dx" % n)
791 return (0, -n, 0, "<< %dx" % n)
793 def makeStateSlowMotion(self, n):
794 return (0, 0, n, "/%d" % n)
796 def isStateForward(self, state):
799 def isStateBackward(self, state):
802 def isStateSlowMotion(self, state):
803 return state[1] == 0 and state[2] > 1
805 def getHigher(self, n, lst):
811 def getLower(self, n, lst):
819 def showAfterSeek(self):
820 if isinstance(self, InfoBarShowHide):
830 service = self.session.nav.getCurrentService()
834 seek = service.seek()
836 if seek is None or not seek.isCurrentlySeekable():
841 def isSeekable(self):
842 if self.getSeek() is None:
846 def __seekableStatusChanged(self):
847 # print "seekable status changed!"
848 if not self.isSeekable():
849 self["SeekActions"].setEnabled(False)
850 # print "not seekable, return to play"
851 self.setSeekState(self.SEEK_STATE_PLAY)
853 self["SeekActions"].setEnabled(True)
856 def __serviceStarted(self):
857 self.fast_winding_hint_message_showed = False
858 self.seekstate = self.SEEK_STATE_PLAY
859 self.__seekableStatusChanged()
861 def setSeekState(self, state):
862 service = self.session.nav.getCurrentService()
867 if not self.isSeekable():
868 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
869 state = self.SEEK_STATE_PLAY
871 pauseable = service.pause()
873 if pauseable is None:
874 print "not pauseable."
875 state = self.SEEK_STATE_PLAY
877 self.seekstate = state
879 if pauseable is not None:
880 if self.seekstate[0]:
881 print "resolved to PAUSE"
883 elif self.seekstate[1]:
884 print "resolved to FAST FORWARD"
885 pauseable.setFastForward(self.seekstate[1])
886 elif self.seekstate[2]:
887 print "resolved to SLOW MOTION"
888 pauseable.setSlowMotion(self.seekstate[2])
890 print "resolved to PLAY"
893 for c in self.onPlayStateChanged:
896 self.checkSkipShowHideLock()
900 def playpauseService(self):
901 if self.seekstate != self.SEEK_STATE_PLAY:
902 self.unPauseService()
906 def pauseService(self):
907 if self.seekstate == self.SEEK_STATE_PAUSE:
908 if config.seek.on_pause.value == "play":
909 self.unPauseService()
910 elif config.seek.on_pause.value == "step":
911 self.doSeekRelative(1)
912 elif config.seek.on_pause.value == "last":
913 self.setSeekState(self.lastseekstate)
914 self.lastseekstate = self.SEEK_STATE_PLAY
916 if self.seekstate != self.SEEK_STATE_EOF:
917 self.lastseekstate = self.seekstate
918 self.setSeekState(self.SEEK_STATE_PAUSE);
920 def unPauseService(self):
922 if self.seekstate == self.SEEK_STATE_PLAY:
924 self.setSeekState(self.SEEK_STATE_PLAY)
926 def doSeek(self, pts):
927 seekable = self.getSeek()
932 def doSeekRelative(self, pts):
933 seekable = self.getSeek()
936 prevstate = self.seekstate
938 if self.seekstate == self.SEEK_STATE_EOF:
939 if prevstate == self.SEEK_STATE_PAUSE:
940 self.setSeekState(self.SEEK_STATE_PAUSE)
942 self.setSeekState(self.SEEK_STATE_PLAY)
943 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
944 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
948 seek = self.getSeek()
949 if seek and not (seek.isCurrentlySeekable() & 2):
950 if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
951 self.session.open(MessageBox, _("No fast winding possible yet.. but you can use the number buttons to skip forward/backward!"), MessageBox.TYPE_INFO, timeout=10)
952 self.fast_winding_hint_message_showed = True
954 return 0 # trade as unhandled action
955 if self.seekstate == self.SEEK_STATE_PLAY:
956 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
957 elif self.seekstate == self.SEEK_STATE_PAUSE:
958 if len(config.seek.speeds_slowmotion.value):
959 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
961 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
962 elif self.seekstate == self.SEEK_STATE_EOF:
964 elif self.isStateForward(self.seekstate):
965 speed = self.seekstate[1]
966 if self.seekstate[2]:
967 speed /= self.seekstate[2]
968 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
969 self.setSeekState(self.makeStateForward(speed))
970 elif self.isStateBackward(self.seekstate):
971 speed = -self.seekstate[1]
972 if self.seekstate[2]:
973 speed /= self.seekstate[2]
974 speed = self.getLower(speed, config.seek.speeds_backward.value)
976 self.setSeekState(self.makeStateBackward(speed))
978 self.setSeekState(self.SEEK_STATE_PLAY)
979 elif self.isStateSlowMotion(self.seekstate):
980 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
981 self.setSeekState(self.makeStateSlowMotion(speed))
984 seek = self.getSeek()
985 if seek and not (seek.isCurrentlySeekable() & 2):
986 if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
987 self.session.open(MessageBox, _("No fast winding possible yet.. but you can use the number buttons to skip forward/backward!"), MessageBox.TYPE_INFO, timeout=10)
988 self.fast_winding_hint_message_showed = True
990 return 0 # trade as unhandled action
991 seekstate = self.seekstate
992 if seekstate == self.SEEK_STATE_PLAY:
993 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
994 elif seekstate == self.SEEK_STATE_EOF:
995 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
996 self.doSeekRelative(-6)
997 elif seekstate == self.SEEK_STATE_PAUSE:
998 self.doSeekRelative(-1)
999 elif self.isStateForward(seekstate):
1000 speed = seekstate[1]
1002 speed /= seekstate[2]
1003 speed = self.getLower(speed, config.seek.speeds_forward.value)
1005 self.setSeekState(self.makeStateForward(speed))
1007 self.setSeekState(self.SEEK_STATE_PLAY)
1008 elif self.isStateBackward(seekstate):
1009 speed = -seekstate[1]
1011 speed /= seekstate[2]
1012 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
1013 self.setSeekState(self.makeStateBackward(speed))
1014 elif self.isStateSlowMotion(seekstate):
1015 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
1017 self.setSeekState(self.makeStateSlowMotion(speed))
1019 self.setSeekState(self.SEEK_STATE_PAUSE)
1021 def seekFwdManual(self):
1022 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
1024 def fwdSeekTo(self, minutes):
1025 print "Seek", minutes, "minutes forward"
1026 self.doSeekRelative(minutes * 60 * 90000)
1028 def seekBackManual(self):
1029 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
1031 def rwdSeekTo(self, minutes):
1033 self.doSeekRelative(-minutes * 60 * 90000)
1035 def checkSkipShowHideLock(self):
1036 wantlock = self.seekstate != self.SEEK_STATE_PLAY
1038 if config.usage.show_infobar_on_skip.value:
1039 if self.lockedBecauseOfSkipping and not wantlock:
1041 self.lockedBecauseOfSkipping = False
1043 if wantlock and not self.lockedBecauseOfSkipping:
1045 self.lockedBecauseOfSkipping = True
1047 def calcRemainingTime(self):
1048 seekable = self.getSeek()
1049 if seekable is not None:
1050 len = seekable.getLength()
1052 tmp = self.cueGetEndCutPosition()
1057 pos = seekable.getPlayPosition()
1058 speednom = self.seekstate[1] or 1
1059 speedden = self.seekstate[2] or 1
1060 if not len[0] and not pos[0]:
1061 if len[1] <= pos[1]:
1063 time = (len[1] - pos[1])*speedden/(90*speednom)
1068 if self.seekstate == self.SEEK_STATE_EOF:
1071 # if we are seeking forward, we try to end up ~1s before the end, and pause there.
1072 seekstate = self.seekstate
1073 if self.seekstate != self.SEEK_STATE_PAUSE:
1074 self.setSeekState(self.SEEK_STATE_EOF)
1076 if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
1077 seekable = self.getSeek()
1078 if seekable is not None:
1080 if seekstate == self.SEEK_STATE_PLAY: # regular EOF
1081 self.doEofInternal(True)
1083 self.doEofInternal(False)
1085 def doEofInternal(self, playing):
1086 pass # Defined in subclasses
1089 self.setSeekState(self.SEEK_STATE_PLAY)
1092 from Screens.PVRState import PVRState, TimeshiftState
1094 class InfoBarPVRState:
1095 def __init__(self, screen=PVRState, force_show = False):
1096 self.onPlayStateChanged.append(self.__playStateChanged)
1097 self.pvrStateDialog = self.session.instantiateDialog(screen)
1098 self.onShow.append(self._mayShow)
1099 self.onHide.append(self.pvrStateDialog.hide)
1100 self.force_show = force_show
1103 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1104 self.pvrStateDialog.show()
1106 def __playStateChanged(self, state):
1107 playstateString = state[3]
1108 self.pvrStateDialog["state"].setText(playstateString)
1110 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
1111 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
1112 self.pvrStateDialog.hide()
1117 class InfoBarTimeshiftState(InfoBarPVRState):
1119 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1122 if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
1123 self.pvrStateDialog.show()
1125 class InfoBarShowMovies:
1127 # i don't really like this class.
1128 # it calls a not further specified "movie list" on up/down/movieList,
1129 # so this is not more than an action map
1131 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1133 "movieList": (self.showMovies, _("movie list")),
1134 "up": (self.showMovies, _("movie list")),
1135 "down": (self.showMovies, _("movie list"))
1138 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1142 # Timeshift works the following way:
1143 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1144 # - normal playback TUNER unused PLAY enable disable disable
1145 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1146 # - user presess pause again FILE record PLAY enable disable enable
1147 # - user fast forwards FILE record FF enable disable enable
1148 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1149 # - user backwards FILE record BACK # !! enable disable enable
1153 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1154 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1155 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1156 # - the user can now PVR around
1157 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1158 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1160 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1161 # - if the user rewinds, or press pause, timeshift will be activated again
1163 # note that a timeshift can be enabled ("recording") and
1164 # activated (currently time-shifting).
1166 class InfoBarTimeshift:
1168 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1170 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1171 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1173 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1175 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1176 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1177 }, prio=-1) # priority over record
1179 self.timeshift_enabled = 0
1180 self.timeshift_state = 0
1181 self.ts_rewind_timer = eTimer()
1182 self.ts_rewind_timer.callback.append(self.rewindService)
1184 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1186 iPlayableService.evStart: self.__serviceStarted,
1187 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1190 def getTimeshift(self):
1191 service = self.session.nav.getCurrentService()
1192 return service and service.timeshift()
1194 def startTimeshift(self):
1195 print "enable timeshift"
1196 ts = self.getTimeshift()
1198 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1199 print "no ts interface"
1202 if self.timeshift_enabled:
1203 print "hu, timeshift already enabled?"
1205 if not ts.startTimeshift():
1206 self.timeshift_enabled = 1
1208 # we remove the "relative time" for now.
1209 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1212 #self.setSeekState(self.SEEK_STATE_PAUSE)
1213 self.activateTimeshiftEnd(False)
1215 # enable the "TimeshiftEnableActions", which will override
1216 # the startTimeshift actions
1217 self.__seekableStatusChanged()
1219 print "timeshift failed"
1221 def stopTimeshift(self):
1222 if not self.timeshift_enabled:
1224 print "disable timeshift"
1225 ts = self.getTimeshift()
1228 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1230 def stopTimeshiftConfirmed(self, confirmed):
1234 ts = self.getTimeshift()
1239 self.timeshift_enabled = 0
1242 self.__seekableStatusChanged()
1244 # activates timeshift, and seeks to (almost) the end
1245 def activateTimeshiftEnd(self, back = True):
1246 ts = self.getTimeshift()
1247 print "activateTimeshiftEnd"
1252 if ts.isTimeshiftActive():
1253 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1257 ts.activateTimeshift() # activate timeshift will automatically pause
1258 self.setSeekState(self.SEEK_STATE_PAUSE)
1261 self.ts_rewind_timer.start(200, 1)
1263 def rewindService(self):
1264 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1266 # same as activateTimeshiftEnd, but pauses afterwards.
1267 def activateTimeshiftEndAndPause(self):
1268 print "activateTimeshiftEndAndPause"
1269 #state = self.seekstate
1270 self.activateTimeshiftEnd(False)
1272 def __seekableStatusChanged(self):
1275 # print "self.isSeekable", self.isSeekable()
1276 # print "self.timeshift_enabled", self.timeshift_enabled
1278 # when this service is not seekable, but timeshift
1279 # is enabled, this means we can activate
1281 if not self.isSeekable() and self.timeshift_enabled:
1284 # print "timeshift activate:", enabled
1285 self["TimeshiftActivateActions"].setEnabled(enabled)
1287 def __serviceStarted(self):
1288 self.timeshift_enabled = False
1289 self.__seekableStatusChanged()
1291 from Screens.PiPSetup import PiPSetup
1293 class InfoBarExtensions:
1294 EXTENSION_SINGLE = 0
1300 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1302 "extensions": (self.showExtensionSelection, _("view extensions...")),
1303 }, 1) # lower priority
1305 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1306 self.list.append((type, extension, key))
1308 def updateExtension(self, extension, key = None):
1309 self.extensionsList.append(extension)
1311 if self.extensionKeys.has_key(key):
1315 for x in self.availableKeys:
1316 if not self.extensionKeys.has_key(x):
1321 self.extensionKeys[key] = len(self.extensionsList) - 1
1323 def updateExtensions(self):
1324 self.extensionsList = []
1325 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1326 self.extensionKeys = {}
1328 if x[0] == self.EXTENSION_SINGLE:
1329 self.updateExtension(x[1], x[2])
1332 self.updateExtension(y[0], y[1])
1335 def showExtensionSelection(self):
1336 self.updateExtensions()
1337 extensionsList = self.extensionsList[:]
1340 for x in self.availableKeys:
1341 if self.extensionKeys.has_key(x):
1342 entry = self.extensionKeys[x]
1343 extension = self.extensionsList[entry]
1345 name = str(extension[0]())
1346 list.append((extension[0](), extension))
1348 extensionsList.remove(extension)
1350 extensionsList.remove(extension)
1351 list.extend([(x[0](), x) for x in extensionsList])
1353 keys += [""] * len(extensionsList)
1354 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
1356 def extensionCallback(self, answer):
1357 if answer is not None:
1360 from Tools.BoundFunction import boundFunction
1362 # depends on InfoBarExtensions
1364 class InfoBarPlugins:
1366 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1368 def getPluginName(self, name):
1371 def getPluginList(self):
1372 list = [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
1373 list.sort(key = lambda e: e[2]) # sort by name
1376 def runPlugin(self, plugin):
1377 if isinstance(self, InfoBarChannelSelection):
1378 plugin(session = self.session, servicelist = self.servicelist)
1380 plugin(session = self.session)
1382 from Components.Task import job_manager
1383 class InfoBarJobman:
1385 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1387 def getJobList(self):
1388 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1390 def getJobName(self, job):
1391 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1393 def showJobView(self, job):
1394 from Screens.TaskView import JobView
1395 job_manager.in_background = False
1396 self.session.openWithCallback(self.JobViewCB, JobView, job)
1398 def JobViewCB(self, in_background):
1399 job_manager.in_background = in_background
1401 # depends on InfoBarExtensions
1405 self.session.pipshown
1407 self.session.pipshown = False
1408 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1410 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1411 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1412 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1414 self.addExtension((self.getShowHideName, self.showPiP, self.pipShown), "blue")
1415 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1418 return self.session.pipshown
1420 def pipHandles0Action(self):
1421 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1423 def getShowHideName(self):
1424 if self.session.pipshown:
1425 return _("Disable Picture in Picture")
1427 return _("Activate Picture in Picture")
1429 def getSwapName(self):
1430 return _("Swap Services")
1432 def getMoveName(self):
1433 return _("Move Picture in Picture")
1436 if self.session.pipshown:
1437 del self.session.pip
1438 self.session.pipshown = False
1440 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1441 self.session.pip.show()
1442 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1443 if self.session.pip.playService(newservice):
1444 self.session.pipshown = True
1445 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1447 self.session.pipshown = False
1448 del self.session.pip
1449 self.session.nav.playService(newservice)
1452 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1453 if self.session.pip.servicePath:
1454 servicepath = self.servicelist.getCurrentServicePath()
1455 ref=servicepath[len(servicepath)-1]
1456 pipref=self.session.pip.getCurrentService()
1457 self.session.pip.playService(swapservice)
1458 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1459 if pipref.toString() != ref.toString(): # is a subservice ?
1460 self.session.nav.stopService() # stop portal
1461 self.session.nav.playService(pipref) # start subservice
1462 self.session.pip.servicePath=servicepath
1465 self.session.open(PiPSetup, pip = self.session.pip)
1467 def pipDoHandle0Action(self):
1468 use = config.usage.pip_zero_button.value
1471 elif "swapstop" == use:
1477 from RecordTimer import parseEvent, RecordTimerEntry
1479 class InfoBarInstantRecord:
1480 """Instant Record - handles the instantRecord action in order to
1481 start/stop instant records"""
1483 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1485 "instantRecord": (self.instantRecord, _("Instant Record...")),
1489 def stopCurrentRecording(self, entry = -1):
1490 if entry is not None and entry != -1:
1491 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1492 self.recording.remove(self.recording[entry])
1494 def startInstantRecording(self, limitEvent = False):
1495 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1497 # try to get event info
1500 service = self.session.nav.getCurrentService()
1501 epg = eEPGCache.getInstance()
1502 event = epg.lookupEventTime(serviceref, -1, 0)
1504 info = service.info()
1505 ev = info.getEvent(0)
1511 end = begin + 3600 # dummy
1512 name = "instant record"
1516 if event is not None:
1517 curEvent = parseEvent(event)
1519 description = curEvent[3]
1520 eventid = curEvent[4]
1525 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1527 if isinstance(serviceref, eServiceReference):
1528 serviceref = ServiceReference(serviceref)
1530 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = preferredInstantRecordPath())
1531 recording.dontSave = True
1533 if event is None or limitEvent == False:
1534 recording.autoincrease = True
1535 if recording.setAutoincreaseEnd():
1536 self.session.nav.RecordTimer.record(recording)
1537 self.recording.append(recording)
1539 simulTimerList = self.session.nav.RecordTimer.record(recording)
1540 if simulTimerList is not None: # conflict with other recording
1541 name = simulTimerList[1].name
1542 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1543 print "[TIMER] conflicts with", name_date
1544 recording.autoincrease = True # start with max available length, then increment
1545 if recording.setAutoincreaseEnd():
1546 self.session.nav.RecordTimer.record(recording)
1547 self.recording.append(recording)
1548 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1550 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1551 recording.autoincrease = False
1553 self.recording.append(recording)
1555 def isInstantRecordRunning(self):
1556 print "self.recording:", self.recording
1558 for x in self.recording:
1563 def recordQuestionCallback(self, answer):
1564 print "pre:\n", self.recording
1566 if answer is None or answer[1] == "no":
1569 recording = self.recording[:]
1571 if not x in self.session.nav.RecordTimer.timer_list:
1572 self.recording.remove(x)
1573 elif x.dontSave and x.isRunning():
1574 list.append((x, False))
1576 if answer[1] == "changeduration":
1577 if len(self.recording) == 1:
1578 self.changeDuration(0)
1580 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1581 elif answer[1] == "changeendtime":
1582 if len(self.recording) == 1:
1585 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1586 elif answer[1] == "stop":
1587 if len(self.recording) == 1:
1588 self.stopCurrentRecording(0)
1590 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1591 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1592 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1593 if answer[1] == "manualduration":
1594 self.changeDuration(len(self.recording)-1)
1595 elif answer[1] == "manualendtime":
1596 self.setEndtime(len(self.recording)-1)
1597 print "after:\n", self.recording
1599 def setEndtime(self, entry):
1600 if entry is not None and entry >= 0:
1601 self.selectedEntry = entry
1602 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1603 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1604 dlg.setTitle(_("Please change recording endtime"))
1606 def TimeDateInputClosed(self, ret):
1609 localendtime = localtime(ret[1])
1610 print "stopping recording at", strftime("%c", localendtime)
1611 if self.recording[self.selectedEntry].end != ret[1]:
1612 self.recording[self.selectedEntry].autoincrease = False
1613 self.recording[self.selectedEntry].end = ret[1]
1614 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1616 def changeDuration(self, entry):
1617 if entry is not None and entry >= 0:
1618 self.selectedEntry = entry
1619 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1621 def inputCallback(self, value):
1622 if value is not None:
1623 print "stopping recording after", int(value), "minutes."
1624 entry = self.recording[self.selectedEntry]
1626 entry.autoincrease = False
1627 entry.end = int(time()) + 60 * int(value)
1628 self.session.nav.RecordTimer.timeChanged(entry)
1630 def instantRecord(self):
1631 dir = preferredInstantRecordPath()
1632 if not dir or not fileExists(dir, 'w'):
1633 dir = defaultMoviePath()
1637 # XXX: this message is a little odd as we might be recording to a remote device
1638 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1641 if self.isInstantRecordRunning():
1642 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1643 title=_("A recording is currently running.\nWhat do you want to do?"), \
1644 list=((_("stop recording"), "stop"), \
1645 (_("add recording (stop after current event)"), "event"), \
1646 (_("add recording (indefinitely)"), "indefinitely"), \
1647 (_("add recording (enter recording duration)"), "manualduration"), \
1648 (_("add recording (enter recording endtime)"), "manualendtime"), \
1649 (_("change recording (duration)"), "changeduration"), \
1650 (_("change recording (endtime)"), "changeendtime"), \
1651 (_("do nothing"), "no")))
1653 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1654 title=_("Start recording?"), \
1655 list=((_("add recording (stop after current event)"), "event"), \
1656 (_("add recording (indefinitely)"), "indefinitely"), \
1657 (_("add recording (enter recording duration)"), "manualduration"), \
1658 (_("add recording (enter recording endtime)"), "manualendtime"), \
1659 (_("don't record"), "no")))
1661 from Tools.ISO639 import LanguageCodes
1663 class InfoBarAudioSelection:
1665 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1667 "audioSelection": (self.audioSelection, _("Audio Options...")),
1670 def audioSelection(self):
1671 service = self.session.nav.getCurrentService()
1672 self.audioTracks = audio = service and service.audioTracks()
1673 n = audio and audio.getNumberOfTracks() or 0
1676 self.audioChannel = service.audioChannel()
1681 i = audio.getTrackInfo(idx)
1682 languages = i.getLanguage().split('/')
1683 description = i.getDescription()
1686 for lang in languages:
1689 if LanguageCodes.has_key(lang):
1690 language += LanguageCodes[lang][0]
1695 if len(description):
1696 description += " (" + language + ")"
1698 description = language
1700 tlist.append((description, idx))
1703 tlist.sort(key=lambda x: x[0])
1705 selectedAudio = self.audioTracks.getCurrentTrack()
1710 if x[1] != selectedAudio:
1718 if SystemInfo["CanDownmixAC3"]:
1719 flist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1720 ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
1721 usedKeys.extend(["red", "green"])
1722 availableKeys.extend(["yellow", "blue"])
1725 flist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
1726 usedKeys.extend(["red"])
1727 availableKeys.extend(["green", "yellow", "blue"])
1730 if hasattr(self, "runPlugin"):
1732 def __init__(self, fnc, *args):
1735 def __call__(self, *args, **kwargs):
1736 self.fnc(*self.args)
1738 Plugins = [ (p.name, PluginCaller(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_AUDIOMENU) ]
1742 flist.append((p[0], "CALLFUNC", p[1]))
1744 usedKeys.append(availableKeys[0])
1745 del availableKeys[0]
1749 flist.append(("--", ""))
1753 keys = usedKeys + [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0" ] + [""] * n
1754 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = flist + tlist, selection = selection, keys = keys, skin_name = "AudioTrackSelection")
1756 del self.audioTracks
1758 def changeAC3Downmix(self, arg):
1759 choicelist = self.session.current_dialog["list"]
1760 list = choicelist.list
1762 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1763 _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
1764 choicelist.setList(list)
1765 if config.av.downmix_ac3.value:
1766 config.av.downmix_ac3.value = False
1768 config.av.downmix_ac3.value = True
1769 config.av.downmix_ac3.save()
1771 def audioSelected(self, audio):
1772 if audio is not None:
1773 if isinstance(audio[1], str):
1774 if audio[1] == "mode":
1775 keys = ["red", "green", "yellow"]
1776 selection = self.audioChannel.getCurrentChannel()
1777 tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
1778 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys, skin_name ="AudioModeSelection")
1780 del self.audioChannel
1781 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1782 self.audioTracks.selectTrack(audio[1])
1784 del self.audioChannel
1785 del self.audioTracks
1787 def modeSelected(self, mode):
1788 if mode is not None:
1789 self.audioChannel.selectChannel(mode[1])
1790 del self.audioChannel
1792 class InfoBarSubserviceSelection:
1794 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1796 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1799 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1801 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1802 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1804 self["SubserviceQuickzapAction"].setEnabled(False)
1806 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1808 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1813 def checkSubservicesAvail(self):
1814 service = self.session.nav.getCurrentService()
1815 subservices = service and service.subServices()
1816 if not subservices or subservices.getNumberOfSubservices() == 0:
1817 self["SubserviceQuickzapAction"].setEnabled(False)
1819 def nextSubservice(self):
1820 self.changeSubservice(+1)
1822 def prevSubservice(self):
1823 self.changeSubservice(-1)
1825 def changeSubservice(self, direction):
1826 service = self.session.nav.getCurrentService()
1827 subservices = service and service.subServices()
1828 n = subservices and subservices.getNumberOfSubservices()
1831 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1834 if subservices.getSubservice(idx).toString() == ref.toString():
1839 selection += direction
1844 newservice = subservices.getSubservice(selection)
1845 if newservice.valid():
1848 self.session.nav.playService(newservice, False)
1850 def subserviceSelection(self):
1851 service = self.session.nav.getCurrentService()
1852 subservices = service and service.subServices()
1853 self.bouquets = self.servicelist.getBouquetList()
1854 n = subservices and subservices.getNumberOfSubservices()
1857 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1861 i = subservices.getSubservice(idx)
1862 if i.toString() == ref.toString():
1864 tlist.append((i.getName(), i))
1867 if self.bouquets and len(self.bouquets):
1868 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1869 if config.usage.multibouquet.value:
1870 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1872 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1875 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1876 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1879 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
1881 def subserviceSelected(self, service):
1883 if not service is None:
1884 if isinstance(service[1], str):
1885 if service[1] == "quickzap":
1886 from Screens.SubservicesQuickzap import SubservicesQuickzap
1887 self.session.open(SubservicesQuickzap, service[2])
1889 self["SubserviceQuickzapAction"].setEnabled(True)
1890 self.session.nav.playService(service[1], False)
1892 def addSubserviceToBouquetCallback(self, service):
1893 if len(service) > 1 and isinstance(service[1], eServiceReference):
1894 self.selectedSubservice = service
1895 if self.bouquets is None:
1898 cnt = len(self.bouquets)
1899 if cnt > 1: # show bouquet list
1900 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1901 elif cnt == 1: # add to only one existing bouquet
1902 self.addSubserviceToBouquet(self.bouquets[0][1])
1903 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1905 def bouquetSelClosed(self, confirmed):
1907 del self.selectedSubservice
1909 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1911 def addSubserviceToBouquet(self, dest):
1912 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1914 self.bsel.close(True)
1916 del self.selectedSubservice
1918 class InfoBarAdditionalInfo:
1921 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1922 self["TimeshiftPossible"] = self["RecordingPossible"]
1923 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1924 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1925 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1926 self["ExtensionsAvailable"] = Boolean(fixed=1)
1928 class InfoBarNotifications:
1930 self.onExecBegin.append(self.checkNotifications)
1931 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1932 self.onClose.append(self.__removeNotification)
1934 def __removeNotification(self):
1935 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1937 def checkNotificationsIfExecing(self):
1939 self.checkNotifications()
1941 def checkNotifications(self):
1942 notifications = Notifications.notifications
1944 n = notifications[0]
1946 del notifications[0]
1949 if n[3].has_key("onSessionOpenCallback"):
1950 n[3]["onSessionOpenCallback"]()
1951 del n[3]["onSessionOpenCallback"]
1954 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1956 dlg = self.session.open(n[1], *n[2], **n[3])
1958 # remember that this notification is currently active
1960 Notifications.current_notifications.append(d)
1961 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1963 def __notificationClosed(self, d):
1964 Notifications.current_notifications.remove(d)
1966 class InfoBarServiceNotifications:
1968 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1970 iPlayableService.evEnd: self.serviceHasEnded
1973 def serviceHasEnded(self):
1974 print "service end!"
1977 self.setSeekState(self.SEEK_STATE_PLAY)
1981 class InfoBarCueSheetSupport:
1987 ENABLE_RESUME_SUPPORT = False
1989 def __init__(self, actionmap = "InfobarCueSheetActions"):
1990 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1992 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1993 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1994 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1998 self.is_closing = False
1999 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2001 iPlayableService.evStart: self.__serviceStarted,
2004 def __serviceStarted(self):
2007 print "new service started! trying to download cuts!"
2008 self.downloadCuesheet()
2010 if self.ENABLE_RESUME_SUPPORT:
2013 for (pts, what) in self.cut_list:
2014 if what == self.CUT_TYPE_LAST:
2017 if last is not None:
2018 self.resume_point = last
2019 if config.usage.on_movie_start.value == "ask":
2020 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
2021 elif config.usage.on_movie_start.value == "resume":
2022 # TRANSLATORS: The string "Resuming playback" flashes for a moment
2023 # TRANSLATORS: at the start of a movie, when the user has selected
2024 # TRANSLATORS: "Resume from last position" as start behavior.
2025 # TRANSLATORS: The purpose is to notify the user that the movie starts
2026 # TRANSLATORS: in the middle somewhere and not from the beginning.
2027 # TRANSLATORS: (Some translators seem to have interpreted it as a
2028 # TRANSLATORS: question or a choice, but it is a statement.)
2029 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
2031 def playLastCB(self, answer):
2033 self.doSeek(self.resume_point)
2034 self.hideAfterResume()
2036 def hideAfterResume(self):
2037 if isinstance(self, InfoBarShowHide):
2040 def __getSeekable(self):
2041 service = self.session.nav.getCurrentService()
2044 return service.seek()
2046 def cueGetCurrentPosition(self):
2047 seek = self.__getSeekable()
2050 r = seek.getPlayPosition()
2055 def cueGetEndCutPosition(self):
2058 for cp in self.cut_list:
2059 if cp[1] == self.CUT_TYPE_OUT:
2063 elif cp[1] == self.CUT_TYPE_IN:
2067 def jumpPreviousNextMark(self, cmp, start=False):
2068 current_pos = self.cueGetCurrentPosition()
2069 if current_pos is None:
2071 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
2072 if mark is not None:
2080 def jumpPreviousMark(self):
2081 # we add 2 seconds, so if the play position is <2s after
2082 # the mark, the mark before will be used
2083 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
2085 def jumpNextMark(self):
2086 if not self.jumpPreviousNextMark(lambda x: x):
2089 def getNearestCutPoint(self, pts, cmp=abs, start=False):
2095 bestdiff = cmp(0 - pts)
2097 nearest = [0, False]
2098 for cp in self.cut_list:
2099 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
2101 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
2102 diff = cmp(cp[0] - pts)
2108 if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
2109 diff = cmp(cp[0] - pts)
2110 if diff >= 0 and (nearest is None or bestdiff > diff):
2115 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
2116 current_pos = self.cueGetCurrentPosition()
2117 if current_pos is None:
2118 print "not seekable"
2121 nearest_cutpoint = self.getNearestCutPoint(current_pos)
2123 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
2125 return nearest_cutpoint
2127 self.removeMark(nearest_cutpoint)
2128 elif not onlyremove and not onlyreturn:
2129 self.addMark((current_pos, self.CUT_TYPE_MARK))
2134 def addMark(self, point):
2135 insort(self.cut_list, point)
2136 self.uploadCuesheet()
2137 self.showAfterCuesheetOperation()
2139 def removeMark(self, point):
2140 self.cut_list.remove(point)
2141 self.uploadCuesheet()
2142 self.showAfterCuesheetOperation()
2144 def showAfterCuesheetOperation(self):
2145 if isinstance(self, InfoBarShowHide):
2148 def __getCuesheet(self):
2149 service = self.session.nav.getCurrentService()
2152 return service.cueSheet()
2154 def uploadCuesheet(self):
2155 cue = self.__getCuesheet()
2158 print "upload failed, no cuesheet interface"
2160 cue.setCutList(self.cut_list)
2162 def downloadCuesheet(self):
2163 cue = self.__getCuesheet()
2166 print "download failed, no cuesheet interface"
2169 self.cut_list = cue.getCutList()
2171 class InfoBarSummary(Screen):
2173 <screen position="0,0" size="132,64">
2174 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2175 <convert type="ClockToText">WithSeconds</convert>
2177 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2178 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2179 <convert type="ConditionalShowHide">Blink</convert>
2181 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2182 <convert type="ServiceName">Name</convert>
2184 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2185 <convert type="EventTime">Progress</convert>
2189 # for picon: (path="piconlcd" will use LCD picons)
2190 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2191 # <convert type="ServiceName">Reference</convert>
2194 class InfoBarSummarySupport:
2198 def createSummary(self):
2199 return InfoBarSummary
2201 class InfoBarMoviePlayerSummary(Screen):
2203 <screen position="0,0" size="132,64">
2204 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2205 <convert type="ClockToText">WithSeconds</convert>
2207 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2208 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2209 <convert type="ConditionalShowHide">Blink</convert>
2211 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2212 <convert type="ServiceName">Name</convert>
2214 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2215 <convert type="ServicePosition">Position</convert>
2219 class InfoBarMoviePlayerSummarySupport:
2223 def createSummary(self):
2224 return InfoBarMoviePlayerSummary
2226 class InfoBarTeletextPlugin:
2228 self.teletext_plugin = None
2230 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2231 self.teletext_plugin = p
2233 if self.teletext_plugin is not None:
2234 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2236 "startTeletext": (self.startTeletext, _("View teletext..."))
2239 print "no teletext plugin found!"
2241 def startTeletext(self):
2242 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2244 class InfoBarSubtitleSupport(object):
2246 object.__init__(self)
2247 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2248 self.__subtitles_enabled = False
2250 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2252 iPlayableService.evEnd: self.__serviceStopped,
2253 iPlayableService.evUpdatedInfo: self.__updatedInfo
2255 self.cached_subtitle_checked = False
2256 self.__selected_subtitle = None
2258 def __serviceStopped(self):
2259 self.cached_subtitle_checked = False
2260 if self.__subtitles_enabled:
2261 self.subtitle_window.hide()
2262 self.__subtitles_enabled = False
2263 self.__selected_subtitle = None
2265 def __updatedInfo(self):
2266 if not self.cached_subtitle_checked:
2267 self.cached_subtitle_checked = True
2268 subtitle = self.getCurrentServiceSubtitle()
2269 self.setSelectedSubtitle(subtitle and subtitle.getCachedSubtitle())
2270 if self.__selected_subtitle:
2271 self.setSubtitlesEnable(True)
2273 def getCurrentServiceSubtitle(self):
2274 service = self.session.nav.getCurrentService()
2275 return service and service.subtitle()
2277 def setSubtitlesEnable(self, enable=True):
2278 subtitle = self.getCurrentServiceSubtitle()
2280 if self.__selected_subtitle:
2281 if subtitle and not self.__subtitles_enabled:
2282 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2283 self.subtitle_window.show()
2284 self.__subtitles_enabled = True
2287 subtitle.disableSubtitles(self.subtitle_window.instance)
2288 self.__selected_subtitle = False
2289 self.__subtitles_enabled = False
2290 self.subtitle_window.hide()
2292 def setSelectedSubtitle(self, subtitle):
2293 self.__selected_subtitle = subtitle
2295 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2296 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2298 class InfoBarServiceErrorPopupSupport:
2300 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2302 iPlayableService.evTuneFailed: self.__tuneFailed,
2303 iPlayableService.evStart: self.__serviceStarted
2305 self.__serviceStarted()
2307 def __serviceStarted(self):
2308 self.last_error = None
2309 Notifications.RemovePopup(id = "ZapError")
2311 def __tuneFailed(self):
2312 service = self.session.nav.getCurrentService()
2313 info = service and service.info()
2314 error = info and info.getInfo(iServiceInformation.sDVBState)
2316 if error == self.last_error:
2319 self.last_error = error
2322 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2323 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2324 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2325 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2326 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2327 eDVBServicePMTHandler.eventNewProgramInfo: None,
2328 eDVBServicePMTHandler.eventTuned: None,
2329 eDVBServicePMTHandler.eventSOF: None,
2330 eDVBServicePMTHandler.eventEOF: None,
2331 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2332 }.get(error) #this returns None when the key not exist in the dict
2334 if error is not None:
2335 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2337 Notifications.RemovePopup(id = "ZapError")