X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/2080cf6c4aa2d89b1f08c28968724be5dc71cf09..e65ec4c939982c4dc7d257f6adfd1b8ab87e1179:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index 9fd676e9..b0572979 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -5,18 +5,13 @@ 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.FrontendStatus import FrontendStatus from Components.Sources.Boolean import Boolean -from Components.Sources.Clock import Clock -from Components.TimerList import TimerEntryComponent from Components.config import config, ConfigBoolean, ConfigClock +from Components.SystemInfo import SystemInfo from EpgSelection import EPGSelection from Plugins.Plugin import PluginDescriptor @@ -51,7 +46,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 @@ -77,7 +71,7 @@ class InfoBarShowHide: self.__locked = 0 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) @@ -160,7 +154,7 @@ class NumberZap(Screen): self["number"] = Label(self.field) - self["actions"] = NumberActionMap( [ "SetupActions" ], + self["actions"] = NumberActionMap( [ "SetupActions" ], { "cancel": self.quit, "ok": self.keyOK, @@ -177,7 +171,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: @@ -200,9 +194,13 @@ class InfoBarNumberZap: def keyNumberGlobal(self, number): # print "You pressed number " + str(number) if number == 0: - self.servicelist.recallPrevService() + 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 @@ -250,7 +248,7 @@ 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 @@ -342,7 +340,7 @@ class InfoBarChannelSelection: 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...")), }) @@ -403,11 +401,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? @@ -475,7 +482,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): @@ -531,17 +538,6 @@ class InfoBarEPG: self.epglist[1]=tmp setEvent(self.epglist[0]) -class InfoBarTuner: - """provides a snr/agc/ber display""" - def __init__(self): - self["FrontendStatus"] = FrontendStatus(service_source = self.session.nav.getCurrentService) - -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) - class InfoBarRdsDecoder: """provides RDS and Rass support/display""" def __init__(self): @@ -590,32 +586,11 @@ class InfoBarRdsDecoder: self.RassSlidePicChanged() self.rds_display.show() -class InfoBarServiceName: - def __init__(self): - self["CurrentService"] = CurrentService(self.session.nav) - 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") - SEEK_STATE_EOF = (1, 0, 0, "END") def __init__(self, actionmap = "InfobarSeekActions"): @@ -627,6 +602,13 @@ class InfoBarSeek: 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): @@ -637,28 +619,35 @@ class InfoBarSeek: print "action:", action if action[:5] == "seek:": time = int(action[5:]) - self.screen.seekRelative(time * 90000) - self.screen.showAfterSeek() + 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, actionmap, + self["SeekActions"] = InfoBarSeekActionMap(self, actionmap, { - "playpauseService": (self.playpauseService, _("pause")), + "playpauseService": self.playpauseService, "pauseService": (self.pauseService, _("pause")), "unPauseService": (self.unPauseService, _("continue")), "seekFwd": (self.seekFwd, _("skip forward")), "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")), "seekBack": (self.seekBack, _("skip backward")), - "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")), + "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.lastseekstate = self.SEEK_STATE_PLAY self.onPlayStateChanged = [ ] @@ -666,6 +655,54 @@ class InfoBarSeek: 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) +# el + 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 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() @@ -706,6 +743,9 @@ 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() @@ -745,14 +785,16 @@ class InfoBarSeek: 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): @@ -761,86 +803,117 @@ class InfoBarSeek: return 0 self.setSeekState(self.SEEK_STATE_PLAY) - def doSeek(self, seektime): - print "doseek", seektime - service = self.session.nav.getCurrentService() - if service is None: + def doSeek(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.seekTo(pts) + def doSeekRelative(self, pts): seekable = self.getSeek() if seekable is None: return - - seekable.seekTo(90 * seektime) + 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.SEEK_STATE_EOF: self.SEEK_STATE_EOF, - } - self.setSeekState(lookup[self.seekstate]) + 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 len(config.seek.speeds_slowmotion.value): + 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.SEEK_STATE_EOF: self.SEEK_STATE_BACK_16X, - } - 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 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) + 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 config.usage.show_infobar_on_zap.value: + if config.usage.show_infobar_on_skip.value: if self.lockedBecauseOfSkipping and not wantlock: self.unlockShow() self.lockedBecauseOfSkipping = False @@ -849,48 +922,76 @@ class InfoBarSeek: 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.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.seekstate[1] < 0: # SEEK_STATE_BACK_*X - print "end of stream while seeking back, ignoring." + 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. - if not self.seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]: + eofstate = self.eofState + seekstate = self.seekstate + self.eofState = 0 + if not self.seekstate == self.SEEK_STATE_PAUSE: self.setSeekState(self.SEEK_STATE_EOF) - self.seekRelativeToEnd(-90000) + 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_EOF) + 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: - print "seekRelative: res:", seekable.seekRelative(1, diff) - else: - print "seek failed!" - - def seekRelativeToEnd(self, diff): - assert diff <= 0, "diff is expected to be negative!" - - # might sound like an evil hack, but: - # if we seekRelativeToEnd(0), we expect to be at the end, which is what we want, - # and we don't get that by passing 0 here (it would seek to begin). - if diff == 0: - diff = -1 - - # relative-to-end seeking is implemented as absolutes seeks with negative time - self.seekAbsolute(diff) - - def seekAbsolute(self, abs): - seekable = self.getSeek() - if seekable is not None: - seekable.seekTo(abs) - from Screens.PVRState import PVRState, TimeshiftState class InfoBarPVRState: @@ -919,11 +1020,11 @@ class InfoBarTimeshiftState(InfoBarPVRState): 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")), @@ -960,7 +1061,7 @@ 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' @@ -974,7 +1075,7 @@ class InfoBarTimeshift: self.timeshift_enabled = 0 self.timeshift_state = 0 self.ts_rewind_timer = eTimer() - self.ts_rewind_timer.timeout.get().append(self.rewindService) + self.ts_rewind_timer.callback.append(self.rewindService) self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { @@ -1051,13 +1152,15 @@ class InfoBarTimeshift: print "play, ..." ts.activateTimeshift() # activate timeshift will automatically pause self.setSeekState(self.SEEK_STATE_PAUSE) - self.seekRelativeToEnd(-90000) # seek approx. 1 sec before end 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.SEEK_STATE_BACK_16X) + self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value))) # same as activateTimeshiftEnd, but pauses afterwards. def activateTimeshiftEndAndPause(self): @@ -1172,7 +1275,7 @@ class InfoBarPlugins: return list def runPlugin(self, plugin): - plugin(session = self.session) + plugin(session = self.session, servicelist = self.servicelist) # depends on InfoBarExtensions class InfoBarSleepTimer: @@ -1192,17 +1295,20 @@ class InfoBarSleepTimer: class InfoBarPiP: def __init__(self): self.session.pipshown = False - - 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") + 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") @@ -1221,6 +1327,7 @@ class InfoBarPiP: 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 @@ -1246,10 +1353,20 @@ class InfoBarPiP: 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", @@ -1257,9 +1374,6 @@ class InfoBarInstantRecord: "instantRecord": (self.instantRecord, _("Instant Record...")), }) self.recording = [] - self["BlinkingPoint"] = BlinkingPixmapConditional() - self["BlinkingPoint"].hide() - self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording) def stopCurrentRecording(self, entry = -1): if entry is not None and entry != -1: @@ -1305,8 +1419,6 @@ class InfoBarInstantRecord: recording.dontSave = True self.recording.append(recording) - #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning()) - def isInstantRecordRunning(self): print "self.recording:", self.recording if len(self.recording) > 0: @@ -1326,7 +1438,7 @@ 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: @@ -1337,7 +1449,7 @@ class InfoBarInstantRecord: if len(self.recording) == 1: self.setEndtime(0) else: - self.session.openWithCallback(self.setEndTime, TimerSelection, list) + self.session.openWithCallback(self.setEndtime, TimerSelection, list) elif answer[1] == "stop": if len(self.recording) == 1: self.stopCurrentRecording(0) @@ -1408,7 +1520,7 @@ 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...")), }) @@ -1420,7 +1532,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() @@ -1439,8 +1550,8 @@ class InfoBarAudioSelection: 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: @@ -1596,48 +1707,11 @@ class InfoBarSubserviceSelection: class InfoBarAdditionalInfo: def __init__(self): - self["NimA"] = Pixmap() - self["NimB"] = Pixmap() - self["NimA_Active"] = Pixmap() - self["NimB_Active"] = Pixmap() self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0) self["TimeshiftPossible"] = self["RecordingPossible"] self["ExtensionsAvailable"] = Boolean(fixed=1) - self.session.nav.event.append(self.gotServiceEvent) # we like to get service events - res_mgr = eDVBResourceManager.getInstance() - if res_mgr: - res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged) - - def tunerUseMaskChanged(self, mask): - if mask&1: - self["NimA_Active"].show() - else: - self["NimA_Active"].hide() - if mask&2: - self["NimB_Active"].show() - else: - self["NimB_Active"].hide() - - def checkTunerState(self, service): - info = service and service.frontendInfo() - feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber) - if feNumber is None: - self["NimA"].hide() - self["NimB"].hide() - elif feNumber == 0: - self["NimB"].hide() - self["NimA"].show() - elif feNumber == 1: - self["NimA"].hide() - self["NimB"].show() - - def gotServiceEvent(self, ev): - service = self.session.nav.getCurrentService() - if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd: - self.checkTunerState(service) - class InfoBarNotifications: def __init__(self): self.onExecBegin.append(self.checkNotifications) @@ -1698,13 +1772,13 @@ class InfoBarCueSheetSupport: 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")), + "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) + }, prio=1) self.cut_list = [ ] self.is_closing = False @@ -1728,13 +1802,26 @@ class InfoBarCueSheetSupport: 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": +# TRANSLATORS: The string "Resuming playback" flashes for a moment +# TRANSLATORS: at the start of a movie, when the user has selected +# TRANSLATORS: "Resume from last position" as start behavior. +# TRANSLATORS: The purpose is to notify the user that the movie starts +# TRANSLATORS: in the middle somewhere and not from the beginning. +# TRANSLATORS: (Some translators seem to have interpreted it as a +# TRANSLATORS: question or a choice, but it is a statement.) + 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() @@ -1751,37 +1838,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 cp[1] == self.CUT_TYPE_MARK and 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): @@ -1806,10 +1920,16 @@ class InfoBarCueSheetSupport: def addMark(self, 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() @@ -1829,25 +1949,36 @@ 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): @@ -1856,6 +1987,34 @@ class InfoBarSummarySupport: 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 @@ -1958,7 +2117,8 @@ class InfoBarServiceErrorPopupSupport: eDVBServicePMTHandler.eventNewProgramInfo: None, eDVBServicePMTHandler.eventTuned: None, eDVBServicePMTHandler.eventSOF: None, - eDVBServicePMTHandler.eventEOF: 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