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.hideUnhandledKeySymbolTimer = eTimer()
55 self.hideUnhandledKeySymbolTimer.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
64 #this function is called on every keypress!
65 def actionA(self, key, flag):
67 if self.flags & (1<<1):
68 self.flags = self.uflags = 0
69 self.flags |= (1<<flag)
71 self.checkUnusedTimer.start(0, True)
74 #this function is only called when no other action has handled this key
75 def actionB(self, key, flag):
77 self.uflags |= (1<<flag)
79 def checkUnused(self):
80 if self.flags == self.uflags:
81 self.unhandledKeyDialog.show()
82 self.hideUnhandledKeySymbolTimer.start(2000, True)
84 class InfoBarShowHide:
85 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
93 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
95 "toggleShow": self.toggleShow,
97 }, 1) # lower prio to make it possible to override ok and cancel..
99 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
101 iPlayableService.evStart: self.serviceStarted,
104 self.__state = self.STATE_SHOWN
107 self.hideTimer = eTimer()
108 self.hideTimer.callback.append(self.doTimerHide)
109 self.hideTimer.start(5000, True)
111 self.onShow.append(self.__onShow)
112 self.onHide.append(self.__onHide)
114 def serviceStarted(self):
116 if config.usage.show_infobar_on_zap.value:
120 self.__state = self.STATE_SHOWN
121 self.startHideTimer()
123 def startHideTimer(self):
124 if self.__state == self.STATE_SHOWN and not self.__locked:
125 idx = config.usage.infobar_timeout.index
127 self.hideTimer.start(idx*1000, True)
130 self.__state = self.STATE_HIDDEN
134 self.startHideTimer()
136 def doTimerHide(self):
137 self.hideTimer.stop()
138 if self.__state == self.STATE_SHOWN:
141 def toggleShow(self):
142 if self.__state == self.STATE_SHOWN:
144 self.hideTimer.stop()
145 elif self.__state == self.STATE_HIDDEN:
149 self.__locked = self.__locked + 1
152 self.hideTimer.stop()
154 def unlockShow(self):
155 self.__locked = self.__locked - 1
157 self.startHideTimer()
159 # def startShow(self):
160 # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
161 # self.__state = self.STATE_SHOWN
163 # def startHide(self):
164 # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
165 # self.__state = self.STATE_HIDDEN
167 class NumberZap(Screen):
174 self.close(int(self["number"].getText()))
176 def keyNumberGlobal(self, number):
177 self.Timer.start(3000, True) #reset timer
178 self.field = self.field + str(number)
179 self["number"].setText(self.field)
180 if len(self.field) >= 4:
183 def __init__(self, session, number):
184 Screen.__init__(self, session)
185 self.field = str(number)
187 self["channel"] = Label(_("Channel:"))
189 self["number"] = Label(self.field)
191 self["actions"] = NumberActionMap( [ "SetupActions" ],
195 "1": self.keyNumberGlobal,
196 "2": self.keyNumberGlobal,
197 "3": self.keyNumberGlobal,
198 "4": self.keyNumberGlobal,
199 "5": self.keyNumberGlobal,
200 "6": self.keyNumberGlobal,
201 "7": self.keyNumberGlobal,
202 "8": self.keyNumberGlobal,
203 "9": self.keyNumberGlobal,
204 "0": self.keyNumberGlobal
207 self.Timer = eTimer()
208 self.Timer.callback.append(self.keyOK)
209 self.Timer.start(3000, True)
211 class InfoBarNumberZap:
212 """ Handles an initial number for NumberZapping """
214 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
216 "1": self.keyNumberGlobal,
217 "2": self.keyNumberGlobal,
218 "3": self.keyNumberGlobal,
219 "4": self.keyNumberGlobal,
220 "5": self.keyNumberGlobal,
221 "6": self.keyNumberGlobal,
222 "7": self.keyNumberGlobal,
223 "8": self.keyNumberGlobal,
224 "9": self.keyNumberGlobal,
225 "0": self.keyNumberGlobal,
228 def keyNumberGlobal(self, number):
229 # print "You pressed number " + str(number)
231 if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
232 self.pipDoHandle0Action()
234 self.servicelist.recallPrevService()
236 if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
237 self.session.openWithCallback(self.numberEntered, NumberZap, number)
239 def numberEntered(self, retval):
240 # print self.servicelist
242 self.zapToNumber(retval)
244 def searchNumberHelper(self, serviceHandler, num, bouquet):
245 servicelist = serviceHandler.list(bouquet)
246 if not servicelist is None:
248 serviceIterator = servicelist.getNext()
249 if not serviceIterator.valid(): #check end of list
251 playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
254 if not num: #found service with searched number ?
255 return serviceIterator, 0
258 def zapToNumber(self, number):
259 bouquet = self.servicelist.bouquet_root
261 serviceHandler = eServiceCenter.getInstance()
262 if not config.usage.multibouquet.value:
263 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
265 bouquetlist = serviceHandler.list(bouquet)
266 if not bouquetlist is None:
268 bouquet = bouquetlist.getNext()
269 if not bouquet.valid(): #check end of list
271 if bouquet.flags & eServiceReference.isDirectory:
272 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
273 if not service is None:
274 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
275 self.servicelist.clearPath()
276 if self.servicelist.bouquet_root != bouquet:
277 self.servicelist.enterPath(self.servicelist.bouquet_root)
278 self.servicelist.enterPath(bouquet)
279 self.servicelist.setCurrentSelection(service) #select the service in servicelist
280 self.servicelist.zap()
282 config.misc.initialchannelselection = ConfigBoolean(default = True)
284 class InfoBarChannelSelection:
285 """ ChannelSelection - handles the channelSelection dialog and the initial
286 channelChange actions which open the channelSelection dialog """
289 self.servicelist = self.session.instantiateDialog(ChannelSelection)
291 if config.misc.initialchannelselection.value:
292 self.onShown.append(self.firstRun)
294 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
296 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
297 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
298 "zapUp": (self.zapUp, _("previous channel")),
299 "zapDown": (self.zapDown, _("next channel")),
300 "historyBack": (self.historyBack, _("previous channel in history")),
301 "historyNext": (self.historyNext, _("next channel in history")),
302 "openServiceList": (self.openServiceList, _("open servicelist")),
305 def showTvChannelList(self, zap=False):
306 self.servicelist.setModeTv()
308 self.servicelist.zap()
309 self.session.execDialog(self.servicelist)
311 def showRadioChannelList(self, zap=False):
312 self.servicelist.setModeRadio()
314 self.servicelist.zap()
315 self.session.execDialog(self.servicelist)
318 self.onShown.remove(self.firstRun)
319 config.misc.initialchannelselection.value = False
320 config.misc.initialchannelselection.save()
321 self.switchChannelDown()
323 def historyBack(self):
324 self.servicelist.historyBack()
326 def historyNext(self):
327 self.servicelist.historyNext()
329 def switchChannelUp(self):
330 self.servicelist.moveUp()
331 self.session.execDialog(self.servicelist)
333 def switchChannelDown(self):
334 self.servicelist.moveDown()
335 self.session.execDialog(self.servicelist)
337 def openServiceList(self):
338 self.session.execDialog(self.servicelist)
341 if self.servicelist.inBouquet():
342 prev = self.servicelist.getCurrentSelection()
344 prev = prev.toString()
346 if config.usage.quickzap_bouquet_change.value:
347 if self.servicelist.atBegin():
348 self.servicelist.prevBouquet()
349 self.servicelist.moveUp()
350 cur = self.servicelist.getCurrentSelection()
351 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
354 self.servicelist.moveUp()
355 self.servicelist.zap()
358 if self.servicelist.inBouquet():
359 prev = self.servicelist.getCurrentSelection()
361 prev = prev.toString()
363 if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
364 self.servicelist.nextBouquet()
366 self.servicelist.moveDown()
367 cur = self.servicelist.getCurrentSelection()
368 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
371 self.servicelist.moveDown()
372 self.servicelist.zap()
375 """ Handles a menu action, to open the (main) menu """
377 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
379 "mainMenu": (self.mainMenu, _("Enter main menu...")),
381 self.session.infobar = None
384 print "loading mainmenu XML..."
385 menu = mdom.getroot()
386 assert menu.tag == "menu", "root element in menu must be 'menu'!"
388 self.session.infobar = self
389 # so we can access the currently active infobar from screens opened from within the mainmenu
390 # at the moment used from the SubserviceSelection
392 self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)
394 def mainMenuClosed(self, *val):
395 self.session.infobar = None
397 class InfoBarSimpleEventView:
398 """ Opens the Eventview for now/next """
400 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
402 "showEventInfo": (self.openEventView, _("show event details")),
403 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
406 def showEventInfoWhenNotVisible(self):
413 def openEventView(self):
415 self.epglist = epglist
416 service = self.session.nav.getCurrentService()
417 ref = self.session.nav.getCurrentlyPlayingServiceReference()
418 info = service.info()
426 self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
428 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
429 epglist = self.epglist
432 epglist[0] = epglist[1]
436 class SimpleServicelist:
437 def __init__(self, services):
438 self.services = services
439 self.length = len(services)
442 def selectService(self, service):
448 while self.services[self.current].ref != service:
450 if self.current >= self.length:
454 def nextService(self):
457 if self.current+1 < self.length:
462 def prevService(self):
465 if self.current-1 > -1:
468 self.current = self.length - 1
470 def currentService(self):
471 if not self.length or self.current >= self.length:
473 return self.services[self.current]
476 """ EPG - Opens an EPG list when the showEPGList action fires """
478 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
480 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
483 self.is_now_next = False
485 self.bouquetSel = None
486 self.eventView = None
487 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
489 "showEventInfo": (self.openEventView, _("show EPG...")),
490 "showEventInfoPlugin": (self.showEventInfoPlugins, _("list of EPG views...")),
491 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
494 def showEventInfoWhenNotVisible(self):
501 def zapToService(self, service):
502 if not service is None:
503 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
504 self.servicelist.clearPath()
505 if self.servicelist.bouquet_root != self.epg_bouquet:
506 self.servicelist.enterPath(self.servicelist.bouquet_root)
507 self.servicelist.enterPath(self.epg_bouquet)
508 self.servicelist.setCurrentSelection(service) #select the service in servicelist
509 self.servicelist.zap()
511 def getBouquetServices(self, bouquet):
513 servicelist = eServiceCenter.getInstance().list(bouquet)
514 if not servicelist is None:
516 service = servicelist.getNext()
517 if not service.valid(): #check if end of list
519 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
521 services.append(ServiceReference(service))
524 def openBouquetEPG(self, bouquet, withCallback=True):
525 services = self.getBouquetServices(bouquet)
527 self.epg_bouquet = bouquet
529 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
531 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
533 def changeBouquetCB(self, direction, epg):
536 self.bouquetSel.down()
539 bouquet = self.bouquetSel.getCurrent()
540 services = self.getBouquetServices(bouquet)
542 self.epg_bouquet = bouquet
543 epg.setServices(services)
545 def closed(self, ret=False):
546 closedScreen = self.dlg_stack.pop()
547 if self.bouquetSel and closedScreen == self.bouquetSel:
548 self.bouquetSel = None
549 elif self.eventView and closedScreen == self.eventView:
550 self.eventView = None
552 dlgs=len(self.dlg_stack)
554 self.dlg_stack[dlgs-1].close(dlgs > 1)
556 def openMultiServiceEPG(self, withCallback=True):
557 bouquets = self.servicelist.getBouquetList()
562 if cnt > 1: # show bouquet list
564 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
565 self.dlg_stack.append(self.bouquetSel)
567 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
569 self.openBouquetEPG(bouquets[0][1], withCallback)
571 def changeServiceCB(self, direction, epg):
574 self.serviceSel.nextService()
576 self.serviceSel.prevService()
577 epg.setService(self.serviceSel.currentService())
579 def SingleServiceEPGClosed(self, ret=False):
580 self.serviceSel = None
582 def openSingleServiceEPG(self):
583 ref=self.session.nav.getCurrentlyPlayingServiceReference()
585 if self.servicelist.getMutableList() is not None: # bouquet in channellist
586 current_path = self.servicelist.getRoot()
587 services = self.getBouquetServices(current_path)
588 self.serviceSel = SimpleServicelist(services)
589 if self.serviceSel.selectService(ref):
590 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
592 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref)
594 self.session.open(EPGSelection, ref)
596 def showEventInfoPlugins(self):
597 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
600 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
601 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
603 self.openSingleServiceEPG()
605 def runPlugin(self, plugin):
606 plugin(session = self.session, servicelist = self.servicelist)
608 def EventInfoPluginChosen(self, answer):
609 if answer is not None:
612 def openSimilarList(self, eventid, refstr):
613 self.session.open(EPGSelection, refstr, None, eventid)
615 def getNowNext(self):
617 service = self.session.nav.getCurrentService()
618 info = service and service.info()
619 ptr = info and info.getEvent(0)
622 ptr = info and info.getEvent(1)
625 self.epglist = epglist
627 def __evEventInfoChanged(self):
628 if self.is_now_next and len(self.dlg_stack) == 1:
630 assert self.eventView
632 self.eventView.setEvent(self.epglist[0])
634 def openEventView(self):
635 ref = self.session.nav.getCurrentlyPlayingServiceReference()
637 epglist = self.epglist
639 self.is_now_next = False
640 epg = eEPGCache.getInstance()
641 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
644 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
648 self.is_now_next = True
650 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
651 self.dlg_stack.append(self.eventView)
653 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
654 self.openMultiServiceEPG(False)
656 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
657 epglist = self.epglist
660 epglist[0]=epglist[1]
664 class InfoBarRdsDecoder:
665 """provides RDS and Rass support/display"""
667 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
668 self.rass_interactive = None
670 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
672 iPlayableService.evEnd: self.__serviceStopped,
673 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
676 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
678 "startRassInteractive": self.startRassInteractive
681 self["RdsActions"].setEnabled(False)
683 self.onLayoutFinish.append(self.rds_display.show)
684 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
686 def RassInteractivePossibilityChanged(self, state):
687 self["RdsActions"].setEnabled(state)
689 def RassSlidePicChanged(self):
690 if not self.rass_interactive:
691 service = self.session.nav.getCurrentService()
692 decoder = service and service.rdsDecoder()
694 decoder.showRassSlidePicture()
696 def __serviceStopped(self):
697 if self.rass_interactive is not None:
698 rass_interactive = self.rass_interactive
699 self.rass_interactive = None
700 rass_interactive.close()
702 def startRassInteractive(self):
703 self.rds_display.hide()
704 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
706 def RassInteractiveClosed(self, *val):
707 if self.rass_interactive is not None:
708 self.rass_interactive = None
709 self.RassSlidePicChanged()
710 self.rds_display.show()
713 """handles actions like seeking, pause"""
715 SEEK_STATE_PLAY = (0, 0, 0, ">")
716 SEEK_STATE_PAUSE = (1, 0, 0, "||")
717 SEEK_STATE_EOF = (1, 0, 0, "END")
719 def __init__(self, actionmap = "InfobarSeekActions"):
720 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
722 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
723 iPlayableService.evStart: self.__serviceStarted,
725 iPlayableService.evEOF: self.__evEOF,
726 iPlayableService.evSOF: self.__evSOF,
728 self.fast_winding_hint_message_showed = False
730 class InfoBarSeekActionMap(HelpableActionMap):
731 def __init__(self, screen, *args, **kwargs):
732 HelpableActionMap.__init__(self, screen, *args, **kwargs)
735 def action(self, contexts, action):
736 print "action:", action
737 if action[:5] == "seek:":
738 time = int(action[5:])
739 self.screen.doSeekRelative(time * 90000)
741 elif action[:8] == "seekdef:":
742 key = int(action[8:])
743 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
744 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
745 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
746 self.screen.doSeekRelative(time * 90000)
749 return HelpableActionMap.action(self, contexts, action)
751 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
753 "playpauseService": self.playpauseService,
754 "pauseService": (self.pauseService, _("pause")),
755 "unPauseService": (self.unPauseService, _("continue")),
757 "seekFwd": (self.seekFwd, _("skip forward")),
758 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
759 "seekBack": (self.seekBack, _("skip backward")),
760 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
762 # give them a little more priority to win over color buttons
764 self["SeekActions"].setEnabled(False)
766 self.seekstate = self.SEEK_STATE_PLAY
767 self.lastseekstate = self.SEEK_STATE_PLAY
769 self.onPlayStateChanged = [ ]
771 self.lockedBecauseOfSkipping = False
773 self.__seekableStatusChanged()
775 def makeStateForward(self, n):
776 return (0, n, 0, ">> %dx" % n)
778 def makeStateBackward(self, n):
779 return (0, -n, 0, "<< %dx" % n)
781 def makeStateSlowMotion(self, n):
782 return (0, 0, n, "/%d" % n)
784 def isStateForward(self, state):
787 def isStateBackward(self, state):
790 def isStateSlowMotion(self, state):
791 return state[1] == 0 and state[2] > 1
793 def getHigher(self, n, lst):
799 def getLower(self, n, lst):
807 def showAfterSeek(self):
808 if isinstance(self, InfoBarShowHide):
818 service = self.session.nav.getCurrentService()
822 seek = service.seek()
824 if seek is None or not seek.isCurrentlySeekable():
829 def isSeekable(self):
830 if self.getSeek() is None:
834 def __seekableStatusChanged(self):
835 # print "seekable status changed!"
836 if not self.isSeekable():
837 self["SeekActions"].setEnabled(False)
838 # print "not seekable, return to play"
839 self.setSeekState(self.SEEK_STATE_PLAY)
841 self["SeekActions"].setEnabled(True)
844 def __serviceStarted(self):
845 self.fast_winding_hint_message_showed = False
846 self.seekstate = self.SEEK_STATE_PLAY
847 self.__seekableStatusChanged()
849 def setSeekState(self, state):
850 service = self.session.nav.getCurrentService()
855 if not self.isSeekable():
856 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
857 state = self.SEEK_STATE_PLAY
859 pauseable = service.pause()
861 if pauseable is None:
862 print "not pauseable."
863 state = self.SEEK_STATE_PLAY
865 self.seekstate = state
867 if pauseable is not None:
868 if self.seekstate[0]:
869 print "resolved to PAUSE"
871 elif self.seekstate[1]:
872 print "resolved to FAST FORWARD"
873 pauseable.setFastForward(self.seekstate[1])
874 elif self.seekstate[2]:
875 print "resolved to SLOW MOTION"
876 pauseable.setSlowMotion(self.seekstate[2])
878 print "resolved to PLAY"
881 for c in self.onPlayStateChanged:
884 self.checkSkipShowHideLock()
888 def playpauseService(self):
889 if self.seekstate != self.SEEK_STATE_PLAY:
890 self.unPauseService()
894 def pauseService(self):
895 if self.seekstate == self.SEEK_STATE_PAUSE:
896 if config.seek.on_pause.value == "play":
897 self.unPauseService()
898 elif config.seek.on_pause.value == "step":
899 self.doSeekRelative(1)
900 elif config.seek.on_pause.value == "last":
901 self.setSeekState(self.lastseekstate)
902 self.lastseekstate = self.SEEK_STATE_PLAY
904 if self.seekstate != self.SEEK_STATE_EOF:
905 self.lastseekstate = self.seekstate
906 self.setSeekState(self.SEEK_STATE_PAUSE);
908 def unPauseService(self):
910 if self.seekstate == self.SEEK_STATE_PLAY:
912 self.setSeekState(self.SEEK_STATE_PLAY)
914 def doSeek(self, pts):
915 seekable = self.getSeek()
920 def doSeekRelative(self, pts):
921 seekable = self.getSeek()
924 prevstate = self.seekstate
926 if self.seekstate == self.SEEK_STATE_EOF:
927 if prevstate == self.SEEK_STATE_PAUSE:
928 self.setSeekState(self.SEEK_STATE_PAUSE)
930 self.setSeekState(self.SEEK_STATE_PLAY)
931 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
932 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
936 seek = self.getSeek()
937 if seek and not (seek.isCurrentlySeekable() & 2):
938 if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
939 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)
940 self.fast_winding_hint_message_showed = True
942 return 0 # trade as unhandled action
943 if self.seekstate == self.SEEK_STATE_PLAY:
944 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
945 elif self.seekstate == self.SEEK_STATE_PAUSE:
946 if len(config.seek.speeds_slowmotion.value):
947 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
949 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
950 elif self.seekstate == self.SEEK_STATE_EOF:
952 elif self.isStateForward(self.seekstate):
953 speed = self.seekstate[1]
954 if self.seekstate[2]:
955 speed /= self.seekstate[2]
956 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
957 self.setSeekState(self.makeStateForward(speed))
958 elif self.isStateBackward(self.seekstate):
959 speed = -self.seekstate[1]
960 if self.seekstate[2]:
961 speed /= self.seekstate[2]
962 speed = self.getLower(speed, config.seek.speeds_backward.value)
964 self.setSeekState(self.makeStateBackward(speed))
966 self.setSeekState(self.SEEK_STATE_PLAY)
967 elif self.isStateSlowMotion(self.seekstate):
968 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
969 self.setSeekState(self.makeStateSlowMotion(speed))
972 seek = self.getSeek()
973 if seek and not (seek.isCurrentlySeekable() & 2):
974 if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
975 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)
976 self.fast_winding_hint_message_showed = True
978 return 0 # trade as unhandled action
979 seekstate = self.seekstate
980 if seekstate == self.SEEK_STATE_PLAY:
981 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
982 elif seekstate == self.SEEK_STATE_EOF:
983 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
984 self.doSeekRelative(-6)
985 elif seekstate == self.SEEK_STATE_PAUSE:
986 self.doSeekRelative(-1)
987 elif self.isStateForward(seekstate):
990 speed /= seekstate[2]
991 speed = self.getLower(speed, config.seek.speeds_forward.value)
993 self.setSeekState(self.makeStateForward(speed))
995 self.setSeekState(self.SEEK_STATE_PLAY)
996 elif self.isStateBackward(seekstate):
997 speed = -seekstate[1]
999 speed /= seekstate[2]
1000 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
1001 self.setSeekState(self.makeStateBackward(speed))
1002 elif self.isStateSlowMotion(seekstate):
1003 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
1005 self.setSeekState(self.makeStateSlowMotion(speed))
1007 self.setSeekState(self.SEEK_STATE_PAUSE)
1009 def seekFwdManual(self):
1010 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
1012 def fwdSeekTo(self, minutes):
1013 print "Seek", minutes, "minutes forward"
1014 self.doSeekRelative(minutes * 60 * 90000)
1016 def seekBackManual(self):
1017 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
1019 def rwdSeekTo(self, minutes):
1021 self.doSeekRelative(-minutes * 60 * 90000)
1023 def checkSkipShowHideLock(self):
1024 wantlock = self.seekstate != self.SEEK_STATE_PLAY
1026 if config.usage.show_infobar_on_skip.value:
1027 if self.lockedBecauseOfSkipping and not wantlock:
1029 self.lockedBecauseOfSkipping = False
1031 if wantlock and not self.lockedBecauseOfSkipping:
1033 self.lockedBecauseOfSkipping = True
1035 def calcRemainingTime(self):
1036 seekable = self.getSeek()
1037 if seekable is not None:
1038 len = seekable.getLength()
1040 tmp = self.cueGetEndCutPosition()
1045 pos = seekable.getPlayPosition()
1046 speednom = self.seekstate[1] or 1
1047 speedden = self.seekstate[2] or 1
1048 if not len[0] and not pos[0]:
1049 if len[1] <= pos[1]:
1051 time = (len[1] - pos[1])*speedden/(90*speednom)
1056 if self.seekstate == self.SEEK_STATE_EOF:
1059 # if we are seeking forward, we try to end up ~1s before the end, and pause there.
1060 seekstate = self.seekstate
1061 if self.seekstate != self.SEEK_STATE_PAUSE:
1062 self.setSeekState(self.SEEK_STATE_EOF)
1064 if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
1065 seekable = self.getSeek()
1066 if seekable is not None:
1068 if seekstate == self.SEEK_STATE_PLAY: # regular EOF
1069 self.doEofInternal(True)
1071 self.doEofInternal(False)
1073 def doEofInternal(self, playing):
1074 pass # Defined in subclasses
1077 self.setSeekState(self.SEEK_STATE_PLAY)
1080 from Screens.PVRState import PVRState, TimeshiftState
1082 class InfoBarPVRState:
1083 def __init__(self, screen=PVRState, force_show = False):
1084 self.onPlayStateChanged.append(self.__playStateChanged)
1085 self.pvrStateDialog = self.session.instantiateDialog(screen)
1086 self.onShow.append(self._mayShow)
1087 self.onHide.append(self.pvrStateDialog.hide)
1088 self.force_show = force_show
1091 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1092 self.pvrStateDialog.show()
1094 def __playStateChanged(self, state):
1095 playstateString = state[3]
1096 self.pvrStateDialog["state"].setText(playstateString)
1098 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
1099 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
1100 self.pvrStateDialog.hide()
1104 class InfoBarTimeshiftState(InfoBarPVRState):
1106 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1107 self.__hideTimer = eTimer()
1108 self.__hideTimer.callback.append(self.__hideTimeshiftState)
1111 if self.execing and self.timeshift_enabled:
1112 self.pvrStateDialog.show()
1113 if self.seekstate == self.SEEK_STATE_PLAY and not self.shown:
1114 self.__hideTimer.start(5*1000, True)
1116 def __hideTimeshiftState(self):
1117 self.pvrStateDialog.hide()
1119 class InfoBarShowMovies:
1121 # i don't really like this class.
1122 # it calls a not further specified "movie list" on up/down/movieList,
1123 # so this is not more than an action map
1125 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1127 "movieList": (self.showMovies, _("movie list")),
1128 "up": (self.showMovies, _("movie list")),
1129 "down": (self.showMovies, _("movie list"))
1132 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1136 # Timeshift works the following way:
1137 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1138 # - normal playback TUNER unused PLAY enable disable disable
1139 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1140 # - user presess pause again FILE record PLAY enable disable enable
1141 # - user fast forwards FILE record FF enable disable enable
1142 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1143 # - user backwards FILE record BACK # !! enable disable enable
1147 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1148 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1149 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1150 # - the user can now PVR around
1151 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1152 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1154 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1155 # - if the user rewinds, or press pause, timeshift will be activated again
1157 # note that a timeshift can be enabled ("recording") and
1158 # activated (currently time-shifting).
1160 class InfoBarTimeshift:
1162 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1164 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1165 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1167 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1169 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1170 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1171 }, prio=-1) # priority over record
1173 self.timeshift_enabled = 0
1174 self.timeshift_state = 0
1175 self.ts_rewind_timer = eTimer()
1176 self.ts_rewind_timer.callback.append(self.rewindService)
1178 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1180 iPlayableService.evStart: self.__serviceStarted,
1181 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1184 def getTimeshift(self):
1185 service = self.session.nav.getCurrentService()
1186 return service and service.timeshift()
1188 def startTimeshift(self):
1189 print "enable timeshift"
1190 ts = self.getTimeshift()
1192 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1193 print "no ts interface"
1196 if self.timeshift_enabled:
1197 print "hu, timeshift already enabled?"
1199 if not ts.startTimeshift():
1200 self.timeshift_enabled = 1
1202 # we remove the "relative time" for now.
1203 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1206 #self.setSeekState(self.SEEK_STATE_PAUSE)
1207 self.activateTimeshiftEnd(False)
1209 # enable the "TimeshiftEnableActions", which will override
1210 # the startTimeshift actions
1211 self.__seekableStatusChanged()
1213 print "timeshift failed"
1215 def stopTimeshift(self):
1216 if not self.timeshift_enabled:
1218 print "disable timeshift"
1219 ts = self.getTimeshift()
1222 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1224 def stopTimeshiftConfirmed(self, confirmed):
1228 ts = self.getTimeshift()
1233 self.timeshift_enabled = 0
1236 self.__seekableStatusChanged()
1238 # activates timeshift, and seeks to (almost) the end
1239 def activateTimeshiftEnd(self, back = True):
1240 ts = self.getTimeshift()
1241 print "activateTimeshiftEnd"
1246 if ts.isTimeshiftActive():
1247 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1251 ts.activateTimeshift() # activate timeshift will automatically pause
1252 self.setSeekState(self.SEEK_STATE_PAUSE)
1255 self.ts_rewind_timer.start(200, 1)
1257 def rewindService(self):
1258 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1260 # same as activateTimeshiftEnd, but pauses afterwards.
1261 def activateTimeshiftEndAndPause(self):
1262 print "activateTimeshiftEndAndPause"
1263 #state = self.seekstate
1264 self.activateTimeshiftEnd(False)
1266 def __seekableStatusChanged(self):
1269 # print "self.isSeekable", self.isSeekable()
1270 # print "self.timeshift_enabled", self.timeshift_enabled
1272 # when this service is not seekable, but timeshift
1273 # is enabled, this means we can activate
1275 if not self.isSeekable() and self.timeshift_enabled:
1278 # print "timeshift activate:", enabled
1279 self["TimeshiftActivateActions"].setEnabled(enabled)
1281 def __serviceStarted(self):
1282 self.timeshift_enabled = False
1283 self.__seekableStatusChanged()
1285 from Screens.PiPSetup import PiPSetup
1287 class InfoBarExtensions:
1288 EXTENSION_SINGLE = 0
1294 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1296 "extensions": (self.showExtensionSelection, _("view extensions...")),
1297 }, 1) # lower priority
1299 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1300 self.list.append((type, extension, key))
1302 def updateExtension(self, extension, key = None):
1303 self.extensionsList.append(extension)
1305 if self.extensionKeys.has_key(key):
1309 for x in self.availableKeys:
1310 if not self.extensionKeys.has_key(x):
1315 self.extensionKeys[key] = len(self.extensionsList) - 1
1317 def updateExtensions(self):
1318 self.extensionsList = []
1319 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1320 self.extensionKeys = {}
1322 if x[0] == self.EXTENSION_SINGLE:
1323 self.updateExtension(x[1], x[2])
1326 self.updateExtension(y[0], y[1])
1329 def showExtensionSelection(self):
1330 self.updateExtensions()
1331 extensionsList = self.extensionsList[:]
1334 for x in self.availableKeys:
1335 if self.extensionKeys.has_key(x):
1336 entry = self.extensionKeys[x]
1337 extension = self.extensionsList[entry]
1339 name = str(extension[0]())
1340 list.append((extension[0](), extension))
1342 extensionsList.remove(extension)
1344 extensionsList.remove(extension)
1345 list.extend([(x[0](), x) for x in extensionsList])
1347 keys += [""] * len(extensionsList)
1348 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
1350 def extensionCallback(self, answer):
1351 if answer is not None:
1354 from Tools.BoundFunction import boundFunction
1356 # depends on InfoBarExtensions
1358 class InfoBarPlugins:
1360 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1362 def getPluginName(self, name):
1365 def getPluginList(self):
1366 list = [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
1367 list.sort(key = lambda e: e[2]) # sort by name
1370 def runPlugin(self, plugin):
1371 if isinstance(self, InfoBarChannelSelection):
1372 plugin(session = self.session, servicelist = self.servicelist)
1374 plugin(session = self.session)
1376 from Components.Task import job_manager
1377 class InfoBarJobman:
1379 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1381 def getJobList(self):
1382 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1384 def getJobName(self, job):
1385 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1387 def showJobView(self, job):
1388 from Screens.TaskView import JobView
1389 job_manager.in_background = False
1390 self.session.openWithCallback(self.JobViewCB, JobView, job)
1392 def JobViewCB(self, in_background):
1393 job_manager.in_background = in_background
1395 # depends on InfoBarExtensions
1399 self.session.pipshown
1401 self.session.pipshown = False
1402 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1404 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1405 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1406 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1408 self.addExtension((self.getShowHideName, self.showPiP, self.pipShown), "blue")
1409 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1412 return self.session.pipshown
1414 def pipHandles0Action(self):
1415 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1417 def getShowHideName(self):
1418 if self.session.pipshown:
1419 return _("Disable Picture in Picture")
1421 return _("Activate Picture in Picture")
1423 def getSwapName(self):
1424 return _("Swap Services")
1426 def getMoveName(self):
1427 return _("Move Picture in Picture")
1430 if self.session.pipshown:
1431 del self.session.pip
1432 self.session.pipshown = False
1434 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1435 self.session.pip.show()
1436 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1437 if self.session.pip.playService(newservice):
1438 self.session.pipshown = True
1439 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1441 self.session.pipshown = False
1442 del self.session.pip
1443 self.session.nav.playService(newservice)
1446 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1447 if self.session.pip.servicePath:
1448 servicepath = self.servicelist.getCurrentServicePath()
1449 ref=servicepath[len(servicepath)-1]
1450 pipref=self.session.pip.getCurrentService()
1451 self.session.pip.playService(swapservice)
1452 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1453 if pipref.toString() != ref.toString(): # is a subservice ?
1454 self.session.nav.stopService() # stop portal
1455 self.session.nav.playService(pipref) # start subservice
1456 self.session.pip.servicePath=servicepath
1459 self.session.open(PiPSetup, pip = self.session.pip)
1461 def pipDoHandle0Action(self):
1462 use = config.usage.pip_zero_button.value
1465 elif "swapstop" == use:
1471 from RecordTimer import parseEvent, RecordTimerEntry
1473 class InfoBarInstantRecord:
1474 """Instant Record - handles the instantRecord action in order to
1475 start/stop instant records"""
1477 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1479 "instantRecord": (self.instantRecord, _("Instant Record...")),
1483 def stopCurrentRecording(self, entry = -1):
1484 if entry is not None and entry != -1:
1485 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1486 self.recording.remove(self.recording[entry])
1488 def startInstantRecording(self, limitEvent = False):
1489 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1491 # try to get event info
1494 service = self.session.nav.getCurrentService()
1495 epg = eEPGCache.getInstance()
1496 event = epg.lookupEventTime(serviceref, -1, 0)
1498 info = service.info()
1499 ev = info.getEvent(0)
1505 end = begin + 3600 # dummy
1506 name = "instant record"
1510 if event is not None:
1511 curEvent = parseEvent(event)
1513 description = curEvent[3]
1514 eventid = curEvent[4]
1519 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1521 if isinstance(serviceref, eServiceReference):
1522 serviceref = ServiceReference(serviceref)
1524 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = preferredInstantRecordPath())
1525 recording.dontSave = True
1527 if event is None or limitEvent == False:
1528 recording.autoincrease = True
1529 if recording.setAutoincreaseEnd():
1530 self.session.nav.RecordTimer.record(recording)
1531 self.recording.append(recording)
1533 simulTimerList = self.session.nav.RecordTimer.record(recording)
1534 if simulTimerList is not None: # conflict with other recording
1535 name = simulTimerList[1].name
1536 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1537 print "[TIMER] conflicts with", name_date
1538 recording.autoincrease = True # start with max available length, then increment
1539 if recording.setAutoincreaseEnd():
1540 self.session.nav.RecordTimer.record(recording)
1541 self.recording.append(recording)
1542 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1544 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1545 recording.autoincrease = False
1547 self.recording.append(recording)
1549 def isInstantRecordRunning(self):
1550 print "self.recording:", self.recording
1552 for x in self.recording:
1557 def recordQuestionCallback(self, answer):
1558 print "pre:\n", self.recording
1560 if answer is None or answer[1] == "no":
1563 recording = self.recording[:]
1565 if not x in self.session.nav.RecordTimer.timer_list:
1566 self.recording.remove(x)
1567 elif x.dontSave and x.isRunning():
1568 list.append((x, False))
1570 if answer[1] == "changeduration":
1571 if len(self.recording) == 1:
1572 self.changeDuration(0)
1574 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1575 elif answer[1] == "changeendtime":
1576 if len(self.recording) == 1:
1579 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1580 elif answer[1] == "stop":
1581 if len(self.recording) == 1:
1582 self.stopCurrentRecording(0)
1584 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1585 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1586 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1587 if answer[1] == "manualduration":
1588 self.changeDuration(len(self.recording)-1)
1589 elif answer[1] == "manualendtime":
1590 self.setEndtime(len(self.recording)-1)
1591 print "after:\n", self.recording
1593 def setEndtime(self, entry):
1594 if entry is not None and entry >= 0:
1595 self.selectedEntry = entry
1596 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1597 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1598 dlg.setTitle(_("Please change recording endtime"))
1600 def TimeDateInputClosed(self, ret):
1603 localendtime = localtime(ret[1])
1604 print "stopping recording at", strftime("%c", localendtime)
1605 if self.recording[self.selectedEntry].end != ret[1]:
1606 self.recording[self.selectedEntry].autoincrease = False
1607 self.recording[self.selectedEntry].end = ret[1]
1608 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1610 def changeDuration(self, entry):
1611 if entry is not None and entry >= 0:
1612 self.selectedEntry = entry
1613 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1615 def inputCallback(self, value):
1616 if value is not None:
1617 print "stopping recording after", int(value), "minutes."
1618 entry = self.recording[self.selectedEntry]
1620 entry.autoincrease = False
1621 entry.end = int(time()) + 60 * int(value)
1622 self.session.nav.RecordTimer.timeChanged(entry)
1624 def instantRecord(self):
1625 dir = preferredInstantRecordPath()
1626 if not dir or not fileExists(dir, 'w'):
1627 dir = defaultMoviePath()
1631 # XXX: this message is a little odd as we might be recording to a remote device
1632 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1635 if self.isInstantRecordRunning():
1636 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1637 title=_("A recording is currently running.\nWhat do you want to do?"), \
1638 list=((_("stop recording"), "stop"), \
1639 (_("add recording (stop after current event)"), "event"), \
1640 (_("add recording (indefinitely)"), "indefinitely"), \
1641 (_("add recording (enter recording duration)"), "manualduration"), \
1642 (_("add recording (enter recording endtime)"), "manualendtime"), \
1643 (_("change recording (duration)"), "changeduration"), \
1644 (_("change recording (endtime)"), "changeendtime"), \
1645 (_("do nothing"), "no")))
1647 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1648 title=_("Start recording?"), \
1649 list=((_("add recording (stop after current event)"), "event"), \
1650 (_("add recording (indefinitely)"), "indefinitely"), \
1651 (_("add recording (enter recording duration)"), "manualduration"), \
1652 (_("add recording (enter recording endtime)"), "manualendtime"), \
1653 (_("don't record"), "no")))
1655 from Tools.ISO639 import LanguageCodes
1657 class InfoBarAudioSelection:
1659 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1661 "audioSelection": (self.audioSelection, _("Audio Options...")),
1664 def audioSelection(self):
1665 service = self.session.nav.getCurrentService()
1666 self.audioTracks = audio = service and service.audioTracks()
1667 n = audio and audio.getNumberOfTracks() or 0
1670 self.audioChannel = service.audioChannel()
1675 i = audio.getTrackInfo(idx)
1676 languages = i.getLanguage().split('/')
1677 description = i.getDescription()
1680 for lang in languages:
1683 if LanguageCodes.has_key(lang):
1684 language += LanguageCodes[lang][0]
1689 if len(description):
1690 description += " (" + language + ")"
1692 description = language
1694 tlist.append((description, idx))
1697 tlist.sort(key=lambda x: x[0])
1699 selectedAudio = self.audioTracks.getCurrentTrack()
1704 if x[1] != selectedAudio:
1712 if SystemInfo["CanDownmixAC3"]:
1713 flist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1714 ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
1715 usedKeys.extend(["red", "green"])
1716 availableKeys.extend(["yellow", "blue"])
1719 flist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
1720 usedKeys.extend(["red"])
1721 availableKeys.extend(["green", "yellow", "blue"])
1724 if hasattr(self, "runPlugin"):
1726 def __init__(self, fnc, *args):
1729 def __call__(self, *args, **kwargs):
1730 self.fnc(*self.args)
1732 Plugins = [ (p.name, PluginCaller(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_AUDIOMENU) ]
1736 flist.append((p[0], "CALLFUNC", p[1]))
1738 usedKeys.append(availableKeys[0])
1739 del availableKeys[0]
1743 flist.append(("--", ""))
1747 keys = usedKeys + [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0" ] + [""] * n
1748 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = flist + tlist, selection = selection, keys = keys, skin_name = "AudioTrackSelection")
1750 del self.audioTracks
1752 def changeAC3Downmix(self, arg):
1753 choicelist = self.session.current_dialog["list"]
1754 list = choicelist.list
1756 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1757 _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
1758 choicelist.setList(list)
1759 if config.av.downmix_ac3.value:
1760 config.av.downmix_ac3.value = False
1762 config.av.downmix_ac3.value = True
1763 config.av.downmix_ac3.save()
1765 def audioSelected(self, audio):
1766 if audio is not None:
1767 if isinstance(audio[1], str):
1768 if audio[1] == "mode":
1769 keys = ["red", "green", "yellow"]
1770 selection = self.audioChannel.getCurrentChannel()
1771 tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
1772 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys, skin_name ="AudioModeSelection")
1774 del self.audioChannel
1775 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1776 self.audioTracks.selectTrack(audio[1])
1778 del self.audioChannel
1779 del self.audioTracks
1781 def modeSelected(self, mode):
1782 if mode is not None:
1783 self.audioChannel.selectChannel(mode[1])
1784 del self.audioChannel
1786 class InfoBarSubserviceSelection:
1788 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1790 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1793 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1795 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1796 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1798 self["SubserviceQuickzapAction"].setEnabled(False)
1800 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1802 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1807 def checkSubservicesAvail(self):
1808 service = self.session.nav.getCurrentService()
1809 subservices = service and service.subServices()
1810 if not subservices or subservices.getNumberOfSubservices() == 0:
1811 self["SubserviceQuickzapAction"].setEnabled(False)
1813 def nextSubservice(self):
1814 self.changeSubservice(+1)
1816 def prevSubservice(self):
1817 self.changeSubservice(-1)
1819 def changeSubservice(self, direction):
1820 service = self.session.nav.getCurrentService()
1821 subservices = service and service.subServices()
1822 n = subservices and subservices.getNumberOfSubservices()
1825 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1828 if subservices.getSubservice(idx).toString() == ref.toString():
1833 selection += direction
1838 newservice = subservices.getSubservice(selection)
1839 if newservice.valid():
1842 self.session.nav.playService(newservice, False)
1844 def subserviceSelection(self):
1845 service = self.session.nav.getCurrentService()
1846 subservices = service and service.subServices()
1847 self.bouquets = self.servicelist.getBouquetList()
1848 n = subservices and subservices.getNumberOfSubservices()
1851 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1855 i = subservices.getSubservice(idx)
1856 if i.toString() == ref.toString():
1858 tlist.append((i.getName(), i))
1861 if self.bouquets and len(self.bouquets):
1862 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1863 if config.usage.multibouquet.value:
1864 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1866 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1869 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1870 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1873 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
1875 def subserviceSelected(self, service):
1877 if not service is None:
1878 if isinstance(service[1], str):
1879 if service[1] == "quickzap":
1880 from Screens.SubservicesQuickzap import SubservicesQuickzap
1881 self.session.open(SubservicesQuickzap, service[2])
1883 self["SubserviceQuickzapAction"].setEnabled(True)
1884 self.session.nav.playService(service[1], False)
1886 def addSubserviceToBouquetCallback(self, service):
1887 if len(service) > 1 and isinstance(service[1], eServiceReference):
1888 self.selectedSubservice = service
1889 if self.bouquets is None:
1892 cnt = len(self.bouquets)
1893 if cnt > 1: # show bouquet list
1894 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1895 elif cnt == 1: # add to only one existing bouquet
1896 self.addSubserviceToBouquet(self.bouquets[0][1])
1897 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1899 def bouquetSelClosed(self, confirmed):
1901 del self.selectedSubservice
1903 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1905 def addSubserviceToBouquet(self, dest):
1906 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1908 self.bsel.close(True)
1910 del self.selectedSubservice
1912 class InfoBarAdditionalInfo:
1915 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1916 self["TimeshiftPossible"] = self["RecordingPossible"]
1917 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1918 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1919 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1920 self["ExtensionsAvailable"] = Boolean(fixed=1)
1922 class InfoBarNotifications:
1924 self.onExecBegin.append(self.checkNotifications)
1925 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1926 self.onClose.append(self.__removeNotification)
1928 def __removeNotification(self):
1929 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1931 def checkNotificationsIfExecing(self):
1933 self.checkNotifications()
1935 def checkNotifications(self):
1936 notifications = Notifications.notifications
1938 n = notifications[0]
1940 del notifications[0]
1943 if n[3].has_key("onSessionOpenCallback"):
1944 n[3]["onSessionOpenCallback"]()
1945 del n[3]["onSessionOpenCallback"]
1948 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1950 dlg = self.session.open(n[1], *n[2], **n[3])
1952 # remember that this notification is currently active
1954 Notifications.current_notifications.append(d)
1955 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1957 def __notificationClosed(self, d):
1958 Notifications.current_notifications.remove(d)
1960 class InfoBarServiceNotifications:
1962 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1964 iPlayableService.evEnd: self.serviceHasEnded
1967 def serviceHasEnded(self):
1968 print "service end!"
1971 self.setSeekState(self.SEEK_STATE_PLAY)
1975 class InfoBarCueSheetSupport:
1981 ENABLE_RESUME_SUPPORT = False
1983 def __init__(self, actionmap = "InfobarCueSheetActions"):
1984 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1986 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1987 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1988 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1992 self.is_closing = False
1993 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1995 iPlayableService.evStart: self.__serviceStarted,
1998 def __serviceStarted(self):
2001 print "new service started! trying to download cuts!"
2002 self.downloadCuesheet()
2004 if self.ENABLE_RESUME_SUPPORT:
2007 for (pts, what) in self.cut_list:
2008 if what == self.CUT_TYPE_LAST:
2011 if last is not None:
2012 self.resume_point = last
2015 if config.usage.on_movie_start.value == "ask":
2016 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?") + "\n" + (_("Resume position at %s") % ("%d:%02d:%02d" % (l/3600, l%3600/60, l%60))), timeout=10)
2017 elif config.usage.on_movie_start.value == "resume":
2018 # TRANSLATORS: The string "Resuming playback" flashes for a moment
2019 # TRANSLATORS: at the start of a movie, when the user has selected
2020 # TRANSLATORS: "Resume from last position" as start behavior.
2021 # TRANSLATORS: The purpose is to notify the user that the movie starts
2022 # TRANSLATORS: in the middle somewhere and not from the beginning.
2023 # TRANSLATORS: (Some translators seem to have interpreted it as a
2024 # TRANSLATORS: question or a choice, but it is a statement.)
2025 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
2027 def playLastCB(self, answer):
2029 self.doSeek(self.resume_point)
2030 self.hideAfterResume()
2032 def hideAfterResume(self):
2033 if isinstance(self, InfoBarShowHide):
2036 def __getSeekable(self):
2037 service = self.session.nav.getCurrentService()
2040 return service.seek()
2042 def cueGetCurrentPosition(self):
2043 seek = self.__getSeekable()
2046 r = seek.getPlayPosition()
2051 def cueGetEndCutPosition(self):
2054 for cp in self.cut_list:
2055 if cp[1] == self.CUT_TYPE_OUT:
2059 elif cp[1] == self.CUT_TYPE_IN:
2063 def jumpPreviousNextMark(self, cmp, start=False):
2064 current_pos = self.cueGetCurrentPosition()
2065 if current_pos is None:
2067 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
2068 if mark is not None:
2076 def jumpPreviousMark(self):
2077 # we add 5 seconds, so if the play position is <5s after
2078 # the mark, the mark before will be used
2079 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
2081 def jumpNextMark(self):
2082 if not self.jumpPreviousNextMark(lambda x: x-90000):
2085 def getNearestCutPoint(self, pts, cmp=abs, start=False):
2092 bestdiff = cmp(0 - pts)
2094 nearest = [0, False]
2095 for cp in self.cut_list:
2096 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
2098 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
2099 diff = cmp(cp[0] - pts)
2100 if start and diff >= 0:
2106 if cp[1] == self.CUT_TYPE_IN:
2108 elif cp[1] == self.CUT_TYPE_OUT:
2110 elif cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
2111 diff = cmp(cp[0] - pts)
2112 if instate and diff >= 0 and (nearest is None or bestdiff > diff):
2117 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
2118 current_pos = self.cueGetCurrentPosition()
2119 if current_pos is None:
2120 print "not seekable"
2123 nearest_cutpoint = self.getNearestCutPoint(current_pos)
2125 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
2127 return nearest_cutpoint
2129 self.removeMark(nearest_cutpoint)
2130 elif not onlyremove and not onlyreturn:
2131 self.addMark((current_pos, self.CUT_TYPE_MARK))
2136 def addMark(self, point):
2137 insort(self.cut_list, point)
2138 self.uploadCuesheet()
2139 self.showAfterCuesheetOperation()
2141 def removeMark(self, point):
2142 self.cut_list.remove(point)
2143 self.uploadCuesheet()
2144 self.showAfterCuesheetOperation()
2146 def showAfterCuesheetOperation(self):
2147 if isinstance(self, InfoBarShowHide):
2150 def __getCuesheet(self):
2151 service = self.session.nav.getCurrentService()
2154 return service.cueSheet()
2156 def uploadCuesheet(self):
2157 cue = self.__getCuesheet()
2160 print "upload failed, no cuesheet interface"
2162 cue.setCutList(self.cut_list)
2164 def downloadCuesheet(self):
2165 cue = self.__getCuesheet()
2168 print "download failed, no cuesheet interface"
2171 self.cut_list = cue.getCutList()
2173 class InfoBarSummary(Screen):
2175 <screen position="0,0" size="132,64">
2176 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2177 <convert type="ClockToText">WithSeconds</convert>
2179 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2180 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2181 <convert type="ConditionalShowHide">Blink</convert>
2183 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2184 <convert type="ServiceName">Name</convert>
2186 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2187 <convert type="EventTime">Progress</convert>
2191 # for picon: (path="piconlcd" will use LCD picons)
2192 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2193 # <convert type="ServiceName">Reference</convert>
2196 class InfoBarSummarySupport:
2200 def createSummary(self):
2201 return InfoBarSummary
2203 class InfoBarMoviePlayerSummary(Screen):
2205 <screen position="0,0" size="132,64">
2206 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2207 <convert type="ClockToText">WithSeconds</convert>
2209 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2210 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2211 <convert type="ConditionalShowHide">Blink</convert>
2213 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2214 <convert type="ServiceName">Name</convert>
2216 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2217 <convert type="ServicePosition">Position</convert>
2221 class InfoBarMoviePlayerSummarySupport:
2225 def createSummary(self):
2226 return InfoBarMoviePlayerSummary
2228 class InfoBarTeletextPlugin:
2230 self.teletext_plugin = None
2232 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2233 self.teletext_plugin = p
2235 if self.teletext_plugin is not None:
2236 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2238 "startTeletext": (self.startTeletext, _("View teletext..."))
2241 print "no teletext plugin found!"
2243 def startTeletext(self):
2244 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2246 class InfoBarSubtitleSupport(object):
2248 object.__init__(self)
2249 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2250 self.__subtitles_enabled = False
2252 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2254 iPlayableService.evEnd: self.__serviceStopped,
2255 iPlayableService.evUpdatedInfo: self.__updatedInfo
2257 self.cached_subtitle_checked = False
2258 self.__selected_subtitle = None
2260 def __serviceStopped(self):
2261 self.cached_subtitle_checked = False
2262 if self.__subtitles_enabled:
2263 self.subtitle_window.hide()
2264 self.__subtitles_enabled = False
2265 self.__selected_subtitle = None
2267 def __updatedInfo(self):
2268 if not self.cached_subtitle_checked:
2269 self.cached_subtitle_checked = True
2270 subtitle = self.getCurrentServiceSubtitle()
2271 self.setSelectedSubtitle(subtitle and subtitle.getCachedSubtitle())
2272 if self.__selected_subtitle:
2273 self.setSubtitlesEnable(True)
2275 def getCurrentServiceSubtitle(self):
2276 service = self.session.nav.getCurrentService()
2277 return service and service.subtitle()
2279 def setSubtitlesEnable(self, enable=True):
2280 subtitle = self.getCurrentServiceSubtitle()
2282 if self.__selected_subtitle:
2283 if subtitle and not self.__subtitles_enabled:
2284 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2285 self.subtitle_window.show()
2286 self.__subtitles_enabled = True
2289 subtitle.disableSubtitles(self.subtitle_window.instance)
2290 self.__selected_subtitle = False
2291 self.__subtitles_enabled = False
2292 self.subtitle_window.hide()
2294 def setSelectedSubtitle(self, subtitle):
2295 self.__selected_subtitle = subtitle
2297 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2298 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2300 class InfoBarServiceErrorPopupSupport:
2302 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2304 iPlayableService.evTuneFailed: self.__tuneFailed,
2305 iPlayableService.evStart: self.__serviceStarted
2307 self.__serviceStarted()
2309 def __serviceStarted(self):
2310 self.last_error = None
2311 Notifications.RemovePopup(id = "ZapError")
2313 def __tuneFailed(self):
2314 service = self.session.nav.getCurrentService()
2315 info = service and service.info()
2316 error = info and info.getInfo(iServiceInformation.sDVBState)
2318 if error == self.last_error:
2321 self.last_error = error
2324 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2325 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2326 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2327 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2328 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2329 eDVBServicePMTHandler.eventNewProgramInfo: None,
2330 eDVBServicePMTHandler.eventTuned: None,
2331 eDVBServicePMTHandler.eventSOF: None,
2332 eDVBServicePMTHandler.eventEOF: None,
2333 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2334 }.get(error) #this returns None when the key not exist in the dict
2336 if error is not None:
2337 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2339 Notifications.RemovePopup(id = "ZapError")