X-Git-Url: http://code.vuplus.com/gitweb/?p=vuplus_dvbapp;a=blobdiff_plain;f=lib%2Fpython%2FScreens%2FInfoBarGenerics.py;h=e7f71daf7766c5ee1f572e5dea7e36e3e7ef9c0f;hp=06892a784882f967abb499e1c502f29696156250;hb=04f4636324ab06c5a3a4f618100048e159eaf6f9;hpb=3f80578e8b0c0ab98e1e84341c2a2325ea71b638
diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index 06892a7..e7f71da 100644
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -9,9 +9,9 @@ from Components.Label import Label
from Components.Pixmap import Pixmap
from Components.PluginComponent import plugins
from Components.ServiceEventTracker import ServiceEventTracker
-from Components.Sources.Source import ObsoleteSource
from Components.Sources.Boolean import Boolean
from Components.config import config, ConfigBoolean, ConfigClock
+from Components.SystemInfo import SystemInfo
from EpgSelection import EPGSelection
from Plugins.Plugin import PluginDescriptor
@@ -71,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)
@@ -171,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:
@@ -538,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"] = ObsoleteSource(new_source = "session.FrontendStatus", removal_date = "2008-01")
-
-class InfoBarEvent:
- """provides a current/next event info display"""
- def __init__(self):
- 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 InfoBarRdsDecoder:
"""provides RDS and Rass support/display"""
def __init__(self):
@@ -597,39 +586,14 @@ class InfoBarRdsDecoder:
self.RassSlidePicChanged()
self.rds_display.show()
-class InfoBarServiceName:
- def __init__(self):
- 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_16X = (0, 16, 0, ">> 16x")
- SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x")
- SEEK_STATE_FF_48X = (0, 48, 0, ">> 48x")
- SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x")
- SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x")
-
- SEEK_STATE_BACK_8X = (0, -8, 0, "<< 8x")
- SEEK_STATE_BACK_16X = (0, -16, 0, "<< 16x")
- SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x")
- SEEK_STATE_BACK_48X = (0, -48, 0, "<< 48x")
- 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"):
+ def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
@@ -638,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 = useSeekBackHack and 16 or 0
class InfoBarSeekActionMap(HelpableActionMap):
def __init__(self, screen, *args, **kwargs):
@@ -648,10 +619,15 @@ class InfoBarSeek:
print "action:", action
if action[:5] == "seek:":
time = int(action[5:])
- self.screen.seekRelative(time * 90000)
- if config.usage.show_infobar_on_skip.value:
- 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)
@@ -664,18 +640,14 @@ class InfoBarSeek:
"seekFwd": (self.seekFwd, _("skip forward")),
"seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
"seekBack": (self.seekBack, _("skip backward")),
- "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")),
-
- "seekFwdDef": (self.seekFwdDef, _("skip forward (self defined)")),
- "seekBackDef": (self.seekBackDef, _("skip backward (self defined)"))
+ "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.seek_flag = True
+ self.lastseekstate = self.SEEK_STATE_PLAY
self.onPlayStateChanged = [ ]
@@ -683,6 +655,53 @@ 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 self.minSpeedBackward and 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()
@@ -723,6 +742,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()
@@ -762,14 +784,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):
@@ -778,105 +802,112 @@ 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_16X,
- self.SEEK_STATE_FF_16X: self.SEEK_STATE_FF_32X,
- self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_48X,
- self.SEEK_STATE_FF_48X: 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_8X: self.SEEK_STATE_PLAY,
- self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_8X,
- self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X,
- self.SEEK_STATE_BACK_48X: self.SEEK_STATE_BACK_32X,
- self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_48X,
- 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_8X,
- 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_16X: self.SEEK_STATE_FF_8X,
- self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_16X,
- self.SEEK_STATE_FF_48X: self.SEEK_STATE_FF_32X,
- self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_48X,
- self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
- self.SEEK_STATE_BACK_8X: self.SEEK_STATE_BACK_16X,
- self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X,
- self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_48X,
- self.SEEK_STATE_BACK_48X: 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_8X,
- }
- self.setSeekState(lookup[self.seekstate])
-
- if self.seekstate == self.SEEK_STATE_PAUSE:
- seekable = self.getSeek()
- if seekable is not None:
- seekable.seekRelative(-1, 3)
-
- def seekFwdDef(self):
- self.seek_flag = False
- seconds = config.usage.self_defined_seek.value
- print "Seek", seconds, "seconds self defined forward"
- seekable = self.getSeek()
- if seekable is not None:
- seekable.seekRelative(1, seconds * 90000)
-
- def seekBackDef(self):
- self.seek_flag = False
- seconds = config.usage.self_defined_seek.value
- print "Seek", seconds, "seconds self defined backward"
- seekable = self.getSeek()
- if seekable is not None:
- seekable.seekRelative(1, 0 - seconds * 90000)
+ 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
@@ -890,50 +921,75 @@ 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]:
- self.setSeekState(self.SEEK_STATE_EOF)
- self.seekRelativeToEnd(-90000)
- else:
+ eofstate = self.eofState
+ seekstate = self.seekstate
+ self.eofState = 0
+ if not self.seekstate == self.SEEK_STATE_PAUSE:
self.setSeekState(self.SEEK_STATE_EOF)
-
- def __evSOF(self):
- self.setSeekState(self.SEEK_STATE_PLAY)
- self.doSeek(0)
-
- def seekRelative(self, diff):
- if self.seek_flag == True:
+ if eofstate == -1 or not seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
seekable = self.getSeek()
if seekable is not None:
- print "seekRelative: res:", seekable.seekRelative(1, diff)
- else:
- print "seek failed!"
+ seekable.seekTo(-1)
+ if eofstate == 1 and seekstate == self.SEEK_STATE_PLAY:
+ self.doEofInternal(True)
else:
- self.seek_flag = True
+ self.doEofInternal(False)
- def seekRelativeToEnd(self, diff):
- assert diff <= 0, "diff is expected to be negative!"
+ def doEofInternal(self, playing):
+ pass # Defined in subclasses
- # 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)
+ def __evSOF(self):
+ self.setSeekState(self.SEEK_STATE_PLAY)
+ self.doSeek(0)
from Screens.PVRState import PVRState, TimeshiftState
@@ -1018,7 +1074,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=
{
@@ -1095,13 +1151,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):
@@ -1221,10 +1279,7 @@ class InfoBarPlugins:
# depends on InfoBarExtensions
class InfoBarSleepTimer:
def __init__(self):
- self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
-
- def available(self):
- return True
+ self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, lambda: True), "1")
def getSleepTimerName(self):
return _("Sleep Timer")
@@ -1236,13 +1291,10 @@ 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")
-
- def available(self):
- return True
+ if SystemInfo.get("NumVideoDecoders", 1) > 1:
+ self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
+ self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
+ self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
def pipShown(self):
return self.session.pipshown
@@ -1304,7 +1356,7 @@ class InfoBarPiP:
elif "stop" == use:
self.showPiP()
-from RecordTimer import parseEvent
+from RecordTimer import parseEvent, RecordTimerEntry
class InfoBarInstantRecord:
"""Instant Record - handles the instantRecord action in order to
@@ -1315,10 +1367,6 @@ class InfoBarInstantRecord:
"instantRecord": (self.instantRecord, _("Instant Record...")),
})
self.recording = []
-#### DEPRECATED CODE ####
- self["BlinkingPoint"] = BlinkingPixmapConditional()
- self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
-#########################
def stopCurrentRecording(self, entry = -1):
if entry is not None and entry != -1:
@@ -1358,15 +1406,15 @@ class InfoBarInstantRecord:
if limitEvent:
self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
- data = (begin, end, name, description, eventid)
+ # TODO: needed?
+ if isinstance(serviceref, eServiceReference):
+ serviceref = ServiceReference(serviceref)
- recording = self.session.nav.recordWithTimer(serviceref, *data)
+ recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
recording.dontSave = True
- self.recording.append(recording)
-#### DEPRECATED CODE ####
- self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
-#########################
+ self.session.nav.RecordTimer.record(recording)
+ self.recording.append(recording)
def isInstantRecordRunning(self):
print "self.recording:", self.recording
@@ -1398,7 +1446,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)
@@ -1476,10 +1524,8 @@ class InfoBarAudioSelection:
def audioSelection(self):
service = self.session.nav.getCurrentService()
- audio = service and service.audioTracks()
- self.audioTracks = audio
+ self.audioTracks = audio = service and service.audioTracks()
n = audio and audio.getNumberOfTracks() or 0
- keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
tlist = []
if n > 0:
self.audioChannel = service.audioChannel()
@@ -1499,21 +1545,45 @@ class InfoBarAudioSelection:
tlist.append((description, x))
- selectedAudio = audio.getCurrentTrack()
tlist.sort(key=lambda x: x[0])
- selection = 2
+ selectedAudio = self.audioTracks.getCurrentTrack()
+
+ selection = 0
+
for x in tlist:
if x[1] != selectedAudio:
selection += 1
else:
break
- tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
+ if SystemInfo["CanDownmixAC3"]:
+ tlist = [(_("AC3 downmix") + " - " +[_("Off"), _("On")][config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
+ ([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"),
+ ("--", "")] + tlist
+ keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+ selection += 3
+ else:
+ tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
+ keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+ selection += 2
self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
else:
del self.audioTracks
+ def changeAC3Downmix(self, arg):
+ choicelist = self.session.current_dialog["list"]
+ list = choicelist.list
+ t = list[0][1]
+ list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
+ _("AC3 downmix") + " - " +[_("On"), _("Off")][config.av.downmix_ac3.value and 1 or 0])
+ choicelist.setList(list)
+ if config.av.downmix_ac3.value:
+ config.av.downmix_ac3.value = False
+ else:
+ config.av.downmix_ac3.value = True
+ config.av.downmix_ac3.save()
+
def audioSelected(self, audio):
if audio is not None:
if isinstance(audio[1], str):
@@ -1586,7 +1656,7 @@ class InfoBarSubserviceSelection:
if newservice.valid():
del subservices
del service
- self.session.nav.playService(newservice)
+ self.session.nav.playService(newservice, False)
def subserviceSelection(self):
service = self.session.nav.getCurrentService()
@@ -1604,7 +1674,7 @@ class InfoBarSubserviceSelection:
tlist.append((i.getName(), i))
if self.bouquets and len(self.bouquets):
- keys = ["red", "green", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+ keys = ["red", "blue", "", "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:
@@ -1626,7 +1696,7 @@ class InfoBarSubserviceSelection:
self.session.open(SubservicesQuickzap, service[2])
else:
self["SubserviceQuickzapAction"].setEnabled(True)
- self.session.nav.playService(service[1])
+ self.session.nav.playService(service[1], False)
def addSubserviceToBouquetCallback(self, service):
if len(service) > 1 and isinstance(service[1], eServiceReference):
@@ -1661,47 +1731,6 @@ class InfoBarAdditionalInfo:
self["TimeshiftPossible"] = self["RecordingPossible"]
self["ExtensionsAvailable"] = Boolean(fixed=1)
-######### DEPRECATED CODE ##########
- self["NimA"] = Pixmap()
- self["NimB"] = Pixmap()
- self["NimA_Active"] = Pixmap()
- self["NimB_Active"] = Pixmap()
-
- 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
-
- 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)
@@ -1792,13 +1821,21 @@ 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):
@@ -1820,37 +1857,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):
@@ -1915,6 +1979,10 @@ class InfoBarSummary(Screen):
WithSeconds
+
+ config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean
+ Blink
+
Name
@@ -1929,7 +1997,7 @@ class InfoBarSummary(Screen):
#
def __init__(self, session, parent):
- Screen.__init__(self, session)
+ Screen.__init__(self, session, parent = parent)
class InfoBarSummarySupport:
def __init__(self):
@@ -1944,6 +2012,10 @@ class InfoBarMoviePlayerSummary(Screen):
WithSeconds
+
+ config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean
+ Blink
+
Name
@@ -2064,7 +2136,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