X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/b5ca0a1b4676eea8cf2fd9966634cac73bd46e5b..9f9398866adac30930d3d485e03d7810309461a9:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index a2d1ec76..66af3574 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -5,20 +5,14 @@ from Components.ActionMap import NumberActionMap from Components.BlinkingPixmap import BlinkingPixmapConditional from Components.Harddisk import harddiskmanager from Components.Input import Input -from Components.Label import * -from Components.Pixmap import Pixmap, PixmapConditional +from Components.Label import Label +from Components.Pixmap import Pixmap from Components.PluginComponent import plugins -from Components.ProgressBar import * from Components.ServiceEventTracker import ServiceEventTracker -from Components.Sources.CurrentService import CurrentService -from Components.Sources.EventInfo import EventInfo -from Components.Sources.RadioText import RadioText -from Components.Sources.FrontendStatus import FrontendStatus +from Components.Sources.Source import ObsoleteSource from Components.Sources.Boolean import Boolean -from Components.Sources.Clock import Clock -from Components.TimerList import TimerEntryComponent -from Components.config import config, ConfigBoolean - +from Components.config import config, ConfigBoolean, ConfigClock +from Components.SystemInfo import SystemInfo from EpgSelection import EPGSelection from Plugins.Plugin import PluginDescriptor @@ -32,17 +26,20 @@ from Screens.MinuteInput import MinuteInput from Screens.TimerSelection import TimerSelection from Screens.PictureInPicture import PictureInPicture from Screens.SubtitleDisplay import SubtitleDisplay +from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive +from Screens.SleepTimerEdit import SleepTimerEdit +from Screens.TimeDateInput import TimeDateInput from ServiceReference import ServiceReference from Tools import Notifications -from Tools.Directories import * +from Tools.Directories import SCOPE_HDD, resolveFilename -#from enigma import eTimer, eDVBVolumecontrol, quitMainloop -from enigma import * +from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \ + iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache -import time -import os -import bisect +from time import time, localtime, strftime +from os import stat as os_stat +from bisect import insort # hack alert! from Menu import MainMenu, mdom @@ -50,7 +47,6 @@ from Menu import MainMenu, mdom class InfoBarDish: def __init__(self): self.dishDialog = self.session.instantiateDialog(Dish) - self.onLayoutFinish.append(self.dishDialog.show) class InfoBarShowHide: """ InfoBar show/hide control, accepts toggleShow and hide actions, might start @@ -59,33 +55,43 @@ class InfoBarShowHide: STATE_HIDING = 1 STATE_SHOWING = 2 STATE_SHOWN = 3 - + def __init__(self): self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] , { "toggleShow": self.toggleShow, "hide": self.hide, + }, 1) # lower prio to make it possible to override ok and cancel.. + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evStart: self.serviceStarted, }) self.__state = self.STATE_SHOWN self.__locked = 0 - - self.onExecBegin.append(self.show) - + self.hideTimer = eTimer() - self.hideTimer.timeout.get().append(self.doTimerHide) + self.hideTimer.callback.append(self.doTimerHide) self.hideTimer.start(5000, True) - + self.onShow.append(self.__onShow) self.onHide.append(self.__onHide) + def serviceStarted(self): + if self.execing: + if config.usage.show_infobar_on_zap.value: + self.doShow() + def __onShow(self): self.__state = self.STATE_SHOWN self.startHideTimer() - + def startHideTimer(self): if self.__state == self.STATE_SHOWN and not self.__locked: - self.hideTimer.start(5000, True) + idx = config.usage.infobar_timeout.index + if idx: + self.hideTimer.start(idx*1000, True) def __onHide(self): self.__state = self.STATE_HIDDEN @@ -111,7 +117,7 @@ class InfoBarShowHide: if self.execing: self.show() self.hideTimer.stop() - + def unlockShow(self): self.__locked = self.__locked - 1 if self.execing: @@ -120,7 +126,7 @@ class InfoBarShowHide: # def startShow(self): # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100) # self.__state = self.STATE_SHOWN -# +# # def startHide(self): # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100) # self.__state = self.STATE_HIDDEN @@ -149,7 +155,7 @@ class NumberZap(Screen): self["number"] = Label(self.field) - self["actions"] = NumberActionMap( [ "SetupActions" ], + self["actions"] = NumberActionMap( [ "SetupActions" ], { "cancel": self.quit, "ok": self.keyOK, @@ -166,7 +172,7 @@ class NumberZap(Screen): }) self.Timer = eTimer() - self.Timer.timeout.get().append(self.keyOK) + self.Timer.callback.append(self.keyOK) self.Timer.start(3000, True) class InfoBarNumberZap: @@ -189,10 +195,13 @@ class InfoBarNumberZap: def keyNumberGlobal(self, number): # print "You pressed number " + str(number) if number == 0: - self.servicelist.recallPrevService() - self.doShow() + if isinstance(self, InfoBarPiP) and self.pipHandles0Action(): + self.pipDoHandle0Action() + else: + self.servicelist.recallPrevService() else: - self.session.openWithCallback(self.numberEntered, NumberZap, number) + if self.has_key("TimeshiftActions") and not self.timeshift_enabled: + self.session.openWithCallback(self.numberEntered, NumberZap, number) def numberEntered(self, retval): # print self.servicelist @@ -206,9 +215,9 @@ class InfoBarNumberZap: serviceIterator = servicelist.getNext() if not serviceIterator.valid(): #check end of list break - if serviceIterator.flags: #assume normal dvb service have no flags set - continue - num -= 1; + playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory)) + if playable: + num -= 1; if not num: #found service with searched number ? return serviceIterator, 0 return None, num @@ -217,18 +226,17 @@ class InfoBarNumberZap: bouquet = self.servicelist.bouquet_root service = None serviceHandler = eServiceCenter.getInstance() - if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK + if not config.usage.multibouquet.value: service, number = self.searchNumberHelper(serviceHandler, number, bouquet) else: bouquetlist = serviceHandler.list(bouquet) if not bouquetlist is None: while number: - bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext()) + bouquet = bouquetlist.getNext() if not bouquet.valid(): #check end of list break - if (bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory: - continue - service, number = self.searchNumberHelper(serviceHandler, number, bouquet) + if bouquet.flags & eServiceReference.isDirectory: + service, number = self.searchNumberHelper(serviceHandler, number, bouquet) if not service is None: if self.servicelist.getRoot() != bouquet: #already in correct bouquet? self.servicelist.clearPath() @@ -241,12 +249,12 @@ class InfoBarNumberZap: config.misc.initialchannelselection = ConfigBoolean(default = True) class InfoBarChannelSelection: - """ ChannelSelection - handles the channelSelection dialog and the initial + """ ChannelSelection - handles the channelSelection dialog and the initial channelChange actions which open the channelSelection dialog """ def __init__(self): #instantiate forever self.servicelist = self.session.instantiateDialog(ChannelSelection) - + if config.misc.initialchannelselection.value: self.onShown.append(self.firstRun) @@ -292,7 +300,7 @@ class InfoBarChannelSelection: def switchChannelDown(self): self.servicelist.moveDown() self.session.execDialog(self.servicelist) - + def openServiceList(self): self.session.execDialog(self.servicelist) @@ -312,7 +320,6 @@ class InfoBarChannelSelection: else: self.servicelist.moveUp() self.servicelist.zap() - self.doShow() def zapDown(self): if self.servicelist.inBouquet(): @@ -330,21 +337,29 @@ class InfoBarChannelSelection: else: self.servicelist.moveDown() self.servicelist.zap() - self.doShow() class InfoBarMenu: """ Handles a menu action, to open the (main) menu """ def __init__(self): - self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", + self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", { "mainMenu": (self.mainMenu, _("Enter main menu...")), }) + self.session.infobar = None def mainMenu(self): print "loading mainmenu XML..." menu = mdom.childNodes[0] assert menu.tagName == "menu", "root element in menu must be 'menu'!" - self.session.open(MainMenu, menu, menu.childNodes) + + self.session.infobar = self + # so we can access the currently active infobar from screens opened from within the mainmenu + # at the moment used from the SubserviceSelection + + self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu, menu.childNodes) + + def mainMenuClosed(self, *val): + self.session.infobar = None class InfoBarSimpleEventView: """ Opens the Eventview for now/next """ @@ -387,11 +402,20 @@ class InfoBarEPG: self.dlg_stack = [ ] self.bouquetSel = None self.eventView = None - self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", + self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", { "showEventInfo": (self.openEventView, _("show EPG...")), + "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")), + "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible, }) + def showEventInfoWhenNotVisible(self): + if self.shown: + self.openEventView() + else: + self.toggleShow() + return 1 + def zapToService(self, service): if not service is None: if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet? @@ -410,7 +434,7 @@ class InfoBarEPG: service = servicelist.getNext() if not service.valid(): #check if end of list break - if service.flags: #ignore non playable services + if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services continue services.append(ServiceReference(service)) return services @@ -459,7 +483,7 @@ class InfoBarEPG: self.dlg_stack.append(self.bouquetSel) else: self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True) - elif cnt == 1: + elif cnt == 1: self.openBouquetEPG(bouquets[0][1], withCallback) def openSingleServiceEPG(self): @@ -518,107 +542,192 @@ class InfoBarEPG: class InfoBarTuner: """provides a snr/agc/ber display""" def __init__(self): - self["FrontendStatus"] = FrontendStatus(service_source = self.session.nav.getCurrentService) + self["FrontendStatus"] = ObsoleteSource(new_source = "session.FrontendStatus", removal_date = "2008-01") class InfoBarEvent: """provides a current/next event info display""" def __init__(self): - self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW) - self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT) + self["Event_Now"] = ObsoleteSource(new_source = "session.Event_Now", removal_date = "2008-01") + self["Event_Next"] = ObsoleteSource(new_source = "session.Event_Next", removal_date = "2008-01") -class InfoBarRadioText: - """provides radio (RDS) text info display""" +class InfoBarRdsDecoder: + """provides RDS and Rass support/display""" def __init__(self): - self["RadioText"] = RadioText(self.session.nav) + self.rds_display = self.session.instantiateDialog(RdsInfoDisplay) + self.rass_interactive = None + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evEnd: self.__serviceStopped, + iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged + }) + + self["RdsActions"] = ActionMap(["InfobarRdsActions"], + { + "startRassInteractive": self.startRassInteractive + },-1) + + self["RdsActions"].setEnabled(False) + + self.onLayoutFinish.append(self.rds_display.show) + self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged) + + def RassInteractivePossibilityChanged(self, state): + self["RdsActions"].setEnabled(state) + + def RassSlidePicChanged(self): + if not self.rass_interactive: + service = self.session.nav.getCurrentService() + decoder = service and service.rdsDecoder() + if decoder: + decoder.showRassSlidePicture() + + def __serviceStopped(self): + if self.rass_interactive is not None: + rass_interactive = self.rass_interactive + self.rass_interactive = None + rass_interactive.close() + + def startRassInteractive(self): + self.rds_display.hide() + self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive) + + def RassInteractiveClosed(self, *val): + if self.rass_interactive is not None: + self.rass_interactive = None + self.RassSlidePicChanged() + self.rds_display.show() class InfoBarServiceName: def __init__(self): - self["CurrentService"] = CurrentService(self.session.nav) + self["CurrentService"] = ObsoleteSource(new_source = "session.CurrentService", removal_date = "2008-01") class InfoBarSeek: """handles actions like seeking, pause""" - - # ispause, isff, issm + SEEK_STATE_PLAY = (0, 0, 0, ">") SEEK_STATE_PAUSE = (1, 0, 0, "||") - SEEK_STATE_FF_2X = (0, 2, 0, ">> 2x") - SEEK_STATE_FF_4X = (0, 4, 0, ">> 4x") - SEEK_STATE_FF_8X = (0, 8, 0, ">> 8x") - SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x") - SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x") - SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x") - - SEEK_STATE_BACK_16X = (0, -16, 0, "<< 16x") - SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x") - SEEK_STATE_BACK_64X = (0, -64, 0, "<< 64x") - SEEK_STATE_BACK_128X = (0, -128, 0, "<< 128x") - - SEEK_STATE_SM_HALF = (0, 0, 2, "/2") - SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4") - SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8") - - def __init__(self): + SEEK_STATE_EOF = (1, 0, 0, "END") + + def __init__(self, actionmap = "InfobarSeekActions"): self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged, iPlayableService.evStart: self.__serviceStarted, - + iPlayableService.evEOF: self.__evEOF, iPlayableService.evSOF: self.__evSOF, }) + self.eofState = 0 + self.eofTimer = eTimer() + self.eofTimer.timeout.get().append(self.doEof) + self.eofInhibitTimer = eTimer() + self.eofInhibitTimer.timeout.get().append(self.inhibitEof) + + self.minSpeedBackward = 16 class InfoBarSeekActionMap(HelpableActionMap): def __init__(self, screen, *args, **kwargs): HelpableActionMap.__init__(self, screen, *args, **kwargs) self.screen = screen - + def action(self, contexts, action): + print "action:", action if action[:5] == "seek:": time = int(action[5:]) - self.screen.seekRelative(time * 90000) + self.screen.doSeekRelative(time * 90000) return 1 + elif action[:8] == "seekdef:": + key = int(action[8:]) + time = [-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value, + -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value, + -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value][key-1] + self.screen.doSeekRelative(time * 90000) + return 1 else: return HelpableActionMap.action(self, contexts, action) - self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", + self["SeekActions"] = InfoBarSeekActionMap(self, actionmap, { + "playpauseService": self.playpauseService, "pauseService": (self.pauseService, _("pause")), "unPauseService": (self.unPauseService, _("continue")), - + "seekFwd": (self.seekFwd, _("skip forward")), - "seekFwdDown": self.seekFwdDown, - "seekFwdUp": self.seekFwdUp, + "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")), "seekBack": (self.seekBack, _("skip backward")), - "seekBackDown": self.seekBackDown, - "seekBackUp": self.seekBackUp, + "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")) }, prio=-1) # give them a little more priority to win over color buttons + self["SeekActions"].setEnabled(False) + self.seekstate = self.SEEK_STATE_PLAY - self.onClose.append(self.delTimer) - - self.fwdtimer = False - self.fwdKeyTimer = eTimer() - self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire) + self.lastseekstate = self.SEEK_STATE_PLAY - self.rwdtimer = False - self.rwdKeyTimer = eTimer() - self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire) - self.onPlayStateChanged = [ ] - + self.lockedBecauseOfSkipping = False - + + self.__seekableStatusChanged() + + def makeStateForward(self, n): + minspeed = config.seek.stepwise_minspeed.value + repeat = int(config.seek.stepwise_repeat.value) + if minspeed != "Never" and n >= int(minspeed) and repeat > 1: + return (0, n * repeat, repeat, ">> %dx" % n) + else: + return (0, n, 0, ">> %dx" % n) + + def makeStateBackward(self, n): + minspeed = config.seek.stepwise_minspeed.value + repeat = int(config.seek.stepwise_repeat.value) + if n < self.minSpeedBackward: + r = (self.minSpeedBackward - 1)/ n + 1 + if minspeed != "Never" and n >= int(minspeed) and repeat > 1: + r = max(r, repeat) + return (0, -n * r, r, "<< %dx" % n) + elif minspeed != "Never" and n >= int(minspeed) and repeat > 1: + return (0, -n * repeat, repeat, "<< %dx" % n) + else: + return (0, -n, 0, "<< %dx" % n) + + def makeStateSlowMotion(self, n): + return (0, 0, n, "/%d" % n) + + def isStateForward(self, state): + return state[1] > 1 + + def isStateBackward(self, state): + return state[1] < 0 + + def isStateSlowMotion(self, state): + return state[1] == 0 and state[2] > 1 + + def getHigher(self, n, lst): + for x in lst: + if x > n: + return x + return False + + def getLower(self, n, lst): + lst = lst+[] + lst.reverse() + for x in lst: + if x < n: + return x + return False + + def showAfterSeek(self): + if isinstance(self, InfoBarShowHide): + self.doShow() + def up(self): pass - + def down(self): pass - - def delTimer(self): - del self.fwdKeyTimer - del self.rwdKeyTimer - + def getSeek(self): service = self.session.nav.getCurrentService() if service is None: @@ -628,9 +737,9 @@ class InfoBarSeek: if seek is None or not seek.isCurrentlySeekable(): return None - + return seek - + def isSeekable(self): if self.getSeek() is None: return False @@ -648,226 +757,293 @@ class InfoBarSeek: def __serviceStarted(self): self.seekstate = self.SEEK_STATE_PLAY + self.__seekableStatusChanged() + if self.eofState != 0: + self.eofTimer.stop() + self.eofState = 0 def setSeekState(self, state): service = self.session.nav.getCurrentService() - + if service is None: return False - + if not self.isSeekable(): if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]: state = self.SEEK_STATE_PLAY - + pauseable = service.pause() if pauseable is None: print "not pauseable." state = self.SEEK_STATE_PLAY - + oldstate = self.seekstate self.seekstate = state - + for i in range(3): if oldstate[i] != self.seekstate[i]: (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i]) for c in self.onPlayStateChanged: c(self.seekstate) - + self.checkSkipShowHideLock() return True + def playpauseService(self): + if self.seekstate != self.SEEK_STATE_PLAY: + self.unPauseService() + else: + self.pauseService() + def pauseService(self): if self.seekstate == self.SEEK_STATE_PAUSE: - print "pause, but in fact unpause" - self.unPauseService() + if config.seek.on_pause.value == "play": + self.unPauseService() + elif config.seek.on_pause.value == "step": + self.doSeekRelative(0) + elif config.seek.on_pause.value == "last": + self.setSeekState(self.lastseekstate) + self.lastseekstate = self.SEEK_STATE_PLAY else: - if self.seekstate == self.SEEK_STATE_PLAY: - print "yes, playing." - else: - print "no", self.seekstate - print "pause" + if self.seekstate != self.SEEK_STATE_EOF: + self.lastseekstate = self.seekstate self.setSeekState(self.SEEK_STATE_PAUSE); - + def unPauseService(self): print "unpause" if self.seekstate == self.SEEK_STATE_PLAY: return 0 self.setSeekState(self.SEEK_STATE_PLAY) - - def doSeek(self, seektime): - print "doseek", seektime - service = self.session.nav.getCurrentService() - if service is None: - return - + + def doSeek(self, pts): seekable = self.getSeek() if seekable is None: return - - seekable.seekTo(90 * seektime) - - def seekFwdDown(self): - print "start fwd timer" - self.fwdtimer = True - self.fwdKeyTimer.start(1000) - - def seekBackDown(self): - print "start rewind timer" - self.rwdtimer = True - self.rwdKeyTimer.start(1000) + prevstate = self.seekstate + if self.eofState == 1: + self.eofState = 2 + self.inhibitEof() + if self.seekstate == self.SEEK_STATE_EOF: + if prevstate == self.SEEK_STATE_PAUSE: + self.setSeekState(self.SEEK_STATE_PAUSE) + else: + self.setSeekState(self.SEEK_STATE_PLAY) + self.eofInhibitTimer.start(200, True) + seekable.seekTo(pts) - def seekFwdUp(self): - print "seekFwdUp" - if self.fwdtimer: - self.fwdKeyTimer.stop() - self.fwdtimer = False - self.seekFwd() + def doSeekRelative(self, pts): + seekable = self.getSeek() + if seekable is None: + return + prevstate = self.seekstate + if self.eofState == 1: + self.eofState = 2 + self.inhibitEof() + if self.seekstate == self.SEEK_STATE_EOF: + if prevstate == self.SEEK_STATE_PAUSE: + self.setSeekState(self.SEEK_STATE_PAUSE) + else: + self.setSeekState(self.SEEK_STATE_PLAY) + self.eofInhibitTimer.start(200, True) + seekable.seekRelative(pts<0 and -1 or 1, abs(pts)) + if abs(pts) > 100 and config.usage.show_infobar_on_skip.value: + self.showAfterSeek() def seekFwd(self): - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH, - self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X, - self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X, - self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X, - self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X, - self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X, - self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X, - self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X, - self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X, - self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF, - self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF, - self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER - } - self.setSeekState(lookup[self.seekstate]) - - def seekBackUp(self): - print "seekBackUp" - if self.rwdtimer: - self.rwdKeyTimer.stop() - self.rwdtimer = False - self.seekBack() - + if self.seekstate == self.SEEK_STATE_PLAY: + self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value))) + elif self.seekstate == self.SEEK_STATE_PAUSE: + if config.seek.speeds_slowmotion: + self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1])) + else: + self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value))) + elif self.seekstate == self.SEEK_STATE_EOF: + pass + elif self.isStateForward(self.seekstate): + speed = self.seekstate[1] + if self.seekstate[2]: + speed /= self.seekstate[2] + speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1] + self.setSeekState(self.makeStateForward(speed)) + elif self.isStateBackward(self.seekstate): + speed = -self.seekstate[1] + if self.seekstate[2]: + speed /= self.seekstate[2] + speed = self.getLower(speed, config.seek.speeds_backward.value) + if speed: + self.setSeekState(self.makeStateBackward(speed)) + else: + self.setSeekState(self.SEEK_STATE_PLAY) + elif self.isStateSlowMotion(self.seekstate): + speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0] + self.setSeekState(self.makeStateSlowMotion(speed)) + def seekBack(self): - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE, - self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY, - self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X, - self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X, - self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X, - self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X, - self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X, - self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X, - self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X, - self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER, - self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH, - self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE - } - self.setSeekState(lookup[self.seekstate]) - - if self.seekstate == self.SEEK_STATE_PAUSE: - seekable = self.getSeek() - if seekable is not None: - seekable.seekRelative(-1, 3) + if self.seekstate == self.SEEK_STATE_PLAY: + self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value))) + elif self.seekstate == self.SEEK_STATE_EOF: + self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value))) + self.doSeekRelative(-6) + elif self.seekstate == self.SEEK_STATE_PAUSE: + self.doSeekRelative(-3) + elif self.isStateForward(self.seekstate): + speed = self.seekstate[1] + if self.seekstate[2]: + speed /= self.seekstate[2] + speed = self.getLower(speed, config.seek.speeds_forward.value) + if speed: + self.setSeekState(self.makeStateForward(speed)) + else: + self.setSeekState(self.SEEK_STATE_PLAY) + elif self.isStateBackward(self.seekstate): + speed = -self.seekstate[1] + if self.seekstate[2]: + speed /= self.seekstate[2] + speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1] + self.setSeekState(self.makeStateBackward(speed)) + elif self.isStateSlowMotion(self.seekstate): + speed = self.getHigher(self.seekstate[2], config.seek.speeds_slowmotion.value) + if speed: + self.setSeekState(self.makeStateSlowMotion(speed)) + else: + self.setSeekState(self.SEEK_STATE_PAUSE) - def fwdTimerFire(self): - print "Display seek fwd" - self.fwdKeyTimer.stop() - self.fwdtimer = False + def seekFwdManual(self): self.session.openWithCallback(self.fwdSeekTo, MinuteInput) - + def fwdSeekTo(self, minutes): print "Seek", minutes, "minutes forward" - if minutes != 0: - seekable = self.getSeek() - if seekable is not None: - seekable.seekRelative(1, minutes * 60 * 90000) - - def rwdTimerFire(self): - print "rwdTimerFire" - self.rwdKeyTimer.stop() - self.rwdtimer = False + self.doSeekRelative(minutes * 60 * 90000) + + def seekBackManual(self): self.session.openWithCallback(self.rwdSeekTo, MinuteInput) - + def rwdSeekTo(self, minutes): print "rwdSeekTo" - self.fwdSeekTo(0 - minutes) - + self.doSeekRelative(-minutes * 60 * 90000) + def checkSkipShowHideLock(self): wantlock = self.seekstate != self.SEEK_STATE_PLAY - - if self.lockedBecauseOfSkipping and not wantlock: - self.unlockShow() - self.lockedBecauseOfSkipping = False - - if wantlock and not self.lockedBecauseOfSkipping: - self.lockShow() - self.lockedBecauseOfSkipping = True + if config.usage.show_infobar_on_skip.value: + if self.lockedBecauseOfSkipping and not wantlock: + self.unlockShow() + self.lockedBecauseOfSkipping = False + + if wantlock and not self.lockedBecauseOfSkipping: + self.lockShow() + self.lockedBecauseOfSkipping = True + + def calcRemainingTime(self): + seekable = self.getSeek() + if seekable is not None: + len = seekable.getLength() + try: + tmp = self.cueGetEndCutPosition() + if tmp: + len = [False, tmp] + except: + pass + pos = seekable.getPlayPosition() + speednom = self.seekstate[1] or 1 + speedden = self.seekstate[2] or 1 + if not len[0] and not pos[0]: + if len[1] <= pos[1]: + return 0 + time = (len[1] - pos[1])*speedden/(90*speednom) + return time + return False + def __evEOF(self): - if self.seekstate != self.SEEK_STATE_PLAY: - self.setSeekState(self.SEEK_STATE_PAUSE) - # HACK - #self.getSeek().seekRelative(1, -90000) - self.setSeekState(self.SEEK_STATE_PLAY) + if self.eofState == 0 and self.seekstate != self.SEEK_STATE_EOF: + self.eofState = 1 + time = self.calcRemainingTime() + if not time: + time = 3000 # Failed to calc, use default + elif time == 0: + time = 300 # Passed end, shortest wait + elif time > 15000: + self.eofState = -2 # Too long, block eof + time = 15000 + else: + time += 1000 # Add margin + self.eofTimer.start(time, True) + + def inhibitEof(self): + if self.eofState >= 1: + self.eofState = -self.eofState + self.eofTimer.stop() + self.doEof() + + def doEof(self): + if self.seekstate == self.SEEK_STATE_EOF: + return + if self.eofState == -2 or self.isStateBackward(self.seekstate): + self.eofState = 0 + return + + # if we are seeking, we try to end up ~1s before the end, and pause there. + eofstate = self.eofState + seekstate = self.seekstate + self.eofState = 0 + if not self.seekstate == self.SEEK_STATE_PAUSE: + self.setSeekState(self.SEEK_STATE_EOF) + if eofstate == -1 or not seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]: + seekable = self.getSeek() + if seekable is not None: + seekable.seekTo(-1) + if eofstate == 1 and seekstate == self.SEEK_STATE_PLAY: + self.doEofInternal(True) else: - self.setSeekState(self.SEEK_STATE_PAUSE) - + self.doEofInternal(False) + + def doEofInternal(self, playing): + pass # Defined in subclasses + def __evSOF(self): self.setSeekState(self.SEEK_STATE_PLAY) self.doSeek(0) - def seekRelative(self, diff): - seekable = self.getSeek() - if seekable is not None: - seekable.seekRelative(1, diff) - - def seekAbsolute(self, abs): - seekable = self.getSeek() - if seekable is not None: - seekable.seekTo(abs) - from Screens.PVRState import PVRState, TimeshiftState class InfoBarPVRState: def __init__(self, screen=PVRState): self.onPlayStateChanged.append(self.__playStateChanged) self.pvrStateDialog = self.session.instantiateDialog(screen) - self.onShow.append(self.__mayShow) + self.onShow.append(self._mayShow) self.onHide.append(self.pvrStateDialog.hide) - - def __mayShow(self): - if self.seekstate != self.SEEK_STATE_PLAY and self.execing: + + def _mayShow(self): + if self.execing and self.seekstate != self.SEEK_STATE_PLAY: self.pvrStateDialog.show() def __playStateChanged(self, state): playstateString = state[3] self.pvrStateDialog["state"].setText(playstateString) - self.__mayShow() + self._mayShow() class InfoBarTimeshiftState(InfoBarPVRState): def __init__(self): InfoBarPVRState.__init__(self, screen=TimeshiftState) + def _mayShow(self): + if self.execing and self.timeshift_enabled: + self.pvrStateDialog.show() + class InfoBarShowMovies: - # i don't really like this class. + # i don't really like this class. # it calls a not further specified "movie list" on up/down/movieList, # so this is not more than an action map def __init__(self): - self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", + self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", { - "movieList": (self.showMovies, "movie list"), - "up": (self.showMovies, "movie list"), - "down": (self.showMovies, "movie list") + "movieList": (self.showMovies, _("movie list")), + "up": (self.showMovies, _("movie list")), + "down": (self.showMovies, _("movie list")) }) # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE! @@ -877,7 +1053,7 @@ class InfoBarShowMovies: # Timeshift works the following way: # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions" # - normal playback TUNER unused PLAY enable disable disable -# - user presses "yellow" button. TUNER record PAUSE enable disable enable +# - user presses "yellow" button. FILE record PAUSE enable disable enable # - user presess pause again FILE record PLAY enable disable enable # - user fast forwards FILE record FF enable disable enable # - end of timeshift buffer reached TUNER record PLAY enable enable disable @@ -900,28 +1076,28 @@ class InfoBarShowMovies: class InfoBarTimeshift: def __init__(self): - self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", + self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", { "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key" "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV' }, prio=1) self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"], { - "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key" - "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "backward key" + "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key" + "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key" }, prio=-1) # priority over record self.timeshift_enabled = 0 self.timeshift_state = 0 - self.ts_pause_timer = eTimer() - self.ts_pause_timer.timeout.get().append(self.pauseService) + self.ts_rewind_timer = eTimer() + self.ts_rewind_timer.callback.append(self.rewindService) self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { iPlayableService.evStart: self.__serviceStarted, iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged }) - + def getTimeshift(self): service = self.session.nav.getCurrentService() return service and service.timeshift() @@ -930,23 +1106,23 @@ class InfoBarTimeshift: print "enable timeshift" ts = self.getTimeshift() if ts is None: -# self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR) -# print "no ts interface" - return 0; - + self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR) + print "no ts interface" + return 0 + if self.timeshift_enabled: print "hu, timeshift already enabled?" else: if not ts.startTimeshift(): - import time self.timeshift_enabled = 1 # we remove the "relative time" for now. #self.pvrStateDialog["timeshift"].setRelative(time.time()) - + # PAUSE. - self.setSeekState(self.SEEK_STATE_PAUSE) - + #self.setSeekState(self.SEEK_STATE_PAUSE) + self.activateTimeshiftEnd(False) + # enable the "TimeshiftEnableActions", which will override # the startTimeshift actions self.__seekableStatusChanged() @@ -975,45 +1151,44 @@ class InfoBarTimeshift: # disable actions self.__seekableStatusChanged() - + # activates timeshift, and seeks to (almost) the end - def activateTimeshiftEnd(self): + def activateTimeshiftEnd(self, back = True): ts = self.getTimeshift() - + print "activateTimeshiftEnd" + if ts is None: return - + if ts.isTimeshiftActive(): print "!! activate timeshift called - but shouldn't this be a normal pause?" self.pauseService() else: - self.setSeekState(self.SEEK_STATE_PLAY) - ts.activateTimeshift() - self.seekRelative(0) - + print "play, ..." + ts.activateTimeshift() # activate timeshift will automatically pause + self.setSeekState(self.SEEK_STATE_PAUSE) + + if back: + self.doSeek(-5) # seek some gops before end + self.ts_rewind_timer.start(200, 1) + else: + self.doSeek(-1) # seek 1 gop before end + + def rewindService(self): + self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value))) + # same as activateTimeshiftEnd, but pauses afterwards. def activateTimeshiftEndAndPause(self): - state = self.seekstate - self.activateTimeshiftEnd() - - # well, this is "andPause", but it could be pressed from pause, - # when pausing on the (fake-)"live" picture, so an un-pause - # is perfectly ok. - - print "now, pauseService" - if state == self.SEEK_STATE_PLAY: - print "is PLAYING, start pause timer" - self.ts_pause_timer.start(200, 1) - else: - print "unpause" - self.unPauseService() - + print "activateTimeshiftEndAndPause" + #state = self.seekstate + self.activateTimeshiftEnd(False) + def __seekableStatusChanged(self): enabled = False - + print "self.isSeekable", self.isSeekable() print "self.timeshift_enabled", self.timeshift_enabled - + # when this service is not seekable, but timeshift # is enabled, this means we can activate # the timeshift @@ -1032,10 +1207,10 @@ from Screens.PiPSetup import PiPSetup class InfoBarExtensions: EXTENSION_SINGLE = 0 EXTENSION_LIST = 1 - + def __init__(self): self.list = [] - + self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions", { "extensions": (self.showExtensionSelection, _("view extensions...")), @@ -1043,13 +1218,13 @@ class InfoBarExtensions: def addExtension(self, extension, key = None, type = EXTENSION_SINGLE): self.list.append((type, extension, key)) - + def updateExtension(self, extension, key = None): self.extensionsList.append(extension) if key is not None: if self.extensionKeys.has_key(key): key = None - + if key is None: for x in self.availableKeys: if not self.extensionKeys.has_key(x): @@ -1058,7 +1233,7 @@ class InfoBarExtensions: if key is not None: self.extensionKeys[key] = len(self.extensionsList) - 1 - + def updateExtensions(self): self.extensionsList = [] self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ] @@ -1104,11 +1279,10 @@ from Components.PluginComponent import plugins class InfoBarPlugins: def __init__(self): self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST) - - + def getPluginName(self, name): return name - + def getPluginList(self): list = [] for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU): @@ -1116,74 +1290,59 @@ class InfoBarPlugins: return list def runPlugin(self, plugin): - plugin(session = self.session) + plugin(session = self.session, servicelist = self.servicelist) -# depends on InfoBarExtensions and InfoBarSubtitleSupport -class InfoBarSubtitles: +# depends on InfoBarExtensions +class InfoBarSleepTimer: def __init__(self): - self.addExtension((self.getDisableSubtitleName, self.disableSubtitles, self.subtitlesEnabled), "4") - self.addExtension(extension = self.getSubtitleList, type = InfoBarExtensions.EXTENSION_LIST) - - def getDisableSubtitleName(self): - return _("Disable subtitles") + self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1") - def getSubtitleList(self): - list = [] - s = self.getCurrentServiceSubtitle() - l = s and s.getSubtitleList() or [ ] + def available(self): + return True - for x in l: - list.append(((boundFunction(self.getSubtitleEntryName, x[0]), boundFunction(self.enableSubtitle, x[1]), lambda: True), None)) - return list - - def getSubtitleEntryName(self, name): - return "Enable Subtitles: " + name - - def enableSubtitle(self, subtitles): - print "enable subitles", subtitles - self.selected_subtitle = subtitles - self.subtitles_enabled = True - - def subtitlesEnabled(self): - return self.subtitles_enabled - - def disableSubtitles(self): - self.subtitles_enabled = False + def getSleepTimerName(self): + return _("Sleep Timer") + + def showSleepTimerSetup(self): + self.session.open(SleepTimerEdit) # depends on InfoBarExtensions class InfoBarPiP: def __init__(self): self.session.pipshown = False - - self.addExtension((self.getShowHideName, self.showPiP, self.available), "1") - self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "2") - self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "3") + if SystemInfo.get("NumVideoDecoders", 1) > 1: + self.addExtension((self.getShowHideName, self.showPiP, self.available), "blue") + self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green") + self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow") - def available(self): - return True - + return SystemInfo.get("NumVideoDecoders", 1) > 1 + def pipShown(self): return self.session.pipshown - + + def pipHandles0Action(self): + return self.pipShown() and config.usage.pip_zero_button.value != "standard" + def getShowHideName(self): if self.session.pipshown: return _("Disable Picture in Picture") else: return _("Activate Picture in Picture") - + def getSwapName(self): return _("Swap Services") - + def getMoveName(self): return _("Move Picture in Picture") - + def showPiP(self): if self.session.pipshown: del self.session.pip self.session.pipshown = False else: self.session.pip = self.session.instantiateDialog(PictureInPicture) + self.session.pip.show() newservice = self.session.nav.getCurrentlyPlayingServiceReference() if self.session.pip.playService(newservice): self.session.pipshown = True @@ -1192,7 +1351,7 @@ class InfoBarPiP: self.session.pipshown = False del self.session.pip self.session.nav.playService(newservice) - + def swapPiP(self): swapservice = self.session.nav.getCurrentlyPlayingServiceReference() if self.session.pip.servicePath: @@ -1205,14 +1364,24 @@ class InfoBarPiP: self.session.nav.stopService() # stop portal self.session.nav.playService(pipref) # start subservice self.session.pip.servicePath=servicepath - + def movePiP(self): self.session.open(PiPSetup, pip = self.session.pip) + def pipDoHandle0Action(self): + use = config.usage.pip_zero_button.value + if "swap" == use: + self.swapPiP() + elif "swapstop" == use: + self.swapPiP() + self.showPiP() + elif "stop" == use: + self.showPiP() + from RecordTimer import parseEvent class InfoBarInstantRecord: - """Instant Record - handles the instantRecord action in order to + """Instant Record - handles the instantRecord action in order to start/stop instant records""" def __init__(self): self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord", @@ -1220,18 +1389,22 @@ class InfoBarInstantRecord: "instantRecord": (self.instantRecord, _("Instant Record...")), }) self.recording = [] +#### DEPRECATED CODE #### self["BlinkingPoint"] = BlinkingPixmapConditional() - self["BlinkingPoint"].hide() self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording) + self["BlinkingPoint"].deprecationInfo = ( + "session.RecordState source, Pixmap renderer and " + "ConditionalShowHide/Blink Converter", "2008-02") +######################### - def stopCurrentRecording(self, entry = -1): + def stopCurrentRecording(self, entry = -1): if entry is not None and entry != -1: self.session.nav.RecordTimer.removeEntry(self.recording[entry]) self.recording.remove(self.recording[entry]) def startInstantRecording(self, limitEvent = False): serviceref = self.session.nav.getCurrentlyPlayingServiceReference() - + # try to get event info event = None try: @@ -1245,12 +1418,12 @@ class InfoBarInstantRecord: except: pass - begin = time.time() - end = time.time() + 3600 * 10 + begin = time() + end = time() + 3600 * 10 name = "instant record" description = "" eventid = None - + if event is not None: curEvent = parseEvent(event) name = curEvent[2] @@ -1261,15 +1434,17 @@ class InfoBarInstantRecord: else: if limitEvent: self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO) - + data = (begin, end, name, description, eventid) - + recording = self.session.nav.recordWithTimer(serviceref, *data) recording.dontSave = True self.recording.append(recording) - - #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning()) - + +#### DEPRECATED CODE #### + self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning()) +######################### + def isInstantRecordRunning(self): print "self.recording:", self.recording if len(self.recording) > 0: @@ -1280,7 +1455,7 @@ class InfoBarInstantRecord: def recordQuestionCallback(self, answer): print "pre:\n", self.recording - + if answer is None or answer[1] == "no": return list = [] @@ -1289,29 +1464,46 @@ class InfoBarInstantRecord: if not x in self.session.nav.RecordTimer.timer_list: self.recording.remove(x) elif x.dontSave and x.isRunning(): - list.append(TimerEntryComponent(x, False)) + list.append((x, False)) if answer[1] == "changeduration": if len(self.recording) == 1: self.changeDuration(0) else: self.session.openWithCallback(self.changeDuration, TimerSelection, list) + elif answer[1] == "changeendtime": + if len(self.recording) == 1: + self.setEndtime(0) + else: + self.session.openWithCallback(self.setEndtime, TimerSelection, list) elif answer[1] == "stop": if len(self.recording) == 1: self.stopCurrentRecording(0) else: self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list) - if answer[1] == "indefinitely" or answer[1] == "manualduration" or answer[1] == "event": - limitEvent = False - if answer[1] == "event": - limitEvent = True + elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"): + self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False) if answer[1] == "manualduration": - self.selectedEntry = len(self.recording) - self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER) - self.startInstantRecording(limitEvent = limitEvent) - + self.changeDuration(len(self.recording)-1) + elif answer[1] == "manualendtime": + self.setEndtime(len(self.recording)-1) print "after:\n", self.recording + def setEndtime(self, entry): + if entry is not None: + self.selectedEntry = entry + self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end) + dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime) + dlg.setTitle(_("Please change recording endtime")) + + def TimeDateInputClosed(self, ret): + if len(ret) > 1: + if ret[0]: + localendtime = localtime(ret[1]) + print "stopping recording at", strftime("%c", localendtime) + self.recording[self.selectedEntry].end = ret[1] + self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) + def changeDuration(self, entry): if entry is not None: self.selectedEntry = entry @@ -1320,26 +1512,41 @@ class InfoBarInstantRecord: def inputCallback(self, value): if value is not None: print "stopping recording after", int(value), "minutes." - self.recording[self.selectedEntry].end = time.time() + 60 * int(value) + self.recording[self.selectedEntry].end = time() + 60 * int(value) self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) def instantRecord(self): try: - stat = os.stat(resolveFilename(SCOPE_HDD)) + stat = os_stat(resolveFilename(SCOPE_HDD)) except: self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR) return if self.isInstantRecordRunning(): - self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("A recording is currently running.\nWhat do you want to do?"), list=[(_("stop recording"), "stop"), (_("change recording (duration)"), "changeduration"), (_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"), (_("do nothing"), "no")]) + self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \ + title=_("A recording is currently running.\nWhat do you want to do?"), \ + list=[(_("stop recording"), "stop"), \ + (_("change recording (duration)"), "changeduration"), \ + (_("change recording (endtime)"), "changeendtime"), \ + (_("add recording (indefinitely)"), "indefinitely"), \ + (_("add recording (stop after current event)"), "event"), \ + (_("add recording (enter recording duration)"), "manualduration"), \ + (_("add recording (enter recording endtime)"), "manualendtime"), \ + (_("do nothing"), "no")]) else: - self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")]) + self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \ + title=_("Start recording?"), \ + list=[(_("add recording (indefinitely)"), "indefinitely"), \ + (_("add recording (stop after current event)"), "event"), \ + (_("add recording (enter recording duration)"), "manualduration"), \ + (_("add recording (enter recording endtime)"), "manualendtime"), \ + (_("don't record"), "no")]) from Tools.ISO639 import LanguageCodes class InfoBarAudioSelection: def __init__(self): - self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", + self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", { "audioSelection": (self.audioSelection, _("Audio Options...")), }) @@ -1351,7 +1558,6 @@ class InfoBarAudioSelection: n = audio and audio.getNumberOfTracks() or 0 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n tlist = [] - print "tlist:", tlist if n > 0: self.audioChannel = service.audioChannel() @@ -1359,20 +1565,19 @@ class InfoBarAudioSelection: i = audio.getTrackInfo(x) language = i.getLanguage() description = i.getDescription() - - if len(language) == 3: - if language in LanguageCodes: - language = LanguageCodes[language][0] - + + if LanguageCodes.has_key(language): + language = LanguageCodes[language][0] + if len(description): description += " (" + language + ")" else: description = language - + tlist.append((description, x)) - - selectedAudio = tlist[0][1] - tlist.sort(lambda x,y : cmp(x[0], y[0])) + + selectedAudio = audio.getCurrentTrack() + tlist.sort(key=lambda x: x[0]) selection = 2 for x in tlist: @@ -1423,6 +1628,8 @@ class InfoBarSubserviceSelection: self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events + self.bsel = None + def checkSubservicesAvail(self, ev): if ev == iPlayableService.evUpdatedEventInfo: service = self.session.nav.getCurrentService() @@ -1456,13 +1663,12 @@ class InfoBarSubserviceSelection: if newservice.valid(): del subservices del service - self.doShow() self.session.nav.playService(newservice) def subserviceSelection(self): service = self.session.nav.getCurrentService() subservices = service and service.subServices() - + self.bouquets = self.servicelist.getBouquetList() n = subservices and subservices.getNumberOfSubservices() selection = 0 if n and n > 0: @@ -1474,13 +1680,22 @@ class InfoBarSubserviceSelection: selection = x tlist.append((i.getName(), i)) - tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist - - keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n + if self.bouquets and len(self.bouquets): + keys = ["red", "green", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n + if config.usage.multibouquet.value: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist + else: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist + selection += 3 + else: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist + keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n + selection += 2 - self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection + 2, keys = keys) + self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys) def subserviceSelected(self, service): + del self.bouquets if not service is None: if isinstance(service[1], str): if service[1] == "quickzap": @@ -1488,24 +1703,64 @@ class InfoBarSubserviceSelection: self.session.open(SubservicesQuickzap, service[2]) else: self["SubserviceQuickzapAction"].setEnabled(True) - self.doShow() self.session.nav.playService(service[1]) + def addSubserviceToBouquetCallback(self, service): + if len(service) > 1 and isinstance(service[1], eServiceReference): + self.selectedSubservice = service + if self.bouquets is None: + cnt = 0 + else: + cnt = len(self.bouquets) + if cnt > 1: # show bouquet list + self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet) + elif cnt == 1: # add to only one existing bouquet + self.addSubserviceToBouquet(self.bouquets[0][1]) + self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO) + + def bouquetSelClosed(self, confirmed): + self.bsel = None + del self.selectedSubservice + if confirmed: + self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO) + + def addSubserviceToBouquet(self, dest): + self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1]) + if self.bsel: + self.bsel.close(True) + else: + del self.selectedSubservice + class InfoBarAdditionalInfo: def __init__(self): + + self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0) + self["TimeshiftPossible"] = self["RecordingPossible"] + self["ExtensionsAvailable"] = Boolean(fixed=1) + +######### DEPRECATED CODE ########## self["NimA"] = Pixmap() + self["NimA"].deprecationInfo = ( + "session.TunerInfo source, Pixmap renderer, TunerInfo/UseMask Converter" + ", ValueBitTest(1) Converter and ConditionalShowHide Converter", "2008-02") self["NimB"] = Pixmap() + self["NimB"].deprecationInfo = ( + "session.TunerInfo source, Pixmap renderer, TunerInfo/UseMask Converter" + ", ValueBitTest(2) Converter and ConditionalShowHide Converter", "2008-02") self["NimA_Active"] = Pixmap() + self["NimA_Active"].deprecationInfo = ( + "session.FrontendInfo source, Pixmap renderer, FrontendInfo/NUMBER Converter" + ", ValueRange(1,1) Converter and ConditionalShowHide Converter", "2008-02") self["NimB_Active"] = Pixmap() + self["NimB_Active"].deprecationInfo = ( + "session.FrontendInfo source, Pixmap renderer, FrontendInfo/NUMBER Converter" + ", ValueRange(1,1) Converter and ConditionalShowHide Converter", "2008-02") - self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0) - self["TimeshiftPossible"] = self["RecordingPossible"] - self["ExtensionsAvailable"] = Boolean(fixed=1) + res_mgr = eDVBResourceManager.getInstance() + if res_mgr: + res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged) self.session.nav.event.append(self.gotServiceEvent) # we like to get service events - res_mgr = eDVBResourceManagerPtr() - if eDVBResourceManager.getInstance(res_mgr) == 0: - res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged) def tunerUseMaskChanged(self, mask): if mask&1: @@ -1518,7 +1773,7 @@ class InfoBarAdditionalInfo: self["NimB_Active"].hide() def checkTunerState(self, service): - info = service.frontendInfo() + info = service and service.frontendInfo() feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber) if feNumber is None: self["NimA"].hide() @@ -1532,18 +1787,19 @@ class InfoBarAdditionalInfo: def gotServiceEvent(self, ev): service = self.session.nav.getCurrentService() - if ev == iPlayableService.evStart: + if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd: self.checkTunerState(service) +#################################### class InfoBarNotifications: def __init__(self): self.onExecBegin.append(self.checkNotifications) Notifications.notificationAdded.append(self.checkNotificationsIfExecing) self.onClose.append(self.__removeNotification) - + def __removeNotification(self): Notifications.notificationAdded.remove(self.checkNotificationsIfExecing) - + def checkNotificationsIfExecing(self): if self.execing: self.checkNotifications() @@ -1551,12 +1807,26 @@ class InfoBarNotifications: def checkNotifications(self): if len(Notifications.notifications): n = Notifications.notifications[0] + Notifications.notifications = Notifications.notifications[1:] cb = n[0] + + if n[3].has_key("onSessionOpenCallback"): + n[3]["onSessionOpenCallback"]() + del n[3]["onSessionOpenCallback"] + if cb is not None: - self.session.openWithCallback(cb, n[1], *n[2], **n[3]) + dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3]) else: - self.session.open(n[1], *n[2], **n[3]) + dlg = self.session.open(n[1], *n[2], **n[3]) + + # remember that this notification is currently active + d = (n[4], dlg) + Notifications.current_notifications.append(d) + dlg.onClose.append(boundFunction(self.__notificationClosed, d)) + + def __notificationClosed(self, d): + Notifications.current_notifications.remove(d) class InfoBarServiceNotifications: def __init__(self): @@ -1578,17 +1848,17 @@ class InfoBarCueSheetSupport: CUT_TYPE_OUT = 1 CUT_TYPE_MARK = 2 CUT_TYPE_LAST = 3 - + ENABLE_RESUME_SUPPORT = False - - def __init__(self): - self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions", + + def __init__(self, actionmap = "InfobarCueSheetActions"): + self["CueSheetActions"] = HelpableActionMap(self, actionmap, { - "jumpPreviousMark": (self.jumpPreviousMark, "jump to next marked position"), - "jumpNextMark": (self.jumpNextMark, "jump to previous marked position"), - "toggleMark": (self.toggleMark, "toggle a cut mark at the current position") - }, prio=1) - + "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")), + "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")), + "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position")) + }, prio=1) + self.cut_list = [ ] self.is_closing = False self.__event_tracker = ServiceEventTracker(screen=self, eventmap= @@ -1601,23 +1871,29 @@ class InfoBarCueSheetSupport: return print "new service started! trying to download cuts!" self.downloadCuesheet() - + if self.ENABLE_RESUME_SUPPORT: last = None - + for (pts, what) in self.cut_list: if what == self.CUT_TYPE_LAST: last = pts - + if last is not None: self.resume_point = last - Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10) + if config.usage.on_movie_start.value == "ask": + Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10) + elif config.usage.on_movie_start.value == "resume": + Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO) def playLastCB(self, answer): if answer == True: - seekable = self.__getSeekable() - if seekable is not None: - seekable.seekTo(self.resume_point) + self.doSeek(self.resume_point) + self.hideAfterResume() + + def hideAfterResume(self): + if isinstance(self, InfoBarShowHide): + self.hide() def __getSeekable(self): service = self.session.nav.getCurrentService() @@ -1634,37 +1910,64 @@ class InfoBarCueSheetSupport: return None return long(r[1]) - def jumpPreviousNextMark(self, cmp, alternative=None): + def cueGetEndCutPosition(self): + ret = False + isin = True + for cp in self.cut_list: + if cp[1] == self.CUT_TYPE_OUT: + if isin: + isin = False + ret = cp[0] + elif cp[1] == self.CUT_TYPE_IN: + isin = True + return ret + + def jumpPreviousNextMark(self, cmp, start=False): current_pos = self.cueGetCurrentPosition() if current_pos is None: - return - mark = self.getNearestCutPoint(current_pos, cmp=cmp) + return False + mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start) if mark is not None: pts = mark[0] - elif alternative is not None: - pts = alternative else: - return + return False - seekable = self.__getSeekable() - if seekable is not None: - seekable.seekTo(pts) + self.doSeek(pts) + return True def jumpPreviousMark(self): # we add 2 seconds, so if the play position is <2s after # the mark, the mark before will be used - self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0) + self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True) def jumpNextMark(self): - self.jumpPreviousNextMark(lambda x: x) + if not self.jumpPreviousNextMark(lambda x: x): + self.doSeek(-1) - def getNearestCutPoint(self, pts, cmp=abs): + def getNearestCutPoint(self, pts, cmp=abs, start=False): # can be optimized + beforecut = False nearest = None + if start: + beforecut = True + bestdiff = cmp(0 - pts) + if bestdiff >= 0: + nearest = [0, False] for cp in self.cut_list: - diff = cmp(cp[0] - pts) - if diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff): - nearest = cp + if beforecut and cp[1] in [self.CUT_TYPE_IN, self.CUT_TYPE_OUT]: + beforecut = False + if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks + diff = cmp(cp[0] - pts) + if diff >= 0: + nearest = cp + bestdiff = diff + else: + nearest = None + if cp[1] in [self.CUT_TYPE_MARK, self.CUT_TYPE_LAST]: + diff = cmp(cp[0] - pts) + if diff >= 0 and (nearest is None or bestdiff > diff): + nearest = cp + bestdiff = diff return nearest def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False): @@ -1672,9 +1975,9 @@ class InfoBarCueSheetSupport: if current_pos is None: print "not seekable" return - + nearest_cutpoint = self.getNearestCutPoint(current_pos) - + if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance: if onlyreturn: return nearest_cutpoint @@ -1682,17 +1985,23 @@ class InfoBarCueSheetSupport: self.removeMark(nearest_cutpoint) elif not onlyremove and not onlyreturn: self.addMark((current_pos, self.CUT_TYPE_MARK)) - + if onlyreturn: return None def addMark(self, point): - bisect.insort(self.cut_list, point) + insort(self.cut_list, point) self.uploadCuesheet() + self.showAfterCuesheetOperation() def removeMark(self, point): self.cut_list.remove(point) self.uploadCuesheet() + self.showAfterCuesheetOperation() + + def showAfterCuesheetOperation(self): + if isinstance(self, InfoBarShowHide): + self.doShow() def __getCuesheet(self): service = self.session.nav.getCurrentService() @@ -1712,40 +2021,79 @@ class InfoBarCueSheetSupport: cue = self.__getCuesheet() if cue is None: - print "upload failed, no cuesheet interface" - return - self.cut_list = cue.getCutList() + print "download failed, no cuesheet interface" + self.cut_list = [ ] + else: + self.cut_list = cue.getCutList() class InfoBarSummary(Screen): skin = """ - + WithSeconds - + + config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean + Blink + + Name + + Progress + """ +# for picon: (path="piconlcd" will use LCD picons) +# +# Reference +# + def __init__(self, session, parent): - Screen.__init__(self, session) - self["CurrentService"] = CurrentService(self.session.nav) - self["CurrentTime"] = Clock() + Screen.__init__(self, session, parent = parent) class InfoBarSummarySupport: def __init__(self): pass - + def createSummary(self): return InfoBarSummary +class InfoBarMoviePlayerSummary(Screen): + skin = """ + + + WithSeconds + + + config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean + Blink + + + Name + + + Position + + """ + + def __init__(self, session, parent): + Screen.__init__(self, session) + +class InfoBarMoviePlayerSummarySupport: + def __init__(self): + pass + + def createSummary(self): + return InfoBarMoviePlayerSummary + class InfoBarTeletextPlugin: def __init__(self): self.teletext_plugin = None - + for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT): self.teletext_plugin = p - + if self.teletext_plugin is not None: self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions", { @@ -1765,23 +2113,34 @@ class InfoBarSubtitleSupport(object): self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { - iPlayableService.evStart: self.__serviceStarted, + iPlayableService.evEnd: self.__serviceStopped, + iPlayableService.evUpdatedInfo: self.__updatedInfo }) + self.cached_subtitle_checked = False + self.__selected_subtitle = None - def __serviceStarted(self): - # reenable if it was enabled - r = self.__subtitles_enabled + def __serviceStopped(self): + self.subtitle_window.hide() self.__subtitles_enabled = False - self.__selected_subtitle = None - self.setSubtitlesEnable(r) + self.cached_subtitle_checked = False + + def __updatedInfo(self): + if not self.cached_subtitle_checked: + subtitle = self.getCurrentServiceSubtitle() + self.cached_subtitle_checked = True + self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle() + if self.__selected_subtitle: + subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle) + self.subtitle_window.show() + self.__subtitles_enabled = True def getCurrentServiceSubtitle(self): service = self.session.nav.getCurrentService() return service and service.subtitle() - + def setSubtitlesEnable(self, enable=True): subtitle = self.getCurrentServiceSubtitle() - if enable and self.__selected_subtitle: + if enable and self.__selected_subtitle is not None: if subtitle and not self.__subtitles_enabled: subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle) self.subtitle_window.show() @@ -1789,17 +2148,54 @@ class InfoBarSubtitleSupport(object): else: if subtitle: subtitle.disableSubtitles(self.subtitle_window.instance) - - self.subtitle_window.hide() self.__subtitles_enabled = False + self.subtitle_window.hide() def setSelectedSubtitle(self, subtitle): - if self.__selected_subtitle != subtitle and self.subtitles_enabled: - # kick - self.__selected_subtitle = subtitle - self.__serviceStarted() - else: - self.__selected_subtitle = subtitle + self.__selected_subtitle = subtitle subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable) selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle) + +class InfoBarServiceErrorPopupSupport: + def __init__(self): + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evTuneFailed: self.__tuneFailed, + iPlayableService.evStart: self.__serviceStarted + }) + self.__serviceStarted() + + def __serviceStarted(self): + self.last_error = None + Notifications.RemovePopup(id = "ZapError") + + def __tuneFailed(self): + service = self.session.nav.getCurrentService() + info = service and service.info() + error = info and info.getInfo(iServiceInformation.sDVBState) + + if error == self.last_error: + error = None + else: + self.last_error = error + + errors = { + eDVBServicePMTHandler.eventNoResources: _("No free tuner!"), + eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"), + eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"), + eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"), + eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"), + eDVBServicePMTHandler.eventNewProgramInfo: None, + eDVBServicePMTHandler.eventTuned: None, + eDVBServicePMTHandler.eventSOF: None, + eDVBServicePMTHandler.eventEOF: None, + eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"), + } + + error = errors.get(error) #this returns None when the key not exist in the dict + + if error is not None: + Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError") + else: + Notifications.RemovePopup(id = "ZapError")