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 EpgSelection import EPGSelection
14 from Plugins.Plugin import PluginDescriptor
16 from Screen import Screen
17 from Screens.ChoiceBox import ChoiceBox
18 from Screens.Dish import Dish
19 from Screens.EventView import EventViewEPGSelect, EventViewSimple
20 from Screens.InputBox import InputBox
21 from Screens.MessageBox import MessageBox
22 from Screens.MinuteInput import MinuteInput
23 from Screens.TimerSelection import TimerSelection
24 from Screens.PictureInPicture import PictureInPicture
25 from Screens.SubtitleDisplay import SubtitleDisplay
26 from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
27 from Screens.SleepTimerEdit import SleepTimerEdit
28 from Screens.TimeDateInput import TimeDateInput
29 from ServiceReference import ServiceReference
31 from Tools import Notifications
32 from Tools.Directories import SCOPE_HDD, resolveFilename, fileExists
34 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
35 iPlayableService, eServiceReference, eEPGCache
37 from time import time, localtime, strftime
38 from os import stat as os_stat
39 from bisect import insort
41 from RecordTimer import RecordTimerEntry, RecordTimer
44 from Menu import MainMenu, mdom
48 self.dishDialog = self.session.instantiateDialog(Dish)
50 class InfoBarShowHide:
51 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
59 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
61 "toggleShow": self.toggleShow,
63 }, 1) # lower prio to make it possible to override ok and cancel..
65 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
67 iPlayableService.evStart: self.serviceStarted,
70 self.__state = self.STATE_SHOWN
73 self.hideTimer = eTimer()
74 self.hideTimer.callback.append(self.doTimerHide)
75 self.hideTimer.start(5000, True)
77 self.onShow.append(self.__onShow)
78 self.onHide.append(self.__onHide)
80 def serviceStarted(self):
82 if config.usage.show_infobar_on_zap.value:
86 self.__state = self.STATE_SHOWN
89 def startHideTimer(self):
90 if self.__state == self.STATE_SHOWN and not self.__locked:
91 idx = config.usage.infobar_timeout.index
93 self.hideTimer.start(idx*1000, True)
96 self.__state = self.STATE_HIDDEN
100 self.startHideTimer()
102 def doTimerHide(self):
103 self.hideTimer.stop()
104 if self.__state == self.STATE_SHOWN:
107 def toggleShow(self):
108 if self.__state == self.STATE_SHOWN:
110 self.hideTimer.stop()
111 elif self.__state == self.STATE_HIDDEN:
115 self.__locked = self.__locked + 1
118 self.hideTimer.stop()
120 def unlockShow(self):
121 self.__locked = self.__locked - 1
123 self.startHideTimer()
125 # def startShow(self):
126 # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
127 # self.__state = self.STATE_SHOWN
129 # def startHide(self):
130 # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
131 # self.__state = self.STATE_HIDDEN
133 class NumberZap(Screen):
140 self.close(int(self["number"].getText()))
142 def keyNumberGlobal(self, number):
143 self.Timer.start(3000, True) #reset timer
144 self.field = self.field + str(number)
145 self["number"].setText(self.field)
146 if len(self.field) >= 4:
149 def __init__(self, session, number):
150 Screen.__init__(self, session)
151 self.field = str(number)
153 self["channel"] = Label(_("Channel:"))
155 self["number"] = Label(self.field)
157 self["actions"] = NumberActionMap( [ "SetupActions" ],
161 "1": self.keyNumberGlobal,
162 "2": self.keyNumberGlobal,
163 "3": self.keyNumberGlobal,
164 "4": self.keyNumberGlobal,
165 "5": self.keyNumberGlobal,
166 "6": self.keyNumberGlobal,
167 "7": self.keyNumberGlobal,
168 "8": self.keyNumberGlobal,
169 "9": self.keyNumberGlobal,
170 "0": self.keyNumberGlobal
173 self.Timer = eTimer()
174 self.Timer.callback.append(self.keyOK)
175 self.Timer.start(3000, True)
177 class InfoBarNumberZap:
178 """ Handles an initial number for NumberZapping """
180 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
182 "1": self.keyNumberGlobal,
183 "2": self.keyNumberGlobal,
184 "3": self.keyNumberGlobal,
185 "4": self.keyNumberGlobal,
186 "5": self.keyNumberGlobal,
187 "6": self.keyNumberGlobal,
188 "7": self.keyNumberGlobal,
189 "8": self.keyNumberGlobal,
190 "9": self.keyNumberGlobal,
191 "0": self.keyNumberGlobal,
194 def keyNumberGlobal(self, number):
195 # print "You pressed number " + str(number)
197 if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
198 self.pipDoHandle0Action()
200 self.servicelist.recallPrevService()
202 if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
203 self.session.openWithCallback(self.numberEntered, NumberZap, number)
205 def numberEntered(self, retval):
206 # print self.servicelist
208 self.zapToNumber(retval)
210 def searchNumberHelper(self, serviceHandler, num, bouquet):
211 servicelist = serviceHandler.list(bouquet)
212 if not servicelist is None:
214 serviceIterator = servicelist.getNext()
215 if not serviceIterator.valid(): #check end of list
217 playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
220 if not num: #found service with searched number ?
221 return serviceIterator, 0
224 def zapToNumber(self, number):
225 bouquet = self.servicelist.bouquet_root
227 serviceHandler = eServiceCenter.getInstance()
228 if not config.usage.multibouquet.value:
229 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
231 bouquetlist = serviceHandler.list(bouquet)
232 if not bouquetlist is None:
234 bouquet = bouquetlist.getNext()
235 if not bouquet.valid(): #check end of list
237 if bouquet.flags & eServiceReference.isDirectory:
238 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
239 if not service is None:
240 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
241 self.servicelist.clearPath()
242 if self.servicelist.bouquet_root != bouquet:
243 self.servicelist.enterPath(self.servicelist.bouquet_root)
244 self.servicelist.enterPath(bouquet)
245 self.servicelist.setCurrentSelection(service) #select the service in servicelist
246 self.servicelist.zap()
248 config.misc.initialchannelselection = ConfigBoolean(default = True)
250 class InfoBarChannelSelection:
251 """ ChannelSelection - handles the channelSelection dialog and the initial
252 channelChange actions which open the channelSelection dialog """
255 self.servicelist = self.session.instantiateDialog(ChannelSelection)
257 if config.misc.initialchannelselection.value:
258 self.onShown.append(self.firstRun)
260 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
262 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
263 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
264 "zapUp": (self.zapUp, _("previous channel")),
265 "zapDown": (self.zapDown, _("next channel")),
266 "historyBack": (self.historyBack, _("previous channel in history")),
267 "historyNext": (self.historyNext, _("next channel in history")),
268 "openServiceList": (self.openServiceList, _("open servicelist")),
271 def showTvChannelList(self, zap=False):
272 self.servicelist.setModeTv()
274 self.servicelist.zap()
275 self.session.execDialog(self.servicelist)
277 def showRadioChannelList(self, zap=False):
278 self.servicelist.setModeRadio()
280 self.servicelist.zap()
281 self.session.execDialog(self.servicelist)
284 self.onShown.remove(self.firstRun)
285 config.misc.initialchannelselection.value = False
286 config.misc.initialchannelselection.save()
287 self.switchChannelDown()
289 def historyBack(self):
290 self.servicelist.historyBack()
292 def historyNext(self):
293 self.servicelist.historyNext()
295 def switchChannelUp(self):
296 self.servicelist.moveUp()
297 self.session.execDialog(self.servicelist)
299 def switchChannelDown(self):
300 self.servicelist.moveDown()
301 self.session.execDialog(self.servicelist)
303 def openServiceList(self):
304 self.session.execDialog(self.servicelist)
307 if self.servicelist.inBouquet():
308 prev = self.servicelist.getCurrentSelection()
310 prev = prev.toString()
312 if config.usage.quickzap_bouquet_change.value:
313 if self.servicelist.atBegin():
314 self.servicelist.prevBouquet()
315 self.servicelist.moveUp()
316 cur = self.servicelist.getCurrentSelection()
317 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
320 self.servicelist.moveUp()
321 self.servicelist.zap()
324 if self.servicelist.inBouquet():
325 prev = self.servicelist.getCurrentSelection()
327 prev = prev.toString()
329 if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
330 self.servicelist.nextBouquet()
332 self.servicelist.moveDown()
333 cur = self.servicelist.getCurrentSelection()
334 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
337 self.servicelist.moveDown()
338 self.servicelist.zap()
341 """ Handles a menu action, to open the (main) menu """
343 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
345 "mainMenu": (self.mainMenu, _("Enter main menu...")),
347 self.session.infobar = None
350 print "loading mainmenu XML..."
351 menu = mdom.getroot()
352 assert menu.tag == "menu", "root element in menu must be 'menu'!"
354 self.session.infobar = self
355 # so we can access the currently active infobar from screens opened from within the mainmenu
356 # at the moment used from the SubserviceSelection
358 self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)
360 def mainMenuClosed(self, *val):
361 self.session.infobar = None
363 class InfoBarSimpleEventView:
364 """ Opens the Eventview for now/next """
366 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
368 "showEventInfo": (self.openEventView, _("show event details")),
371 def openEventView(self):
373 self.epglist = epglist
374 service = self.session.nav.getCurrentService()
375 ref = self.session.nav.getCurrentlyPlayingServiceReference()
376 info = service.info()
384 self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
386 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
387 epglist = self.epglist
390 epglist[0] = epglist[1]
394 class SimpleServicelist:
395 def __init__(self, services):
396 self.services = services
397 self.length = len(services)
400 def selectService(self, service):
402 while self.services[self.current].ref != service:
405 def nextService(self):
406 if self.current+1 < self.length:
411 def prevService(self):
412 if self.current-1 > -1:
415 self.current = self.length - 1
417 def currentService(self):
418 return self.services[self.current]
421 """ EPG - Opens an EPG list when the showEPGList action fires """
423 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
425 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
428 self.is_now_next = False
430 self.bouquetSel = None
431 self.eventView = None
432 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
434 "showEventInfo": (self.openEventView, _("show EPG...")),
435 "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
436 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
439 def showEventInfoWhenNotVisible(self):
446 def zapToService(self, service):
447 if not service is None:
448 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
449 self.servicelist.clearPath()
450 if self.servicelist.bouquet_root != self.epg_bouquet:
451 self.servicelist.enterPath(self.servicelist.bouquet_root)
452 self.servicelist.enterPath(self.epg_bouquet)
453 self.servicelist.setCurrentSelection(service) #select the service in servicelist
454 self.servicelist.zap()
456 def getBouquetServices(self, bouquet):
458 servicelist = eServiceCenter.getInstance().list(bouquet)
459 if not servicelist is None:
461 service = servicelist.getNext()
462 if not service.valid(): #check if end of list
464 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
466 services.append(ServiceReference(service))
469 def openBouquetEPG(self, bouquet, withCallback=True):
470 services = self.getBouquetServices(bouquet)
472 self.epg_bouquet = bouquet
474 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
476 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
478 def changeBouquetCB(self, direction, epg):
481 self.bouquetSel.down()
484 bouquet = self.bouquetSel.getCurrent()
485 services = self.getBouquetServices(bouquet)
487 self.epg_bouquet = bouquet
488 epg.setServices(services)
490 def closed(self, ret=False):
491 closedScreen = self.dlg_stack.pop()
492 if self.bouquetSel and closedScreen == self.bouquetSel:
493 self.bouquetSel = None
494 elif self.eventView and closedScreen == self.eventView:
495 self.eventView = None
497 dlgs=len(self.dlg_stack)
499 self.dlg_stack[dlgs-1].close(dlgs > 1)
501 def openMultiServiceEPG(self, withCallback=True):
502 bouquets = self.servicelist.getBouquetList()
507 if cnt > 1: # show bouquet list
509 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
510 self.dlg_stack.append(self.bouquetSel)
512 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
514 self.openBouquetEPG(bouquets[0][1], withCallback)
516 def changeServiceCB(self, direction, epg):
519 self.serviceSel.nextService()
521 self.serviceSel.prevService()
522 epg.setService(self.serviceSel.currentService())
524 def SingleServiceEPGClosed(self, ret=False):
525 self.serviceSel = None
527 def openSingleServiceEPG(self):
528 ref=self.session.nav.getCurrentlyPlayingServiceReference()
530 if self.servicelist.getMutableList() is not None: # bouquet in channellist
531 current_path = self.servicelist.getRoot()
532 services = self.getBouquetServices(current_path)
533 self.serviceSel = SimpleServicelist(services)
534 self.serviceSel.selectService(ref)
535 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
537 self.session.open(EPGSelection, ref)
539 def showEventInfoPlugins(self):
540 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
543 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
544 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list)
546 self.openSingleServiceEPG()
548 def runPlugin(self, plugin):
549 plugin(session = self.session, servicelist = self.servicelist)
551 def EventInfoPluginChosen(self, answer):
552 if answer is not None:
555 def openSimilarList(self, eventid, refstr):
556 self.session.open(EPGSelection, refstr, None, eventid)
558 def getNowNext(self):
560 service = self.session.nav.getCurrentService()
561 info = service and service.info()
562 ptr = info and info.getEvent(0)
565 ptr = info and info.getEvent(1)
568 self.epglist = epglist
570 def __evEventInfoChanged(self):
571 if self.is_now_next and len(self.dlg_stack) == 1:
573 assert self.eventView
575 self.eventView.setEvent(self.epglist[0])
577 def openEventView(self):
578 ref = self.session.nav.getCurrentlyPlayingServiceReference()
580 epglist = self.epglist
582 self.is_now_next = False
583 epg = eEPGCache.getInstance()
584 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
587 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
591 self.is_now_next = True
593 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
594 self.dlg_stack.append(self.eventView)
596 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
597 self.openMultiServiceEPG(False)
599 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
600 epglist = self.epglist
603 epglist[0]=epglist[1]
607 class InfoBarRdsDecoder:
608 """provides RDS and Rass support/display"""
610 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
611 self.rass_interactive = None
613 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
615 iPlayableService.evEnd: self.__serviceStopped,
616 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
619 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
621 "startRassInteractive": self.startRassInteractive
624 self["RdsActions"].setEnabled(False)
626 self.onLayoutFinish.append(self.rds_display.show)
627 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
629 def RassInteractivePossibilityChanged(self, state):
630 self["RdsActions"].setEnabled(state)
632 def RassSlidePicChanged(self):
633 if not self.rass_interactive:
634 service = self.session.nav.getCurrentService()
635 decoder = service and service.rdsDecoder()
637 decoder.showRassSlidePicture()
639 def __serviceStopped(self):
640 if self.rass_interactive is not None:
641 rass_interactive = self.rass_interactive
642 self.rass_interactive = None
643 rass_interactive.close()
645 def startRassInteractive(self):
646 self.rds_display.hide()
647 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
649 def RassInteractiveClosed(self, *val):
650 if self.rass_interactive is not None:
651 self.rass_interactive = None
652 self.RassSlidePicChanged()
653 self.rds_display.show()
656 """handles actions like seeking, pause"""
658 SEEK_STATE_PLAY = (0, 0, 0, ">")
659 SEEK_STATE_PAUSE = (1, 0, 0, "||")
660 SEEK_STATE_EOF = (1, 0, 0, "END")
662 def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
663 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
665 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
666 iPlayableService.evStart: self.__serviceStarted,
668 iPlayableService.evEOF: self.__evEOF,
669 iPlayableService.evSOF: self.__evSOF,
672 self.eofTimer = eTimer()
673 self.eofTimer.timeout.get().append(self.doEof)
674 self.eofInhibitTimer = eTimer()
675 self.eofInhibitTimer.timeout.get().append(self.inhibitEof)
677 self.minSpeedBackward = useSeekBackHack and 16 or 0
679 class InfoBarSeekActionMap(HelpableActionMap):
680 def __init__(self, screen, *args, **kwargs):
681 HelpableActionMap.__init__(self, screen, *args, **kwargs)
684 def action(self, contexts, action):
685 print "action:", action
686 if action[:5] == "seek:":
687 time = int(action[5:])
688 self.screen.doSeekRelative(time * 90000)
690 elif action[:8] == "seekdef:":
691 key = int(action[8:])
692 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
693 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
694 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
695 self.screen.doSeekRelative(time * 90000)
698 return HelpableActionMap.action(self, contexts, action)
700 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
702 "playpauseService": self.playpauseService,
703 "pauseService": (self.pauseService, _("pause")),
704 "unPauseService": (self.unPauseService, _("continue")),
706 "seekFwd": (self.seekFwd, _("skip forward")),
707 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
708 "seekBack": (self.seekBack, _("skip backward")),
709 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
711 # give them a little more priority to win over color buttons
713 self["SeekActions"].setEnabled(False)
715 self.seekstate = self.SEEK_STATE_PLAY
716 self.lastseekstate = self.SEEK_STATE_PLAY
718 self.onPlayStateChanged = [ ]
720 self.lockedBecauseOfSkipping = False
722 self.__seekableStatusChanged()
724 def makeStateForward(self, n):
725 minspeed = config.seek.stepwise_minspeed.value
726 repeat = int(config.seek.stepwise_repeat.value)
727 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
728 return (0, n * repeat, repeat, ">> %dx" % n)
730 return (0, n, 0, ">> %dx" % n)
732 def makeStateBackward(self, n):
733 minspeed = config.seek.stepwise_minspeed.value
734 repeat = int(config.seek.stepwise_repeat.value)
735 if self.minSpeedBackward and n < self.minSpeedBackward:
736 r = (self.minSpeedBackward - 1)/ n + 1
737 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
739 return (0, -n * r, r, "<< %dx" % n)
740 elif minspeed != "Never" and n >= int(minspeed) and repeat > 1:
741 return (0, -n * repeat, repeat, "<< %dx" % n)
743 return (0, -n, 0, "<< %dx" % n)
745 def makeStateSlowMotion(self, n):
746 return (0, 0, n, "/%d" % n)
748 def isStateForward(self, state):
751 def isStateBackward(self, state):
754 def isStateSlowMotion(self, state):
755 return state[1] == 0 and state[2] > 1
757 def getHigher(self, n, lst):
763 def getLower(self, n, lst):
771 def showAfterSeek(self):
772 if isinstance(self, InfoBarShowHide):
782 service = self.session.nav.getCurrentService()
786 seek = service.seek()
788 if seek is None or not seek.isCurrentlySeekable():
793 def isSeekable(self):
794 if self.getSeek() is None:
798 def __seekableStatusChanged(self):
799 # print "seekable status changed!"
800 if not self.isSeekable():
801 self["SeekActions"].setEnabled(False)
802 # print "not seekable, return to play"
803 self.setSeekState(self.SEEK_STATE_PLAY)
805 self["SeekActions"].setEnabled(True)
808 def __serviceStarted(self):
809 self.seekstate = self.SEEK_STATE_PLAY
810 self.__seekableStatusChanged()
811 if self.eofState != 0:
815 def setSeekState(self, state):
816 service = self.session.nav.getCurrentService()
821 if not self.isSeekable():
822 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
823 state = self.SEEK_STATE_PLAY
825 pauseable = service.pause()
827 if pauseable is None:
828 print "not pauseable."
829 state = self.SEEK_STATE_PLAY
831 oldstate = self.seekstate
832 self.seekstate = state
835 if oldstate[i] != self.seekstate[i]:
836 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
838 for c in self.onPlayStateChanged:
841 self.checkSkipShowHideLock()
845 def playpauseService(self):
846 if self.seekstate != self.SEEK_STATE_PLAY:
847 self.unPauseService()
851 def pauseService(self):
852 if self.seekstate == self.SEEK_STATE_PAUSE:
853 if config.seek.on_pause.value == "play":
854 self.unPauseService()
855 elif config.seek.on_pause.value == "step":
856 self.doSeekRelative(0)
857 elif config.seek.on_pause.value == "last":
858 self.setSeekState(self.lastseekstate)
859 self.lastseekstate = self.SEEK_STATE_PLAY
861 if self.seekstate != self.SEEK_STATE_EOF:
862 self.lastseekstate = self.seekstate
863 self.setSeekState(self.SEEK_STATE_PAUSE);
865 def unPauseService(self):
867 if self.seekstate == self.SEEK_STATE_PLAY:
869 self.setSeekState(self.SEEK_STATE_PLAY)
871 def doSeek(self, pts):
872 seekable = self.getSeek()
875 prevstate = self.seekstate
876 if self.eofState == 1:
879 if self.seekstate == self.SEEK_STATE_EOF:
880 if prevstate == self.SEEK_STATE_PAUSE:
881 self.setSeekState(self.SEEK_STATE_PAUSE)
883 self.setSeekState(self.SEEK_STATE_PLAY)
884 self.eofInhibitTimer.start(200, True)
887 def doSeekRelative(self, pts):
888 seekable = self.getSeek()
891 prevstate = self.seekstate
892 if self.eofState == 1:
895 if self.seekstate == self.SEEK_STATE_EOF:
896 if prevstate == self.SEEK_STATE_PAUSE:
897 self.setSeekState(self.SEEK_STATE_PAUSE)
899 self.setSeekState(self.SEEK_STATE_PLAY)
900 self.eofInhibitTimer.start(200, True)
901 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
902 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
906 if self.seekstate == self.SEEK_STATE_PLAY:
907 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
908 elif self.seekstate == self.SEEK_STATE_PAUSE:
909 if len(config.seek.speeds_slowmotion.value):
910 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
912 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
913 elif self.seekstate == self.SEEK_STATE_EOF:
915 elif self.isStateForward(self.seekstate):
916 speed = self.seekstate[1]
917 if self.seekstate[2]:
918 speed /= self.seekstate[2]
919 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
920 self.setSeekState(self.makeStateForward(speed))
921 elif self.isStateBackward(self.seekstate):
922 speed = -self.seekstate[1]
923 if self.seekstate[2]:
924 speed /= self.seekstate[2]
925 speed = self.getLower(speed, config.seek.speeds_backward.value)
927 self.setSeekState(self.makeStateBackward(speed))
929 self.setSeekState(self.SEEK_STATE_PLAY)
930 elif self.isStateSlowMotion(self.seekstate):
931 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
932 self.setSeekState(self.makeStateSlowMotion(speed))
935 seekstate = self.seekstate
936 if seekstate == self.SEEK_STATE_PLAY:
937 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
938 elif seekstate == self.SEEK_STATE_EOF:
939 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
940 self.doSeekRelative(-6)
941 elif seekstate == self.SEEK_STATE_PAUSE:
942 self.doSeekRelative(-3)
943 elif self.isStateForward(seekstate):
946 speed /= seekstate[2]
947 speed = self.getLower(speed, config.seek.speeds_forward.value)
949 self.setSeekState(self.makeStateForward(speed))
951 self.setSeekState(self.SEEK_STATE_PLAY)
952 elif self.isStateBackward(seekstate):
953 speed = -seekstate[1]
955 speed /= seekstate[2]
956 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
957 self.setSeekState(self.makeStateBackward(speed))
958 elif self.isStateSlowMotion(seekstate):
959 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
961 self.setSeekState(self.makeStateSlowMotion(speed))
963 self.setSeekState(self.SEEK_STATE_PAUSE)
965 def seekFwdManual(self):
966 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
968 def fwdSeekTo(self, minutes):
969 print "Seek", minutes, "minutes forward"
970 self.doSeekRelative(minutes * 60 * 90000)
972 def seekBackManual(self):
973 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
975 def rwdSeekTo(self, minutes):
977 self.doSeekRelative(-minutes * 60 * 90000)
979 def checkSkipShowHideLock(self):
980 wantlock = self.seekstate != self.SEEK_STATE_PLAY
982 if config.usage.show_infobar_on_skip.value:
983 if self.lockedBecauseOfSkipping and not wantlock:
985 self.lockedBecauseOfSkipping = False
987 if wantlock and not self.lockedBecauseOfSkipping:
989 self.lockedBecauseOfSkipping = True
991 def calcRemainingTime(self):
992 seekable = self.getSeek()
993 if seekable is not None:
994 len = seekable.getLength()
996 tmp = self.cueGetEndCutPosition()
1001 pos = seekable.getPlayPosition()
1002 speednom = self.seekstate[1] or 1
1003 speedden = self.seekstate[2] or 1
1004 if not len[0] and not pos[0]:
1005 if len[1] <= pos[1]:
1007 time = (len[1] - pos[1])*speedden/(90*speednom)
1012 if self.eofState == 0 and self.seekstate != self.SEEK_STATE_EOF:
1014 time = self.calcRemainingTime()
1016 time = 3000 # Failed to calc, use default
1018 time = 300 # Passed end, shortest wait
1020 self.eofState = -2 # Too long, block eof
1023 time += 1000 # Add margin
1024 self.eofTimer.start(time, True)
1026 def inhibitEof(self):
1027 if self.eofState >= 1:
1028 self.eofState = -self.eofState
1029 self.eofTimer.stop()
1033 if self.seekstate == self.SEEK_STATE_EOF:
1035 if self.eofState == -2 or self.isStateBackward(self.seekstate):
1039 # if we are seeking, we try to end up ~1s before the end, and pause there.
1040 eofstate = self.eofState
1041 seekstate = self.seekstate
1043 if not self.seekstate == self.SEEK_STATE_PAUSE:
1044 self.setSeekState(self.SEEK_STATE_EOF)
1045 if eofstate == -1 or not seekstate in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
1046 seekable = self.getSeek()
1047 if seekable is not None:
1049 if eofstate == 1 and seekstate == self.SEEK_STATE_PLAY:
1050 self.doEofInternal(True)
1052 self.doEofInternal(False)
1054 def doEofInternal(self, playing):
1055 pass # Defined in subclasses
1058 self.setSeekState(self.SEEK_STATE_PLAY)
1061 from Screens.PVRState import PVRState, TimeshiftState
1063 class InfoBarPVRState:
1064 def __init__(self, screen=PVRState, force_show = False):
1065 self.onPlayStateChanged.append(self.__playStateChanged)
1066 self.pvrStateDialog = self.session.instantiateDialog(screen)
1067 self.onShow.append(self._mayShow)
1068 self.onHide.append(self.pvrStateDialog.hide)
1069 self.force_show = force_show
1072 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1073 self.pvrStateDialog.show()
1075 def __playStateChanged(self, state):
1076 playstateString = state[3]
1077 self.pvrStateDialog["state"].setText(playstateString)
1079 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
1080 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
1081 self.pvrStateDialog.hide()
1086 class InfoBarTimeshiftState(InfoBarPVRState):
1088 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1091 if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
1092 self.pvrStateDialog.show()
1094 class InfoBarShowMovies:
1096 # i don't really like this class.
1097 # it calls a not further specified "movie list" on up/down/movieList,
1098 # so this is not more than an action map
1100 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1102 "movieList": (self.showMovies, _("movie list")),
1103 "up": (self.showMovies, _("movie list")),
1104 "down": (self.showMovies, _("movie list"))
1107 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1111 # Timeshift works the following way:
1112 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1113 # - normal playback TUNER unused PLAY enable disable disable
1114 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1115 # - user presess pause again FILE record PLAY enable disable enable
1116 # - user fast forwards FILE record FF enable disable enable
1117 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1118 # - user backwards FILE record BACK # !! enable disable enable
1122 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1123 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1124 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1125 # - the user can now PVR around
1126 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1127 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1129 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1130 # - if the user rewinds, or press pause, timeshift will be activated again
1132 # note that a timeshift can be enabled ("recording") and
1133 # activated (currently time-shifting).
1135 class InfoBarTimeshift:
1137 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1139 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1140 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1142 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1144 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1145 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1146 }, prio=-1) # priority over record
1148 self.timeshift_enabled = 0
1149 self.timeshift_state = 0
1150 self.ts_rewind_timer = eTimer()
1151 self.ts_rewind_timer.callback.append(self.rewindService)
1153 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1155 iPlayableService.evStart: self.__serviceStarted,
1156 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1159 def getTimeshift(self):
1160 service = self.session.nav.getCurrentService()
1161 return service and service.timeshift()
1163 def startTimeshift(self):
1164 print "enable timeshift"
1165 ts = self.getTimeshift()
1167 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1168 print "no ts interface"
1171 if self.timeshift_enabled:
1172 print "hu, timeshift already enabled?"
1174 if not ts.startTimeshift():
1175 self.timeshift_enabled = 1
1177 # we remove the "relative time" for now.
1178 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1181 #self.setSeekState(self.SEEK_STATE_PAUSE)
1182 self.activateTimeshiftEnd(False)
1184 # enable the "TimeshiftEnableActions", which will override
1185 # the startTimeshift actions
1186 self.__seekableStatusChanged()
1188 print "timeshift failed"
1190 def stopTimeshift(self):
1191 if not self.timeshift_enabled:
1193 print "disable timeshift"
1194 ts = self.getTimeshift()
1197 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1199 def stopTimeshiftConfirmed(self, confirmed):
1203 ts = self.getTimeshift()
1208 self.timeshift_enabled = 0
1211 self.__seekableStatusChanged()
1213 # activates timeshift, and seeks to (almost) the end
1214 def activateTimeshiftEnd(self, back = True):
1215 ts = self.getTimeshift()
1216 print "activateTimeshiftEnd"
1221 if ts.isTimeshiftActive():
1222 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1226 ts.activateTimeshift() # activate timeshift will automatically pause
1227 self.setSeekState(self.SEEK_STATE_PAUSE)
1230 self.doSeek(-5) # seek some gops before end
1231 self.ts_rewind_timer.start(200, 1)
1233 self.doSeek(-1) # seek 1 gop before end
1235 def rewindService(self):
1236 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1238 # same as activateTimeshiftEnd, but pauses afterwards.
1239 def activateTimeshiftEndAndPause(self):
1240 print "activateTimeshiftEndAndPause"
1241 #state = self.seekstate
1242 self.activateTimeshiftEnd(False)
1244 def __seekableStatusChanged(self):
1247 # print "self.isSeekable", self.isSeekable()
1248 # print "self.timeshift_enabled", self.timeshift_enabled
1250 # when this service is not seekable, but timeshift
1251 # is enabled, this means we can activate
1253 if not self.isSeekable() and self.timeshift_enabled:
1256 # print "timeshift activate:", enabled
1257 self["TimeshiftActivateActions"].setEnabled(enabled)
1259 def __serviceStarted(self):
1260 self.timeshift_enabled = False
1261 self.__seekableStatusChanged()
1263 from Screens.PiPSetup import PiPSetup
1265 class InfoBarExtensions:
1266 EXTENSION_SINGLE = 0
1272 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1274 "extensions": (self.showExtensionSelection, _("view extensions...")),
1275 }, 1) # lower priority
1277 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1278 self.list.append((type, extension, key))
1280 def updateExtension(self, extension, key = None):
1281 self.extensionsList.append(extension)
1283 if self.extensionKeys.has_key(key):
1287 for x in self.availableKeys:
1288 if not self.extensionKeys.has_key(x):
1293 self.extensionKeys[key] = len(self.extensionsList) - 1
1295 def updateExtensions(self):
1296 self.extensionsList = []
1297 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1298 self.extensionKeys = {}
1300 if x[0] == self.EXTENSION_SINGLE:
1301 self.updateExtension(x[1], x[2])
1304 self.updateExtension(y[0], y[1])
1307 def showExtensionSelection(self):
1308 self.updateExtensions()
1309 extensionsList = self.extensionsList[:]
1312 for x in self.availableKeys:
1313 if self.extensionKeys.has_key(x):
1314 entry = self.extensionKeys[x]
1315 extension = self.extensionsList[entry]
1317 name = str(extension[0]())
1318 list.append((extension[0](), extension))
1320 extensionsList.remove(extension)
1322 extensionsList.remove(extension)
1323 list.extend([(x[0](), x) for x in extensionsList])
1325 keys += [""] * len(extensionsList)
1326 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
1328 def extensionCallback(self, answer):
1329 if answer is not None:
1332 from Tools.BoundFunction import boundFunction
1334 # depends on InfoBarExtensions
1336 class InfoBarPlugins:
1338 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1340 def getPluginName(self, name):
1343 def getPluginList(self):
1344 return [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
1346 def runPlugin(self, plugin):
1347 if isinstance(self, InfoBarChannelSelection):
1348 plugin(session = self.session, servicelist = self.servicelist)
1350 plugin(session = self.session)
1352 from Components.Task import job_manager
1353 class InfoBarJobman:
1355 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1357 def getJobList(self):
1358 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1360 def getJobName(self, job):
1361 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1363 def showJobView(self, job):
1364 from Screens.TaskView import JobView
1365 job_manager.in_background = False
1366 self.session.openWithCallback(self.JobViewCB, JobView, job)
1368 def JobViewCB(self, in_background):
1369 job_manager.in_background = in_background
1371 # depends on InfoBarExtensions
1372 class InfoBarSleepTimer:
1374 self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, lambda: True), "1")
1376 def getSleepTimerName(self):
1377 return _("Sleep Timer")
1379 def showSleepTimerSetup(self):
1380 self.session.open(SleepTimerEdit)
1382 # depends on InfoBarExtensions
1385 self.session.pipshown = False
1386 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1387 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1388 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1389 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1392 return self.session.pipshown
1394 def pipHandles0Action(self):
1395 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1397 def getShowHideName(self):
1398 if self.session.pipshown:
1399 return _("Disable Picture in Picture")
1401 return _("Activate Picture in Picture")
1403 def getSwapName(self):
1404 return _("Swap Services")
1406 def getMoveName(self):
1407 return _("Move Picture in Picture")
1410 if self.session.pipshown:
1411 del self.session.pip
1412 self.session.pipshown = False
1414 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1415 self.session.pip.show()
1416 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1417 if self.session.pip.playService(newservice):
1418 self.session.pipshown = True
1419 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1421 self.session.pipshown = False
1422 del self.session.pip
1423 self.session.nav.playService(newservice)
1426 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1427 if self.session.pip.servicePath:
1428 servicepath = self.servicelist.getCurrentServicePath()
1429 ref=servicepath[len(servicepath)-1]
1430 pipref=self.session.pip.getCurrentService()
1431 self.session.pip.playService(swapservice)
1432 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1433 if pipref.toString() != ref.toString(): # is a subservice ?
1434 self.session.nav.stopService() # stop portal
1435 self.session.nav.playService(pipref) # start subservice
1436 self.session.pip.servicePath=servicepath
1439 self.session.open(PiPSetup, pip = self.session.pip)
1441 def pipDoHandle0Action(self):
1442 use = config.usage.pip_zero_button.value
1445 elif "swapstop" == use:
1451 from RecordTimer import parseEvent, RecordTimerEntry
1453 class InfoBarInstantRecord:
1454 """Instant Record - handles the instantRecord action in order to
1455 start/stop instant records"""
1457 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1459 "instantRecord": (self.instantRecord, _("Instant Record...")),
1463 def stopCurrentRecording(self, entry = -1):
1464 if entry is not None and entry != -1:
1465 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1466 self.recording.remove(self.recording[entry])
1468 def startInstantRecording(self, limitEvent = False):
1469 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1471 # try to get event info
1474 service = self.session.nav.getCurrentService()
1475 epg = eEPGCache.getInstance()
1476 event = epg.lookupEventTime(serviceref, -1, 0)
1478 info = service.info()
1479 ev = info.getEvent(0)
1485 end = begin + 3600 # dummy
1486 name = "instant record"
1490 if event is not None:
1491 curEvent = parseEvent(event)
1493 description = curEvent[3]
1494 eventid = curEvent[4]
1499 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1501 if isinstance(serviceref, eServiceReference):
1502 serviceref = ServiceReference(serviceref)
1504 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
1505 recording.dontSave = True
1507 if event is None or limitEvent == False:
1508 recording.autoincrease = True
1509 if recording.setAutoincreaseEnd():
1510 self.session.nav.RecordTimer.record(recording)
1511 self.recording.append(recording)
1513 simulTimerList = self.session.nav.RecordTimer.record(recording)
1514 if simulTimerList is not None: # conflict with other recording
1515 name = simulTimerList[1].name
1516 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1517 print "[TIMER] conflicts with", name_date
1518 recording.autoincrease = True # start with max available length, then increment
1519 if recording.setAutoincreaseEnd():
1520 self.session.nav.RecordTimer.record(recording)
1521 self.recording.append(recording)
1522 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1524 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1525 recording.autoincrease = False
1527 self.recording.append(recording)
1529 def isInstantRecordRunning(self):
1530 print "self.recording:", self.recording
1532 for x in self.recording:
1537 def recordQuestionCallback(self, answer):
1538 print "pre:\n", self.recording
1540 if answer is None or answer[1] == "no":
1543 recording = self.recording[:]
1545 if not x in self.session.nav.RecordTimer.timer_list:
1546 self.recording.remove(x)
1547 elif x.dontSave and x.isRunning():
1548 list.append((x, False))
1550 if answer[1] == "changeduration":
1551 if len(self.recording) == 1:
1552 self.changeDuration(0)
1554 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1555 elif answer[1] == "changeendtime":
1556 if len(self.recording) == 1:
1559 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1560 elif answer[1] == "stop":
1561 if len(self.recording) == 1:
1562 self.stopCurrentRecording(0)
1564 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1565 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1566 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1567 if answer[1] == "manualduration":
1568 self.changeDuration(len(self.recording)-1)
1569 elif answer[1] == "manualendtime":
1570 self.setEndtime(len(self.recording)-1)
1571 print "after:\n", self.recording
1573 def setEndtime(self, entry):
1574 if entry is not None:
1575 self.selectedEntry = entry
1576 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1577 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1578 dlg.setTitle(_("Please change recording endtime"))
1580 def TimeDateInputClosed(self, ret):
1583 localendtime = localtime(ret[1])
1584 print "stopping recording at", strftime("%c", localendtime)
1585 if self.recording[self.selectedEntry].end != ret[1]:
1586 self.recording[self.selectedEntry].autoincrease = False
1587 self.recording[self.selectedEntry].end = ret[1]
1588 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1590 def changeDuration(self, entry):
1591 if entry is not None:
1592 self.selectedEntry = entry
1593 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1595 def inputCallback(self, value):
1596 if value is not None:
1597 print "stopping recording after", int(value), "minutes."
1598 entry = self.recording[self.selectedEntry]
1600 entry.autoincrease = False
1601 entry.end = int(time()) + 60 * int(value)
1602 self.session.nav.RecordTimer.timeChanged(entry)
1604 def instantRecord(self):
1605 dir = config.movielist.last_videodir.value
1606 if not fileExists(dir, 'w'):
1607 dir = resolveFilename(SCOPE_HDD)
1611 # XXX: this message is a little odd as we might be recording to a remote device
1612 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1615 if self.isInstantRecordRunning():
1616 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1617 title=_("A recording is currently running.\nWhat do you want to do?"), \
1618 list=((_("add recording (stop after current event)"), "event"), \
1619 (_("add recording (enter recording duration)"), "manualduration"), \
1620 (_("add recording (enter recording endtime)"), "manualendtime"), \
1621 (_("add recording (indefinitely)"), "indefinitely"), \
1622 (_("change recording (duration)"), "changeduration"), \
1623 (_("change recording (endtime)"), "changeendtime"), \
1624 (_("stop recording"), "stop"), \
1625 (_("do nothing"), "no")))
1627 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1628 title=_("Start recording?"), \
1629 list=((_("add recording (stop after current event)"), "event"), \
1630 (_("add recording (enter recording duration)"), "manualduration"), \
1631 (_("add recording (enter recording endtime)"), "manualendtime"), \
1632 (_("add recording (indefinitely)"), "indefinitely"), \
1633 (_("don't record"), "no")))
1635 from Tools.ISO639 import LanguageCodes
1637 class InfoBarAudioSelection:
1639 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1641 "audioSelection": (self.audioSelection, _("Audio Options...")),
1644 def audioSelection(self):
1645 service = self.session.nav.getCurrentService()
1646 self.audioTracks = audio = service and service.audioTracks()
1647 n = audio and audio.getNumberOfTracks() or 0
1650 self.audioChannel = service.audioChannel()
1654 i = audio.getTrackInfo(idx)
1655 language = i.getLanguage()
1656 description = i.getDescription()
1658 if LanguageCodes.has_key(language):
1659 language = LanguageCodes[language][0]
1661 if len(description):
1662 description += " (" + language + ")"
1664 description = language
1666 tlist.append((description, idx))
1669 tlist.sort(key=lambda x: x[0])
1671 selectedAudio = self.audioTracks.getCurrentTrack()
1676 if x[1] != selectedAudio:
1681 if SystemInfo["CanDownmixAC3"]:
1682 tlist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1683 ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"),
1685 keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1688 tlist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
1689 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1691 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
1693 del self.audioTracks
1695 def changeAC3Downmix(self, arg):
1696 choicelist = self.session.current_dialog["list"]
1697 list = choicelist.list
1699 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1700 _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
1701 choicelist.setList(list)
1702 if config.av.downmix_ac3.value:
1703 config.av.downmix_ac3.value = False
1705 config.av.downmix_ac3.value = True
1706 config.av.downmix_ac3.save()
1708 def audioSelected(self, audio):
1709 if audio is not None:
1710 if isinstance(audio[1], str):
1711 if audio[1] == "mode":
1712 keys = ["red", "green", "yellow"]
1713 selection = self.audioChannel.getCurrentChannel()
1714 tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
1715 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
1717 del self.audioChannel
1718 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1719 self.audioTracks.selectTrack(audio[1])
1721 del self.audioChannel
1722 del self.audioTracks
1724 def modeSelected(self, mode):
1725 if mode is not None:
1726 self.audioChannel.selectChannel(mode[1])
1727 del self.audioChannel
1729 class InfoBarSubserviceSelection:
1731 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1733 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1736 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1738 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1739 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1741 self["SubserviceQuickzapAction"].setEnabled(False)
1743 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1745 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1750 def checkSubservicesAvail(self):
1751 service = self.session.nav.getCurrentService()
1752 subservices = service and service.subServices()
1753 if not subservices or subservices.getNumberOfSubservices() == 0:
1754 self["SubserviceQuickzapAction"].setEnabled(False)
1756 def nextSubservice(self):
1757 self.changeSubservice(+1)
1759 def prevSubservice(self):
1760 self.changeSubservice(-1)
1762 def changeSubservice(self, direction):
1763 service = self.session.nav.getCurrentService()
1764 subservices = service and service.subServices()
1765 n = subservices and subservices.getNumberOfSubservices()
1768 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1771 if subservices.getSubservice(idx).toString() == ref.toString():
1776 selection += direction
1781 newservice = subservices.getSubservice(selection)
1782 if newservice.valid():
1785 self.session.nav.playService(newservice, False)
1787 def subserviceSelection(self):
1788 service = self.session.nav.getCurrentService()
1789 subservices = service and service.subServices()
1790 self.bouquets = self.servicelist.getBouquetList()
1791 n = subservices and subservices.getNumberOfSubservices()
1794 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1798 i = subservices.getSubservice(idx)
1799 if i.toString() == ref.toString():
1801 tlist.append((i.getName(), i))
1804 if self.bouquets and len(self.bouquets):
1805 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1806 if config.usage.multibouquet.value:
1807 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1809 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1812 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1813 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1816 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys)
1818 def subserviceSelected(self, service):
1820 if not service is None:
1821 if isinstance(service[1], str):
1822 if service[1] == "quickzap":
1823 from Screens.SubservicesQuickzap import SubservicesQuickzap
1824 self.session.open(SubservicesQuickzap, service[2])
1826 self["SubserviceQuickzapAction"].setEnabled(True)
1827 self.session.nav.playService(service[1], False)
1829 def addSubserviceToBouquetCallback(self, service):
1830 if len(service) > 1 and isinstance(service[1], eServiceReference):
1831 self.selectedSubservice = service
1832 if self.bouquets is None:
1835 cnt = len(self.bouquets)
1836 if cnt > 1: # show bouquet list
1837 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1838 elif cnt == 1: # add to only one existing bouquet
1839 self.addSubserviceToBouquet(self.bouquets[0][1])
1840 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1842 def bouquetSelClosed(self, confirmed):
1844 del self.selectedSubservice
1846 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1848 def addSubserviceToBouquet(self, dest):
1849 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1851 self.bsel.close(True)
1853 del self.selectedSubservice
1855 class InfoBarAdditionalInfo:
1858 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1859 self["TimeshiftPossible"] = self["RecordingPossible"]
1860 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1861 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1862 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1863 self["ExtensionsAvailable"] = Boolean(fixed=1)
1865 class InfoBarNotifications:
1867 self.onExecBegin.append(self.checkNotifications)
1868 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1869 self.onClose.append(self.__removeNotification)
1871 def __removeNotification(self):
1872 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1874 def checkNotificationsIfExecing(self):
1876 self.checkNotifications()
1878 def checkNotifications(self):
1879 notifications = Notifications.notifications
1881 n = notifications[0]
1883 del notifications[0]
1886 if n[3].has_key("onSessionOpenCallback"):
1887 n[3]["onSessionOpenCallback"]()
1888 del n[3]["onSessionOpenCallback"]
1891 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1893 dlg = self.session.open(n[1], *n[2], **n[3])
1895 # remember that this notification is currently active
1897 Notifications.current_notifications.append(d)
1898 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1900 def __notificationClosed(self, d):
1901 Notifications.current_notifications.remove(d)
1903 class InfoBarServiceNotifications:
1905 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1907 iPlayableService.evEnd: self.serviceHasEnded
1910 def serviceHasEnded(self):
1911 print "service end!"
1914 self.setSeekState(self.SEEK_STATE_PLAY)
1918 class InfoBarCueSheetSupport:
1924 ENABLE_RESUME_SUPPORT = False
1926 def __init__(self, actionmap = "InfobarCueSheetActions"):
1927 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1929 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1930 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1931 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1935 self.is_closing = False
1936 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1938 iPlayableService.evStart: self.__serviceStarted,
1941 def __serviceStarted(self):
1944 print "new service started! trying to download cuts!"
1945 self.downloadCuesheet()
1947 if self.ENABLE_RESUME_SUPPORT:
1950 for (pts, what) in self.cut_list:
1951 if what == self.CUT_TYPE_LAST:
1954 if last is not None:
1955 self.resume_point = last
1956 if config.usage.on_movie_start.value == "ask":
1957 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1958 elif config.usage.on_movie_start.value == "resume":
1959 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1960 # TRANSLATORS: at the start of a movie, when the user has selected
1961 # TRANSLATORS: "Resume from last position" as start behavior.
1962 # TRANSLATORS: The purpose is to notify the user that the movie starts
1963 # TRANSLATORS: in the middle somewhere and not from the beginning.
1964 # TRANSLATORS: (Some translators seem to have interpreted it as a
1965 # TRANSLATORS: question or a choice, but it is a statement.)
1966 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1968 def playLastCB(self, answer):
1970 self.doSeek(self.resume_point)
1971 self.hideAfterResume()
1973 def hideAfterResume(self):
1974 if isinstance(self, InfoBarShowHide):
1977 def __getSeekable(self):
1978 service = self.session.nav.getCurrentService()
1981 return service.seek()
1983 def cueGetCurrentPosition(self):
1984 seek = self.__getSeekable()
1987 r = seek.getPlayPosition()
1992 def cueGetEndCutPosition(self):
1995 for cp in self.cut_list:
1996 if cp[1] == self.CUT_TYPE_OUT:
2000 elif cp[1] == self.CUT_TYPE_IN:
2004 def jumpPreviousNextMark(self, cmp, start=False):
2005 current_pos = self.cueGetCurrentPosition()
2006 if current_pos is None:
2008 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
2009 if mark is not None:
2017 def jumpPreviousMark(self):
2018 # we add 2 seconds, so if the play position is <2s after
2019 # the mark, the mark before will be used
2020 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
2022 def jumpNextMark(self):
2023 if not self.jumpPreviousNextMark(lambda x: x):
2026 def getNearestCutPoint(self, pts, cmp=abs, start=False):
2032 bestdiff = cmp(0 - pts)
2034 nearest = [0, False]
2035 for cp in self.cut_list:
2036 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
2038 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
2039 diff = cmp(cp[0] - pts)
2045 if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
2046 diff = cmp(cp[0] - pts)
2047 if diff >= 0 and (nearest is None or bestdiff > diff):
2052 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
2053 current_pos = self.cueGetCurrentPosition()
2054 if current_pos is None:
2055 print "not seekable"
2058 nearest_cutpoint = self.getNearestCutPoint(current_pos)
2060 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
2062 return nearest_cutpoint
2064 self.removeMark(nearest_cutpoint)
2065 elif not onlyremove and not onlyreturn:
2066 self.addMark((current_pos, self.CUT_TYPE_MARK))
2071 def addMark(self, point):
2072 insort(self.cut_list, point)
2073 self.uploadCuesheet()
2074 self.showAfterCuesheetOperation()
2076 def removeMark(self, point):
2077 self.cut_list.remove(point)
2078 self.uploadCuesheet()
2079 self.showAfterCuesheetOperation()
2081 def showAfterCuesheetOperation(self):
2082 if isinstance(self, InfoBarShowHide):
2085 def __getCuesheet(self):
2086 service = self.session.nav.getCurrentService()
2089 return service.cueSheet()
2091 def uploadCuesheet(self):
2092 cue = self.__getCuesheet()
2095 print "upload failed, no cuesheet interface"
2097 cue.setCutList(self.cut_list)
2099 def downloadCuesheet(self):
2100 cue = self.__getCuesheet()
2103 print "download failed, no cuesheet interface"
2106 self.cut_list = cue.getCutList()
2108 class InfoBarSummary(Screen):
2110 <screen position="0,0" size="132,64">
2111 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2112 <convert type="ClockToText">WithSeconds</convert>
2114 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2115 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2116 <convert type="ConditionalShowHide">Blink</convert>
2118 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2119 <convert type="ServiceName">Name</convert>
2121 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2122 <convert type="EventTime">Progress</convert>
2126 # for picon: (path="piconlcd" will use LCD picons)
2127 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2128 # <convert type="ServiceName">Reference</convert>
2131 class InfoBarSummarySupport:
2135 def createSummary(self):
2136 return InfoBarSummary
2138 class InfoBarMoviePlayerSummary(Screen):
2140 <screen position="0,0" size="132,64">
2141 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2142 <convert type="ClockToText">WithSeconds</convert>
2144 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2145 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2146 <convert type="ConditionalShowHide">Blink</convert>
2148 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2149 <convert type="ServiceName">Name</convert>
2151 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2152 <convert type="ServicePosition">Position</convert>
2156 class InfoBarMoviePlayerSummarySupport:
2160 def createSummary(self):
2161 return InfoBarMoviePlayerSummary
2163 class InfoBarTeletextPlugin:
2165 self.teletext_plugin = None
2167 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2168 self.teletext_plugin = p
2170 if self.teletext_plugin is not None:
2171 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2173 "startTeletext": (self.startTeletext, _("View teletext..."))
2176 print "no teletext plugin found!"
2178 def startTeletext(self):
2179 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2181 class InfoBarSubtitleSupport(object):
2183 object.__init__(self)
2184 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2185 self.__subtitles_enabled = False
2187 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2189 iPlayableService.evEnd: self.__serviceStopped,
2190 iPlayableService.evUpdatedInfo: self.__updatedInfo
2192 self.cached_subtitle_checked = False
2193 self.__selected_subtitle = None
2195 def __serviceStopped(self):
2196 self.subtitle_window.hide()
2197 self.__subtitles_enabled = False
2198 self.cached_subtitle_checked = False
2200 def __updatedInfo(self):
2201 if not self.cached_subtitle_checked:
2202 subtitle = self.getCurrentServiceSubtitle()
2203 self.cached_subtitle_checked = True
2204 self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()
2205 if self.__selected_subtitle:
2206 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2207 self.subtitle_window.show()
2208 self.__subtitles_enabled = True
2210 def getCurrentServiceSubtitle(self):
2211 service = self.session.nav.getCurrentService()
2212 return service and service.subtitle()
2214 def setSubtitlesEnable(self, enable=True):
2215 subtitle = self.getCurrentServiceSubtitle()
2216 if enable and self.__selected_subtitle is not None:
2217 if subtitle and not self.__subtitles_enabled:
2218 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2219 self.subtitle_window.show()
2220 self.__subtitles_enabled = True
2223 subtitle.disableSubtitles(self.subtitle_window.instance)
2224 self.__subtitles_enabled = False
2225 self.subtitle_window.hide()
2227 def setSelectedSubtitle(self, subtitle):
2228 self.__selected_subtitle = subtitle
2230 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2231 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2233 class InfoBarServiceErrorPopupSupport:
2235 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2237 iPlayableService.evTuneFailed: self.__tuneFailed,
2238 iPlayableService.evStart: self.__serviceStarted
2240 self.__serviceStarted()
2242 def __serviceStarted(self):
2243 self.last_error = None
2244 Notifications.RemovePopup(id = "ZapError")
2246 def __tuneFailed(self):
2247 service = self.session.nav.getCurrentService()
2248 info = service and service.info()
2249 error = info and info.getInfo(iServiceInformation.sDVBState)
2251 if error == self.last_error:
2254 self.last_error = error
2257 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2258 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2259 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2260 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2261 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2262 eDVBServicePMTHandler.eventNewProgramInfo: None,
2263 eDVBServicePMTHandler.eventTuned: None,
2264 eDVBServicePMTHandler.eventSOF: None,
2265 eDVBServicePMTHandler.eventEOF: None,
2266 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2267 }.get(error) #this returns None when the key not exist in the dict
2269 if error is not None:
2270 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2272 Notifications.RemovePopup(id = "ZapError")