1 from ChannelSelection import ChannelSelection, BouquetSelector
3 from Components.ActionMap import ActionMap, HelpableActionMap
4 from Components.ActionMap import NumberActionMap
5 from Components.BlinkingPixmap import BlinkingPixmapConditional
6 from Components.Harddisk import harddiskmanager
7 from Components.Input import Input
8 from Components.Label import Label
9 from Components.Pixmap import Pixmap
10 from Components.PluginComponent import plugins
11 from Components.ServiceEventTracker import ServiceEventTracker
12 from Components.Sources.Boolean import Boolean
13 from Components.config import config, ConfigBoolean, ConfigClock
14 from Components.SystemInfo import SystemInfo
15 from EpgSelection import EPGSelection
16 from Plugins.Plugin import PluginDescriptor
18 from Screen import Screen
19 from Screens.ChoiceBox import ChoiceBox
20 from Screens.Dish import Dish
21 from Screens.EventView import EventViewEPGSelect, EventViewSimple
22 from Screens.InputBox import InputBox
23 from Screens.MessageBox import MessageBox
24 from Screens.MinuteInput import MinuteInput
25 from Screens.TimerSelection import TimerSelection
26 from Screens.PictureInPicture import PictureInPicture
27 from Screens.SubtitleDisplay import SubtitleDisplay
28 from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
29 from Screens.SleepTimerEdit import SleepTimerEdit
30 from Screens.TimeDateInput import TimeDateInput
31 from ServiceReference import ServiceReference
33 from Tools import Notifications
34 from Tools.Directories import SCOPE_HDD, resolveFilename, pathExists
36 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
37 iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
39 from time import time, localtime, strftime
40 from os import stat as os_stat
41 from bisect import insort
44 from Menu import MainMenu, mdom
48 self.dishDialog = self.session.instantiateDialog(Dish)
50 class InfoBarShowHide:
51 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
59 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
61 "toggleShow": self.toggleShow,
63 }, 1) # lower prio to make it possible to override ok and cancel..
65 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
67 iPlayableService.evStart: self.serviceStarted,
70 self.__state = self.STATE_SHOWN
73 self.hideTimer = eTimer()
74 self.hideTimer.callback.append(self.doTimerHide)
75 self.hideTimer.start(5000, True)
77 self.onShow.append(self.__onShow)
78 self.onHide.append(self.__onHide)
80 def serviceStarted(self):
82 if config.usage.show_infobar_on_zap.value:
86 self.__state = self.STATE_SHOWN
89 def startHideTimer(self):
90 if self.__state == self.STATE_SHOWN and not self.__locked:
91 idx = config.usage.infobar_timeout.index
93 self.hideTimer.start(idx*1000, True)
96 self.__state = self.STATE_HIDDEN
100 self.startHideTimer()
102 def doTimerHide(self):
103 self.hideTimer.stop()
104 if self.__state == self.STATE_SHOWN:
107 def toggleShow(self):
108 if self.__state == self.STATE_SHOWN:
110 self.hideTimer.stop()
111 elif self.__state == self.STATE_HIDDEN:
115 self.__locked = self.__locked + 1
118 self.hideTimer.stop()
120 def unlockShow(self):
121 self.__locked = self.__locked - 1
123 self.startHideTimer()
125 # def startShow(self):
126 # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
127 # self.__state = self.STATE_SHOWN
129 # def startHide(self):
130 # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
131 # self.__state = self.STATE_HIDDEN
133 class NumberZap(Screen):
140 self.close(int(self["number"].getText()))
142 def keyNumberGlobal(self, number):
143 self.Timer.start(3000, True) #reset timer
144 self.field = self.field + str(number)
145 self["number"].setText(self.field)
146 if len(self.field) >= 4:
149 def __init__(self, session, number):
150 Screen.__init__(self, session)
151 self.field = str(number)
153 self["channel"] = Label(_("Channel:"))
155 self["number"] = Label(self.field)
157 self["actions"] = NumberActionMap( [ "SetupActions" ],
161 "1": self.keyNumberGlobal,
162 "2": self.keyNumberGlobal,
163 "3": self.keyNumberGlobal,
164 "4": self.keyNumberGlobal,
165 "5": self.keyNumberGlobal,
166 "6": self.keyNumberGlobal,
167 "7": self.keyNumberGlobal,
168 "8": self.keyNumberGlobal,
169 "9": self.keyNumberGlobal,
170 "0": self.keyNumberGlobal
173 self.Timer = eTimer()
174 self.Timer.callback.append(self.keyOK)
175 self.Timer.start(3000, True)
177 class InfoBarNumberZap:
178 """ Handles an initial number for NumberZapping """
180 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
182 "1": self.keyNumberGlobal,
183 "2": self.keyNumberGlobal,
184 "3": self.keyNumberGlobal,
185 "4": self.keyNumberGlobal,
186 "5": self.keyNumberGlobal,
187 "6": self.keyNumberGlobal,
188 "7": self.keyNumberGlobal,
189 "8": self.keyNumberGlobal,
190 "9": self.keyNumberGlobal,
191 "0": self.keyNumberGlobal,
194 def keyNumberGlobal(self, number):
195 # print "You pressed number " + str(number)
197 if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
198 self.pipDoHandle0Action()
200 self.servicelist.recallPrevService()
202 if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
203 self.session.openWithCallback(self.numberEntered, NumberZap, number)
205 def numberEntered(self, retval):
206 # print self.servicelist
208 self.zapToNumber(retval)
210 def searchNumberHelper(self, serviceHandler, num, bouquet):
211 servicelist = serviceHandler.list(bouquet)
212 if not servicelist is None:
214 serviceIterator = servicelist.getNext()
215 if not serviceIterator.valid(): #check end of list
217 playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
220 if not num: #found service with searched number ?
221 return serviceIterator, 0
224 def zapToNumber(self, number):
225 bouquet = self.servicelist.bouquet_root
227 serviceHandler = eServiceCenter.getInstance()
228 if not config.usage.multibouquet.value:
229 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
231 bouquetlist = serviceHandler.list(bouquet)
232 if not bouquetlist is None:
234 bouquet = bouquetlist.getNext()
235 if not bouquet.valid(): #check end of list
237 if bouquet.flags & eServiceReference.isDirectory:
238 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
239 if not service is None:
240 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
241 self.servicelist.clearPath()
242 if self.servicelist.bouquet_root != bouquet:
243 self.servicelist.enterPath(self.servicelist.bouquet_root)
244 self.servicelist.enterPath(bouquet)
245 self.servicelist.setCurrentSelection(service) #select the service in servicelist
246 self.servicelist.zap()
248 config.misc.initialchannelselection = ConfigBoolean(default = True)
250 class InfoBarChannelSelection:
251 """ ChannelSelection - handles the channelSelection dialog and the initial
252 channelChange actions which open the channelSelection dialog """
255 self.servicelist = self.session.instantiateDialog(ChannelSelection)
257 if config.misc.initialchannelselection.value:
258 self.onShown.append(self.firstRun)
260 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
262 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
263 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
264 "zapUp": (self.zapUp, _("previous channel")),
265 "zapDown": (self.zapDown, _("next channel")),
266 "historyBack": (self.historyBack, _("previous channel in history")),
267 "historyNext": (self.historyNext, _("next channel in history")),
268 "openServiceList": (self.openServiceList, _("open servicelist")),
271 def showTvChannelList(self, zap=False):
272 self.servicelist.setModeTv()
274 self.servicelist.zap()
275 self.session.execDialog(self.servicelist)
277 def showRadioChannelList(self, zap=False):
278 self.servicelist.setModeRadio()
280 self.servicelist.zap()
281 self.session.execDialog(self.servicelist)
284 self.onShown.remove(self.firstRun)
285 config.misc.initialchannelselection.value = False
286 config.misc.initialchannelselection.save()
287 self.switchChannelDown()
289 def historyBack(self):
290 self.servicelist.historyBack()
292 def historyNext(self):
293 self.servicelist.historyNext()
295 def switchChannelUp(self):
296 self.servicelist.moveUp()
297 self.session.execDialog(self.servicelist)
299 def switchChannelDown(self):
300 self.servicelist.moveDown()
301 self.session.execDialog(self.servicelist)
303 def openServiceList(self):
304 self.session.execDialog(self.servicelist)
307 if self.servicelist.inBouquet():
308 prev = self.servicelist.getCurrentSelection()
310 prev = prev.toString()
312 if config.usage.quickzap_bouquet_change.value:
313 if self.servicelist.atBegin():
314 self.servicelist.prevBouquet()
315 self.servicelist.moveUp()
316 cur = self.servicelist.getCurrentSelection()
317 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
320 self.servicelist.moveUp()
321 self.servicelist.zap()
324 if self.servicelist.inBouquet():
325 prev = self.servicelist.getCurrentSelection()
327 prev = prev.toString()
329 if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
330 self.servicelist.nextBouquet()
332 self.servicelist.moveDown()
333 cur = self.servicelist.getCurrentSelection()
334 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
337 self.servicelist.moveDown()
338 self.servicelist.zap()
341 """ Handles a menu action, to open the (main) menu """
343 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
345 "mainMenu": (self.mainMenu, _("Enter main menu...")),
347 self.session.infobar = None
350 print "loading mainmenu XML..."
351 menu = mdom.childNodes[0]
352 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
354 self.session.infobar = self
355 # so we can access the currently active infobar from screens opened from within the mainmenu
356 # at the moment used from the SubserviceSelection
358 self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu, menu.childNodes)
360 def mainMenuClosed(self, *val):
361 self.session.infobar = None
363 class InfoBarSimpleEventView:
364 """ Opens the Eventview for now/next """
366 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
368 "showEventInfo": (self.openEventView, _("show event details")),
371 def openEventView(self):
373 service = self.session.nav.getCurrentService()
374 ref = self.session.nav.getCurrentlyPlayingServiceReference()
375 info = service.info()
378 self.epglist.append(ptr)
381 self.epglist.append(ptr)
382 if len(self.epglist) > 0:
383 self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
385 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
386 if len(self.epglist) > 1:
387 tmp = self.epglist[0]
388 self.epglist[0]=self.epglist[1]
390 setEvent(self.epglist[0])
393 """ EPG - Opens an EPG list when the showEPGList action fires """
395 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
397 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
400 self.is_now_next = False
402 self.bouquetSel = None
403 self.eventView = None
404 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
406 "showEventInfo": (self.openEventView, _("show EPG...")),
407 "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
408 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
411 def showEventInfoWhenNotVisible(self):
418 def zapToService(self, service):
419 if not service is None:
420 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
421 self.servicelist.clearPath()
422 if self.servicelist.bouquet_root != self.epg_bouquet:
423 self.servicelist.enterPath(self.servicelist.bouquet_root)
424 self.servicelist.enterPath(self.epg_bouquet)
425 self.servicelist.setCurrentSelection(service) #select the service in servicelist
426 self.servicelist.zap()
428 def getBouquetServices(self, bouquet):
430 servicelist = eServiceCenter.getInstance().list(bouquet)
431 if not servicelist is None:
433 service = servicelist.getNext()
434 if not service.valid(): #check if end of list
436 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
438 services.append(ServiceReference(service))
441 def openBouquetEPG(self, bouquet, withCallback=True):
442 services = self.getBouquetServices(bouquet)
444 self.epg_bouquet = bouquet
446 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
448 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
450 def changeBouquetCB(self, direction, epg):
453 self.bouquetSel.down()
456 bouquet = self.bouquetSel.getCurrent()
457 services = self.getBouquetServices(bouquet)
459 self.epg_bouquet = bouquet
460 epg.setServices(services)
462 def closed(self, ret=False):
463 closedScreen = self.dlg_stack.pop()
464 if self.bouquetSel and closedScreen == self.bouquetSel:
465 self.bouquetSel = None
466 elif self.eventView and closedScreen == self.eventView:
467 self.eventView = None
469 dlgs=len(self.dlg_stack)
471 self.dlg_stack[dlgs-1].close(dlgs > 1)
473 def openMultiServiceEPG(self, withCallback=True):
474 bouquets = self.servicelist.getBouquetList()
479 if cnt > 1: # show bouquet list
481 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
482 self.dlg_stack.append(self.bouquetSel)
484 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
486 self.openBouquetEPG(bouquets[0][1], withCallback)
488 def openSingleServiceEPG(self):
489 ref=self.session.nav.getCurrentlyPlayingServiceReference()
490 self.session.open(EPGSelection, ref)
492 def openSimilarList(self, eventid, refstr):
493 self.session.open(EPGSelection, refstr, None, eventid)
495 def getNowNext(self):
497 service = self.session.nav.getCurrentService()
498 info = service and service.info()
499 ptr = info and info.getEvent(0)
501 self.epglist.append(ptr)
502 ptr = info and info.getEvent(1)
504 self.epglist.append(ptr)
506 def __evEventInfoChanged(self):
507 if self.is_now_next and len(self.dlg_stack) == 1:
509 assert self.eventView
510 if len(self.epglist):
511 self.eventView.setEvent(self.epglist[0])
513 def openEventView(self):
514 ref = self.session.nav.getCurrentlyPlayingServiceReference()
516 if len(self.epglist) == 0:
517 self.is_now_next = False
518 epg = eEPGCache.getInstance()
519 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
521 self.epglist.append(ptr)
522 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
524 self.epglist.append(ptr)
526 self.is_now_next = True
527 if len(self.epglist) > 0:
528 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
529 self.dlg_stack.append(self.eventView)
531 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
532 self.openMultiServiceEPG(False)
534 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
535 if len(self.epglist) > 1:
536 tmp = self.epglist[0]
537 self.epglist[0]=self.epglist[1]
539 setEvent(self.epglist[0])
541 class InfoBarRdsDecoder:
542 """provides RDS and Rass support/display"""
544 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
545 self.rass_interactive = None
547 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
549 iPlayableService.evEnd: self.__serviceStopped,
550 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
553 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
555 "startRassInteractive": self.startRassInteractive
558 self["RdsActions"].setEnabled(False)
560 self.onLayoutFinish.append(self.rds_display.show)
561 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
563 def RassInteractivePossibilityChanged(self, state):
564 self["RdsActions"].setEnabled(state)
566 def RassSlidePicChanged(self):
567 if not self.rass_interactive:
568 service = self.session.nav.getCurrentService()
569 decoder = service and service.rdsDecoder()
571 decoder.showRassSlidePicture()
573 def __serviceStopped(self):
574 if self.rass_interactive is not None:
575 rass_interactive = self.rass_interactive
576 self.rass_interactive = None
577 rass_interactive.close()
579 def startRassInteractive(self):
580 self.rds_display.hide()
581 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
583 def RassInteractiveClosed(self, *val):
584 if self.rass_interactive is not None:
585 self.rass_interactive = None
586 self.RassSlidePicChanged()
587 self.rds_display.show()
590 """handles actions like seeking, pause"""
592 SEEK_STATE_PLAY = (0, 0, 0, ">")
593 SEEK_STATE_PAUSE = (1, 0, 0, "||")
594 SEEK_STATE_EOF = (1, 0, 0, "END")
596 def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
597 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
599 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
600 iPlayableService.evStart: self.__serviceStarted,
602 iPlayableService.evEOF: self.__evEOF,
603 iPlayableService.evSOF: self.__evSOF,
606 self.eofTimer = eTimer()
607 self.eofTimer.timeout.get().append(self.doEof)
608 self.eofInhibitTimer = eTimer()
609 self.eofInhibitTimer.timeout.get().append(self.inhibitEof)
611 self.minSpeedBackward = useSeekBackHack and 16 or 0
613 class InfoBarSeekActionMap(HelpableActionMap):
614 def __init__(self, screen, *args, **kwargs):
615 HelpableActionMap.__init__(self, screen, *args, **kwargs)
618 def action(self, contexts, action):
619 print "action:", action
620 if action[:5] == "seek:":
621 time = int(action[5:])
622 self.screen.doSeekRelative(time * 90000)
624 elif action[:8] == "seekdef:":
625 key = int(action[8:])
626 time = [-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
627 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
628 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value][key-1]
629 self.screen.doSeekRelative(time * 90000)
632 return HelpableActionMap.action(self, contexts, action)
634 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
636 "playpauseService": self.playpauseService,
637 "pauseService": (self.pauseService, _("pause")),
638 "unPauseService": (self.unPauseService, _("continue")),
640 "seekFwd": (self.seekFwd, _("skip forward")),
641 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
642 "seekBack": (self.seekBack, _("skip backward")),
643 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
645 # give them a little more priority to win over color buttons
647 self["SeekActions"].setEnabled(False)
649 self.seekstate = self.SEEK_STATE_PLAY
650 self.lastseekstate = self.SEEK_STATE_PLAY
652 self.onPlayStateChanged = [ ]
654 self.lockedBecauseOfSkipping = False
656 self.__seekableStatusChanged()
658 def makeStateForward(self, n):
659 minspeed = config.seek.stepwise_minspeed.value
660 repeat = int(config.seek.stepwise_repeat.value)
661 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
662 return (0, n * repeat, repeat, ">> %dx" % n)
664 return (0, n, 0, ">> %dx" % n)
666 def makeStateBackward(self, n):
667 minspeed = config.seek.stepwise_minspeed.value
668 repeat = int(config.seek.stepwise_repeat.value)
669 if self.minSpeedBackward and n < self.minSpeedBackward:
670 r = (self.minSpeedBackward - 1)/ n + 1
671 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
673 return (0, -n * r, r, "<< %dx" % n)
674 elif minspeed != "Never" and n >= int(minspeed) and repeat > 1:
675 return (0, -n * repeat, repeat, "<< %dx" % n)
677 return (0, -n, 0, "<< %dx" % n)
679 def makeStateSlowMotion(self, n):
680 return (0, 0, n, "/%d" % n)
682 def isStateForward(self, state):
685 def isStateBackward(self, state):
688 def isStateSlowMotion(self, state):
689 return state[1] == 0 and state[2] > 1
691 def getHigher(self, n, lst):
697 def getLower(self, n, lst):
705 def showAfterSeek(self):
706 if isinstance(self, InfoBarShowHide):
716 service = self.session.nav.getCurrentService()
720 seek = service.seek()
722 if seek is None or not seek.isCurrentlySeekable():
727 def isSeekable(self):
728 if self.getSeek() is None:
732 def __seekableStatusChanged(self):
733 # print "seekable status changed!"
734 if not self.isSeekable():
735 self["SeekActions"].setEnabled(False)
736 # print "not seekable, return to play"
737 self.setSeekState(self.SEEK_STATE_PLAY)
739 self["SeekActions"].setEnabled(True)
742 def __serviceStarted(self):
743 self.seekstate = self.SEEK_STATE_PLAY
744 self.__seekableStatusChanged()
745 if self.eofState != 0:
749 def setSeekState(self, state):
750 service = self.session.nav.getCurrentService()
755 if not self.isSeekable():
756 if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
757 state = self.SEEK_STATE_PLAY
759 pauseable = service.pause()
761 if pauseable is None:
762 print "not pauseable."
763 state = self.SEEK_STATE_PLAY
765 oldstate = self.seekstate
766 self.seekstate = state
769 if oldstate[i] != self.seekstate[i]:
770 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
772 for c in self.onPlayStateChanged:
775 self.checkSkipShowHideLock()
779 def playpauseService(self):
780 if self.seekstate != self.SEEK_STATE_PLAY:
781 self.unPauseService()
785 def pauseService(self):
786 if self.seekstate == self.SEEK_STATE_PAUSE:
787 if config.seek.on_pause.value == "play":
788 self.unPauseService()
789 elif config.seek.on_pause.value == "step":
790 self.doSeekRelative(0)
791 elif config.seek.on_pause.value == "last":
792 self.setSeekState(self.lastseekstate)
793 self.lastseekstate = self.SEEK_STATE_PLAY
795 if self.seekstate != self.SEEK_STATE_EOF:
796 self.lastseekstate = self.seekstate
797 self.setSeekState(self.SEEK_STATE_PAUSE);
799 def unPauseService(self):
801 if self.seekstate == self.SEEK_STATE_PLAY:
803 self.setSeekState(self.SEEK_STATE_PLAY)
805 def doSeek(self, pts):
806 seekable = self.getSeek()
809 prevstate = self.seekstate
810 if self.eofState == 1:
813 if self.seekstate == self.SEEK_STATE_EOF:
814 if prevstate == self.SEEK_STATE_PAUSE:
815 self.setSeekState(self.SEEK_STATE_PAUSE)
817 self.setSeekState(self.SEEK_STATE_PLAY)
818 self.eofInhibitTimer.start(200, True)
821 def doSeekRelative(self, pts):
822 seekable = self.getSeek()
825 prevstate = self.seekstate
826 if self.eofState == 1:
829 if self.seekstate == self.SEEK_STATE_EOF:
830 if prevstate == self.SEEK_STATE_PAUSE:
831 self.setSeekState(self.SEEK_STATE_PAUSE)
833 self.setSeekState(self.SEEK_STATE_PLAY)
834 self.eofInhibitTimer.start(200, True)
835 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
836 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
840 if self.seekstate == self.SEEK_STATE_PLAY:
841 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
842 elif self.seekstate == self.SEEK_STATE_PAUSE:
843 if len(config.seek.speeds_slowmotion.value):
844 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
846 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
847 elif self.seekstate == self.SEEK_STATE_EOF:
849 elif self.isStateForward(self.seekstate):
850 speed = self.seekstate[1]
851 if self.seekstate[2]:
852 speed /= self.seekstate[2]
853 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
854 self.setSeekState(self.makeStateForward(speed))
855 elif self.isStateBackward(self.seekstate):
856 speed = -self.seekstate[1]
857 if self.seekstate[2]:
858 speed /= self.seekstate[2]
859 speed = self.getLower(speed, config.seek.speeds_backward.value)
861 self.setSeekState(self.makeStateBackward(speed))
863 self.setSeekState(self.SEEK_STATE_PLAY)
864 elif self.isStateSlowMotion(self.seekstate):
865 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
866 self.setSeekState(self.makeStateSlowMotion(speed))
869 if self.seekstate == self.SEEK_STATE_PLAY:
870 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
871 elif self.seekstate == self.SEEK_STATE_EOF:
872 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
873 self.doSeekRelative(-6)
874 elif self.seekstate == self.SEEK_STATE_PAUSE:
875 self.doSeekRelative(-3)
876 elif self.isStateForward(self.seekstate):
877 speed = self.seekstate[1]
878 if self.seekstate[2]:
879 speed /= self.seekstate[2]
880 speed = self.getLower(speed, config.seek.speeds_forward.value)
882 self.setSeekState(self.makeStateForward(speed))
884 self.setSeekState(self.SEEK_STATE_PLAY)
885 elif self.isStateBackward(self.seekstate):
886 speed = -self.seekstate[1]
887 if self.seekstate[2]:
888 speed /= self.seekstate[2]
889 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
890 self.setSeekState(self.makeStateBackward(speed))
891 elif self.isStateSlowMotion(self.seekstate):
892 speed = self.getHigher(self.seekstate[2], config.seek.speeds_slowmotion.value)
894 self.setSeekState(self.makeStateSlowMotion(speed))
896 self.setSeekState(self.SEEK_STATE_PAUSE)
898 def seekFwdManual(self):
899 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
901 def fwdSeekTo(self, minutes):
902 print "Seek", minutes, "minutes forward"
903 self.doSeekRelative(minutes * 60 * 90000)
905 def seekBackManual(self):
906 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
908 def rwdSeekTo(self, minutes):
910 self.doSeekRelative(-minutes * 60 * 90000)
912 def checkSkipShowHideLock(self):
913 wantlock = self.seekstate != self.SEEK_STATE_PLAY
915 if config.usage.show_infobar_on_skip.value:
916 if self.lockedBecauseOfSkipping and not wantlock:
918 self.lockedBecauseOfSkipping = False
920 if wantlock and not self.lockedBecauseOfSkipping:
922 self.lockedBecauseOfSkipping = True
924 def calcRemainingTime(self):
925 seekable = self.getSeek()
926 if seekable is not None:
927 len = seekable.getLength()
929 tmp = self.cueGetEndCutPosition()
934 pos = seekable.getPlayPosition()
935 speednom = self.seekstate[1] or 1
936 speedden = self.seekstate[2] or 1
937 if not len[0] and not pos[0]:
940 time = (len[1] - pos[1])*speedden/(90*speednom)
945 if self.eofState == 0 and self.seekstate != self.SEEK_STATE_EOF:
947 time = self.calcRemainingTime()
949 time = 3000 # Failed to calc, use default
951 time = 300 # Passed end, shortest wait
953 self.eofState = -2 # Too long, block eof
956 time += 1000 # Add margin
957 self.eofTimer.start(time, True)
959 def inhibitEof(self):
960 if self.eofState >= 1:
961 self.eofState = -self.eofState
966 if self.seekstate == self.SEEK_STATE_EOF:
968 if self.eofState == -2 or self.isStateBackward(self.seekstate):
972 # if we are seeking, we try to end up ~1s before the end, and pause there.
973 eofstate = self.eofState
974 seekstate = self.seekstate
976 if not self.seekstate == self.SEEK_STATE_PAUSE:
977 self.setSeekState(self.SEEK_STATE_EOF)
978 if eofstate == -1 or not seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
979 seekable = self.getSeek()
980 if seekable is not None:
982 if eofstate == 1 and seekstate == self.SEEK_STATE_PLAY:
983 self.doEofInternal(True)
985 self.doEofInternal(False)
987 def doEofInternal(self, playing):
988 pass # Defined in subclasses
991 self.setSeekState(self.SEEK_STATE_PLAY)
994 from Screens.PVRState import PVRState, TimeshiftState
996 class InfoBarPVRState:
997 def __init__(self, screen=PVRState):
998 self.onPlayStateChanged.append(self.__playStateChanged)
999 self.pvrStateDialog = self.session.instantiateDialog(screen)
1000 self.onShow.append(self._mayShow)
1001 self.onHide.append(self.pvrStateDialog.hide)
1004 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1005 self.pvrStateDialog.show()
1007 def __playStateChanged(self, state):
1008 playstateString = state[3]
1009 self.pvrStateDialog["state"].setText(playstateString)
1012 class InfoBarTimeshiftState(InfoBarPVRState):
1014 InfoBarPVRState.__init__(self, screen=TimeshiftState)
1017 if self.execing and self.timeshift_enabled:
1018 self.pvrStateDialog.show()
1020 class InfoBarShowMovies:
1022 # i don't really like this class.
1023 # it calls a not further specified "movie list" on up/down/movieList,
1024 # so this is not more than an action map
1026 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1028 "movieList": (self.showMovies, _("movie list")),
1029 "up": (self.showMovies, _("movie list")),
1030 "down": (self.showMovies, _("movie list"))
1033 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1037 # Timeshift works the following way:
1038 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1039 # - normal playback TUNER unused PLAY enable disable disable
1040 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1041 # - user presess pause again FILE record PLAY enable disable enable
1042 # - user fast forwards FILE record FF enable disable enable
1043 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1044 # - user backwards FILE record BACK # !! enable disable enable
1048 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1049 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1050 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1051 # - the user can now PVR around
1052 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1053 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1055 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1056 # - if the user rewinds, or press pause, timeshift will be activated again
1058 # note that a timeshift can be enabled ("recording") and
1059 # activated (currently time-shifting).
1061 class InfoBarTimeshift:
1063 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1065 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1066 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1068 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1070 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1071 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1072 }, prio=-1) # priority over record
1074 self.timeshift_enabled = 0
1075 self.timeshift_state = 0
1076 self.ts_rewind_timer = eTimer()
1077 self.ts_rewind_timer.callback.append(self.rewindService)
1079 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1081 iPlayableService.evStart: self.__serviceStarted,
1082 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1085 def getTimeshift(self):
1086 service = self.session.nav.getCurrentService()
1087 return service and service.timeshift()
1089 def startTimeshift(self):
1090 print "enable timeshift"
1091 ts = self.getTimeshift()
1093 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1094 print "no ts interface"
1097 if self.timeshift_enabled:
1098 print "hu, timeshift already enabled?"
1100 if not ts.startTimeshift():
1101 self.timeshift_enabled = 1
1103 # we remove the "relative time" for now.
1104 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1107 #self.setSeekState(self.SEEK_STATE_PAUSE)
1108 self.activateTimeshiftEnd(False)
1110 # enable the "TimeshiftEnableActions", which will override
1111 # the startTimeshift actions
1112 self.__seekableStatusChanged()
1114 print "timeshift failed"
1116 def stopTimeshift(self):
1117 if not self.timeshift_enabled:
1119 print "disable timeshift"
1120 ts = self.getTimeshift()
1123 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1125 def stopTimeshiftConfirmed(self, confirmed):
1129 ts = self.getTimeshift()
1134 self.timeshift_enabled = 0
1137 self.__seekableStatusChanged()
1139 # activates timeshift, and seeks to (almost) the end
1140 def activateTimeshiftEnd(self, back = True):
1141 ts = self.getTimeshift()
1142 print "activateTimeshiftEnd"
1147 if ts.isTimeshiftActive():
1148 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1152 ts.activateTimeshift() # activate timeshift will automatically pause
1153 self.setSeekState(self.SEEK_STATE_PAUSE)
1156 self.doSeek(-5) # seek some gops before end
1157 self.ts_rewind_timer.start(200, 1)
1159 self.doSeek(-1) # seek 1 gop before end
1161 def rewindService(self):
1162 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1164 # same as activateTimeshiftEnd, but pauses afterwards.
1165 def activateTimeshiftEndAndPause(self):
1166 print "activateTimeshiftEndAndPause"
1167 #state = self.seekstate
1168 self.activateTimeshiftEnd(False)
1170 def __seekableStatusChanged(self):
1173 # print "self.isSeekable", self.isSeekable()
1174 # print "self.timeshift_enabled", self.timeshift_enabled
1176 # when this service is not seekable, but timeshift
1177 # is enabled, this means we can activate
1179 if not self.isSeekable() and self.timeshift_enabled:
1182 # print "timeshift activate:", enabled
1183 self["TimeshiftActivateActions"].setEnabled(enabled)
1185 def __serviceStarted(self):
1186 self.timeshift_enabled = False
1187 self.__seekableStatusChanged()
1189 from Screens.PiPSetup import PiPSetup
1191 class InfoBarExtensions:
1192 EXTENSION_SINGLE = 0
1198 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1200 "extensions": (self.showExtensionSelection, _("view extensions...")),
1203 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1204 self.list.append((type, extension, key))
1206 def updateExtension(self, extension, key = None):
1207 self.extensionsList.append(extension)
1209 if self.extensionKeys.has_key(key):
1213 for x in self.availableKeys:
1214 if not self.extensionKeys.has_key(x):
1219 self.extensionKeys[key] = len(self.extensionsList) - 1
1221 def updateExtensions(self):
1222 self.extensionsList = []
1223 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1224 self.extensionKeys = {}
1226 if x[0] == self.EXTENSION_SINGLE:
1227 self.updateExtension(x[1], x[2])
1230 self.updateExtension(y[0], y[1])
1233 def showExtensionSelection(self):
1234 self.updateExtensions()
1235 extensionsList = self.extensionsList[:]
1238 for x in self.availableKeys:
1239 if self.extensionKeys.has_key(x):
1240 entry = self.extensionKeys[x]
1241 extension = self.extensionsList[entry]
1243 name = str(extension[0]())
1244 list.append((extension[0](), extension))
1246 extensionsList.remove(extension)
1248 extensionsList.remove(extension)
1249 for x in extensionsList:
1250 list.append((x[0](), x))
1251 keys += [""] * len(extensionsList)
1252 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
1254 def extensionCallback(self, answer):
1255 if answer is not None:
1258 from Tools.BoundFunction import boundFunction
1260 # depends on InfoBarExtensions
1261 from Components.PluginComponent import plugins
1263 class InfoBarPlugins:
1265 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1267 def getPluginName(self, name):
1270 def getPluginList(self):
1272 for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
1273 list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
1276 def runPlugin(self, plugin):
1277 plugin(session = self.session, servicelist = self.servicelist)
1279 # depends on InfoBarExtensions
1280 class InfoBarSleepTimer:
1282 self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, lambda: True), "1")
1284 def getSleepTimerName(self):
1285 return _("Sleep Timer")
1287 def showSleepTimerSetup(self):
1288 self.session.open(SleepTimerEdit)
1290 # depends on InfoBarExtensions
1293 self.session.pipshown = False
1294 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1295 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1296 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1297 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1300 return self.session.pipshown
1302 def pipHandles0Action(self):
1303 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1305 def getShowHideName(self):
1306 if self.session.pipshown:
1307 return _("Disable Picture in Picture")
1309 return _("Activate Picture in Picture")
1311 def getSwapName(self):
1312 return _("Swap Services")
1314 def getMoveName(self):
1315 return _("Move Picture in Picture")
1318 if self.session.pipshown:
1319 del self.session.pip
1320 self.session.pipshown = False
1322 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1323 self.session.pip.show()
1324 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1325 if self.session.pip.playService(newservice):
1326 self.session.pipshown = True
1327 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1329 self.session.pipshown = False
1330 del self.session.pip
1331 self.session.nav.playService(newservice)
1334 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1335 if self.session.pip.servicePath:
1336 servicepath = self.servicelist.getCurrentServicePath()
1337 ref=servicepath[len(servicepath)-1]
1338 pipref=self.session.pip.getCurrentService()
1339 self.session.pip.playService(swapservice)
1340 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1341 if pipref.toString() != ref.toString(): # is a subservice ?
1342 self.session.nav.stopService() # stop portal
1343 self.session.nav.playService(pipref) # start subservice
1344 self.session.pip.servicePath=servicepath
1347 self.session.open(PiPSetup, pip = self.session.pip)
1349 def pipDoHandle0Action(self):
1350 use = config.usage.pip_zero_button.value
1353 elif "swapstop" == use:
1359 from RecordTimer import parseEvent, RecordTimerEntry
1361 class InfoBarInstantRecord:
1362 """Instant Record - handles the instantRecord action in order to
1363 start/stop instant records"""
1365 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1367 "instantRecord": (self.instantRecord, _("Instant Record...")),
1371 def stopCurrentRecording(self, entry = -1):
1372 if entry is not None and entry != -1:
1373 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1374 self.recording.remove(self.recording[entry])
1376 def startInstantRecording(self, limitEvent = False):
1377 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1379 # try to get event info
1382 service = self.session.nav.getCurrentService()
1383 epg = eEPGCache.getInstance()
1384 event = epg.lookupEventTime(serviceref, -1, 0)
1386 info = service.info()
1387 ev = info.getEvent(0)
1393 end = time() + 3600 * 10
1394 name = "instant record"
1398 if event is not None:
1399 curEvent = parseEvent(event)
1401 description = curEvent[3]
1402 eventid = curEvent[4]
1407 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1410 if isinstance(serviceref, eServiceReference):
1411 serviceref = ServiceReference(serviceref)
1413 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
1414 recording.dontSave = True
1416 self.session.nav.RecordTimer.record(recording)
1417 self.recording.append(recording)
1419 def isInstantRecordRunning(self):
1420 print "self.recording:", self.recording
1421 if len(self.recording) > 0:
1422 for x in self.recording:
1427 def recordQuestionCallback(self, answer):
1428 print "pre:\n", self.recording
1430 if answer is None or answer[1] == "no":
1433 recording = self.recording[:]
1435 if not x in self.session.nav.RecordTimer.timer_list:
1436 self.recording.remove(x)
1437 elif x.dontSave and x.isRunning():
1438 list.append((x, False))
1440 if answer[1] == "changeduration":
1441 if len(self.recording) == 1:
1442 self.changeDuration(0)
1444 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1445 elif answer[1] == "changeendtime":
1446 if len(self.recording) == 1:
1449 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1450 elif answer[1] == "stop":
1451 if len(self.recording) == 1:
1452 self.stopCurrentRecording(0)
1454 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1455 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1456 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1457 if answer[1] == "manualduration":
1458 self.changeDuration(len(self.recording)-1)
1459 elif answer[1] == "manualendtime":
1460 self.setEndtime(len(self.recording)-1)
1461 print "after:\n", self.recording
1463 def setEndtime(self, entry):
1464 if entry is not None:
1465 self.selectedEntry = entry
1466 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1467 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1468 dlg.setTitle(_("Please change recording endtime"))
1470 def TimeDateInputClosed(self, ret):
1473 localendtime = localtime(ret[1])
1474 print "stopping recording at", strftime("%c", localendtime)
1475 self.recording[self.selectedEntry].end = ret[1]
1476 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1478 def changeDuration(self, entry):
1479 if entry is not None:
1480 self.selectedEntry = entry
1481 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1483 def inputCallback(self, value):
1484 if value is not None:
1485 print "stopping recording after", int(value), "minutes."
1486 self.recording[self.selectedEntry].end = time() + 60 * int(value)
1487 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1489 def instantRecord(self):
1490 dir = config.movielist.last_videodir.value
1491 if not pathExists(dir):
1492 dir = resolveFilename(SCOPE_HDD)
1496 # XXX: this message is a little odd as we might be recording to a remote device
1497 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1500 if self.isInstantRecordRunning():
1501 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1502 title=_("A recording is currently running.\nWhat do you want to do?"), \
1503 list=[(_("stop recording"), "stop"), \
1504 (_("change recording (duration)"), "changeduration"), \
1505 (_("change recording (endtime)"), "changeendtime"), \
1506 (_("add recording (indefinitely)"), "indefinitely"), \
1507 (_("add recording (stop after current event)"), "event"), \
1508 (_("add recording (enter recording duration)"), "manualduration"), \
1509 (_("add recording (enter recording endtime)"), "manualendtime"), \
1510 (_("do nothing"), "no")])
1512 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1513 title=_("Start recording?"), \
1514 list=[(_("add recording (indefinitely)"), "indefinitely"), \
1515 (_("add recording (stop after current event)"), "event"), \
1516 (_("add recording (enter recording duration)"), "manualduration"), \
1517 (_("add recording (enter recording endtime)"), "manualendtime"), \
1518 (_("don't record"), "no")])
1520 from Tools.ISO639 import LanguageCodes
1522 class InfoBarAudioSelection:
1524 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1526 "audioSelection": (self.audioSelection, _("Audio Options...")),
1529 def audioSelection(self):
1530 service = self.session.nav.getCurrentService()
1531 self.audioTracks = audio = service and service.audioTracks()
1532 n = audio and audio.getNumberOfTracks() or 0
1535 self.audioChannel = service.audioChannel()
1538 i = audio.getTrackInfo(x)
1539 language = i.getLanguage()
1540 description = i.getDescription()
1542 if LanguageCodes.has_key(language):
1543 language = LanguageCodes[language][0]
1545 if len(description):
1546 description += " (" + language + ")"
1548 description = language
1550 tlist.append((description, x))
1552 tlist.sort(key=lambda x: x[0])
1554 selectedAudio = self.audioTracks.getCurrentTrack()
1559 if x[1] != selectedAudio:
1564 if SystemInfo["CanDownmixAC3"]:
1565 tlist = [(_("AC3 downmix") + " - " +[_("Off"), _("On")][config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1566 ([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"),
1568 keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1571 tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
1572 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1574 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
1576 del self.audioTracks
1578 def changeAC3Downmix(self, arg):
1579 choicelist = self.session.current_dialog["list"]
1580 list = choicelist.list
1582 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1583 _("AC3 downmix") + " - " +[_("On"), _("Off")][config.av.downmix_ac3.value and 1 or 0])
1584 choicelist.setList(list)
1585 if config.av.downmix_ac3.value:
1586 config.av.downmix_ac3.value = False
1588 config.av.downmix_ac3.value = True
1589 config.av.downmix_ac3.save()
1591 def audioSelected(self, audio):
1592 if audio is not None:
1593 if isinstance(audio[1], str):
1594 if audio[1] == "mode":
1595 keys = ["red", "green", "yellow"]
1596 selection = self.audioChannel.getCurrentChannel()
1597 tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
1598 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
1600 del self.audioChannel
1601 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1602 self.audioTracks.selectTrack(audio[1])
1604 del self.audioChannel
1605 del self.audioTracks
1607 def modeSelected(self, mode):
1608 if mode is not None:
1609 self.audioChannel.selectChannel(mode[1])
1610 del self.audioChannel
1612 class InfoBarSubserviceSelection:
1614 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1616 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1619 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1621 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1622 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1624 self["SubserviceQuickzapAction"].setEnabled(False)
1626 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1628 iPlayableService.evUpdatedInfo: self.checkSubservicesAvail
1633 def checkSubservicesAvail(self):
1634 service = self.session.nav.getCurrentService()
1635 subservices = service and service.subServices()
1636 if not subservices or subservices.getNumberOfSubservices() == 0:
1637 self["SubserviceQuickzapAction"].setEnabled(False)
1639 def nextSubservice(self):
1640 self.changeSubservice(+1)
1642 def prevSubservice(self):
1643 self.changeSubservice(-1)
1645 def changeSubservice(self, direction):
1646 service = self.session.nav.getCurrentService()
1647 subservices = service and service.subServices()
1648 n = subservices and subservices.getNumberOfSubservices()
1651 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1653 if subservices.getSubservice(x).toString() == ref.toString():
1656 selection += direction
1661 newservice = subservices.getSubservice(selection)
1662 if newservice.valid():
1665 self.session.nav.playService(newservice, False)
1667 def subserviceSelection(self):
1668 service = self.session.nav.getCurrentService()
1669 subservices = service and service.subServices()
1670 self.bouquets = self.servicelist.getBouquetList()
1671 n = subservices and subservices.getNumberOfSubservices()
1674 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1677 i = subservices.getSubservice(x)
1678 if i.toString() == ref.toString():
1680 tlist.append((i.getName(), i))
1682 if self.bouquets and len(self.bouquets):
1683 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1684 if config.usage.multibouquet.value:
1685 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1687 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1690 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1691 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1694 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys)
1696 def subserviceSelected(self, service):
1698 if not service is None:
1699 if isinstance(service[1], str):
1700 if service[1] == "quickzap":
1701 from Screens.SubservicesQuickzap import SubservicesQuickzap
1702 self.session.open(SubservicesQuickzap, service[2])
1704 self["SubserviceQuickzapAction"].setEnabled(True)
1705 self.session.nav.playService(service[1], False)
1707 def addSubserviceToBouquetCallback(self, service):
1708 if len(service) > 1 and isinstance(service[1], eServiceReference):
1709 self.selectedSubservice = service
1710 if self.bouquets is None:
1713 cnt = len(self.bouquets)
1714 if cnt > 1: # show bouquet list
1715 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1716 elif cnt == 1: # add to only one existing bouquet
1717 self.addSubserviceToBouquet(self.bouquets[0][1])
1718 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1720 def bouquetSelClosed(self, confirmed):
1722 del self.selectedSubservice
1724 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1726 def addSubserviceToBouquet(self, dest):
1727 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1729 self.bsel.close(True)
1731 del self.selectedSubservice
1733 class InfoBarAdditionalInfo:
1736 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
1737 self["TimeshiftPossible"] = self["RecordingPossible"]
1738 self["ExtensionsAvailable"] = Boolean(fixed=1)
1740 class InfoBarNotifications:
1742 self.onExecBegin.append(self.checkNotifications)
1743 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1744 self.onClose.append(self.__removeNotification)
1746 def __removeNotification(self):
1747 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1749 def checkNotificationsIfExecing(self):
1751 self.checkNotifications()
1753 def checkNotifications(self):
1754 if len(Notifications.notifications):
1755 n = Notifications.notifications[0]
1757 Notifications.notifications = Notifications.notifications[1:]
1760 if n[3].has_key("onSessionOpenCallback"):
1761 n[3]["onSessionOpenCallback"]()
1762 del n[3]["onSessionOpenCallback"]
1765 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1767 dlg = self.session.open(n[1], *n[2], **n[3])
1769 # remember that this notification is currently active
1771 Notifications.current_notifications.append(d)
1772 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1774 def __notificationClosed(self, d):
1775 Notifications.current_notifications.remove(d)
1777 class InfoBarServiceNotifications:
1779 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1781 iPlayableService.evEnd: self.serviceHasEnded
1784 def serviceHasEnded(self):
1785 print "service end!"
1788 self.setSeekState(self.SEEK_STATE_PLAY)
1792 class InfoBarCueSheetSupport:
1798 ENABLE_RESUME_SUPPORT = False
1800 def __init__(self, actionmap = "InfobarCueSheetActions"):
1801 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1803 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1804 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1805 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1809 self.is_closing = False
1810 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1812 iPlayableService.evStart: self.__serviceStarted,
1815 def __serviceStarted(self):
1818 print "new service started! trying to download cuts!"
1819 self.downloadCuesheet()
1821 if self.ENABLE_RESUME_SUPPORT:
1824 for (pts, what) in self.cut_list:
1825 if what == self.CUT_TYPE_LAST:
1828 if last is not None:
1829 self.resume_point = last
1830 if config.usage.on_movie_start.value == "ask":
1831 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1832 elif config.usage.on_movie_start.value == "resume":
1833 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1834 # TRANSLATORS: at the start of a movie, when the user has selected
1835 # TRANSLATORS: "Resume from last position" as start behavior.
1836 # TRANSLATORS: The purpose is to notify the user that the movie starts
1837 # TRANSLATORS: in the middle somewhere and not from the beginning.
1838 # TRANSLATORS: (Some translators seem to have interpreted it as a
1839 # TRANSLATORS: question or a choice, but it is a statement.)
1840 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1842 def playLastCB(self, answer):
1844 self.doSeek(self.resume_point)
1845 self.hideAfterResume()
1847 def hideAfterResume(self):
1848 if isinstance(self, InfoBarShowHide):
1851 def __getSeekable(self):
1852 service = self.session.nav.getCurrentService()
1855 return service.seek()
1857 def cueGetCurrentPosition(self):
1858 seek = self.__getSeekable()
1861 r = seek.getPlayPosition()
1866 def cueGetEndCutPosition(self):
1869 for cp in self.cut_list:
1870 if cp[1] == self.CUT_TYPE_OUT:
1874 elif cp[1] == self.CUT_TYPE_IN:
1878 def jumpPreviousNextMark(self, cmp, start=False):
1879 current_pos = self.cueGetCurrentPosition()
1880 if current_pos is None:
1882 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
1883 if mark is not None:
1891 def jumpPreviousMark(self):
1892 # we add 2 seconds, so if the play position is <2s after
1893 # the mark, the mark before will be used
1894 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
1896 def jumpNextMark(self):
1897 if not self.jumpPreviousNextMark(lambda x: x):
1900 def getNearestCutPoint(self, pts, cmp=abs, start=False):
1906 bestdiff = cmp(0 - pts)
1908 nearest = [0, False]
1909 for cp in self.cut_list:
1910 if beforecut and cp[1] in [self.CUT_TYPE_IN, self.CUT_TYPE_OUT]:
1912 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
1913 diff = cmp(cp[0] - pts)
1919 if cp[1] in [self.CUT_TYPE_MARK, self.CUT_TYPE_LAST]:
1920 diff = cmp(cp[0] - pts)
1921 if diff >= 0 and (nearest is None or bestdiff > diff):
1926 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
1927 current_pos = self.cueGetCurrentPosition()
1928 if current_pos is None:
1929 print "not seekable"
1932 nearest_cutpoint = self.getNearestCutPoint(current_pos)
1934 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
1936 return nearest_cutpoint
1938 self.removeMark(nearest_cutpoint)
1939 elif not onlyremove and not onlyreturn:
1940 self.addMark((current_pos, self.CUT_TYPE_MARK))
1945 def addMark(self, point):
1946 insort(self.cut_list, point)
1947 self.uploadCuesheet()
1948 self.showAfterCuesheetOperation()
1950 def removeMark(self, point):
1951 self.cut_list.remove(point)
1952 self.uploadCuesheet()
1953 self.showAfterCuesheetOperation()
1955 def showAfterCuesheetOperation(self):
1956 if isinstance(self, InfoBarShowHide):
1959 def __getCuesheet(self):
1960 service = self.session.nav.getCurrentService()
1963 return service.cueSheet()
1965 def uploadCuesheet(self):
1966 cue = self.__getCuesheet()
1969 print "upload failed, no cuesheet interface"
1971 cue.setCutList(self.cut_list)
1973 def downloadCuesheet(self):
1974 cue = self.__getCuesheet()
1977 print "download failed, no cuesheet interface"
1980 self.cut_list = cue.getCutList()
1982 class InfoBarSummary(Screen):
1984 <screen position="0,0" size="132,64">
1985 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
1986 <convert type="ClockToText">WithSeconds</convert>
1988 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
1989 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
1990 <convert type="ConditionalShowHide">Blink</convert>
1992 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
1993 <convert type="ServiceName">Name</convert>
1995 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
1996 <convert type="EventTime">Progress</convert>
2000 # for picon: (path="piconlcd" will use LCD picons)
2001 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2002 # <convert type="ServiceName">Reference</convert>
2005 def __init__(self, session, parent):
2006 Screen.__init__(self, session, parent = parent)
2008 class InfoBarSummarySupport:
2012 def createSummary(self):
2013 return InfoBarSummary
2015 class InfoBarMoviePlayerSummary(Screen):
2017 <screen position="0,0" size="132,64">
2018 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2019 <convert type="ClockToText">WithSeconds</convert>
2021 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2022 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2023 <convert type="ConditionalShowHide">Blink</convert>
2025 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2026 <convert type="ServiceName">Name</convert>
2028 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2029 <convert type="ServicePosition">Position</convert>
2033 def __init__(self, session, parent):
2034 Screen.__init__(self, session)
2036 class InfoBarMoviePlayerSummarySupport:
2040 def createSummary(self):
2041 return InfoBarMoviePlayerSummary
2043 class InfoBarTeletextPlugin:
2045 self.teletext_plugin = None
2047 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2048 self.teletext_plugin = p
2050 if self.teletext_plugin is not None:
2051 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2053 "startTeletext": (self.startTeletext, _("View teletext..."))
2056 print "no teletext plugin found!"
2058 def startTeletext(self):
2059 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2061 class InfoBarSubtitleSupport(object):
2063 object.__init__(self)
2064 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2065 self.__subtitles_enabled = False
2067 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2069 iPlayableService.evEnd: self.__serviceStopped,
2070 iPlayableService.evUpdatedInfo: self.__updatedInfo
2072 self.cached_subtitle_checked = False
2073 self.__selected_subtitle = None
2075 def __serviceStopped(self):
2076 self.subtitle_window.hide()
2077 self.__subtitles_enabled = False
2078 self.cached_subtitle_checked = False
2080 def __updatedInfo(self):
2081 if not self.cached_subtitle_checked:
2082 subtitle = self.getCurrentServiceSubtitle()
2083 self.cached_subtitle_checked = True
2084 self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()
2085 if self.__selected_subtitle:
2086 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2087 self.subtitle_window.show()
2088 self.__subtitles_enabled = True
2090 def getCurrentServiceSubtitle(self):
2091 service = self.session.nav.getCurrentService()
2092 return service and service.subtitle()
2094 def setSubtitlesEnable(self, enable=True):
2095 subtitle = self.getCurrentServiceSubtitle()
2096 if enable and self.__selected_subtitle is not None:
2097 if subtitle and not self.__subtitles_enabled:
2098 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2099 self.subtitle_window.show()
2100 self.__subtitles_enabled = True
2103 subtitle.disableSubtitles(self.subtitle_window.instance)
2104 self.__subtitles_enabled = False
2105 self.subtitle_window.hide()
2107 def setSelectedSubtitle(self, subtitle):
2108 self.__selected_subtitle = subtitle
2110 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2111 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2113 class InfoBarServiceErrorPopupSupport:
2115 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2117 iPlayableService.evTuneFailed: self.__tuneFailed,
2118 iPlayableService.evStart: self.__serviceStarted
2120 self.__serviceStarted()
2122 def __serviceStarted(self):
2123 self.last_error = None
2124 Notifications.RemovePopup(id = "ZapError")
2126 def __tuneFailed(self):
2127 service = self.session.nav.getCurrentService()
2128 info = service and service.info()
2129 error = info and info.getInfo(iServiceInformation.sDVBState)
2131 if error == self.last_error:
2134 self.last_error = error
2137 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2138 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2139 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2140 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2141 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2142 eDVBServicePMTHandler.eventNewProgramInfo: None,
2143 eDVBServicePMTHandler.eventTuned: None,
2144 eDVBServicePMTHandler.eventSOF: None,
2145 eDVBServicePMTHandler.eventEOF: None,
2146 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2149 error = errors.get(error) #this returns None when the key not exist in the dict
2151 if error is not None:
2152 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2154 Notifications.RemovePopup(id = "ZapError")