update .meta description

[enigma2.git] / lib / python / Screens / InfoBarGenerics.py

diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index 28e619fd75de525b5b66ae57abd575fcf3a1192a..3f9fe213734e25cb1321683824ff7188feffebfb 100644 (file)
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -2,16 +2,14 @@ from ChannelSelection import ChannelSelection, BouquetSelector
 
 from Components.ActionMap import ActionMap, HelpableActionMap
 from Components.ActionMap import NumberActionMap
 
 from Components.ActionMap import ActionMap, HelpableActionMap
 from Components.ActionMap import NumberActionMap

-from Components.BlinkingPixmap import BlinkingPixmapConditional

 from Components.Harddisk import harddiskmanager
 from Components.Input import Input
 from Components.Label import Label
 from Components.Harddisk import harddiskmanager
 from Components.Input import Input
 from Components.Label import Label

-from Components.Pixmap import Pixmap

 from Components.PluginComponent import plugins
 from Components.ServiceEventTracker import ServiceEventTracker
 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.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
 
 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
 


@@ -31,15 +29,17 @@ from Screens.TimeDateInput import TimeDateInput
 from ServiceReference import ServiceReference
 
 from Tools import Notifications
 from ServiceReference import ServiceReference
 
 from Tools import Notifications

-from Tools.Directories import SCOPE_HDD, resolveFilename
+from Tools.Directories import SCOPE_HDD, resolveFilename, fileExists

 
 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
 
 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \

-       iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
+       iPlayableService, eServiceReference, eEPGCache

 
 from time import time, localtime, strftime
 from os import stat as os_stat
 from bisect import insort
 
 
 from time import time, localtime, strftime
 from os import stat as os_stat
 from bisect import insort
 

+from RecordTimer import RecordTimerEntry, RecordTimer
+

 # hack alert!
 from Menu import MainMenu, mdom
 
 # hack alert!
 from Menu import MainMenu, mdom
 


@@ -71,7 +71,7 @@ class InfoBarShowHide:
                self.__locked = 0
 
                self.hideTimer = eTimer()
                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)
                self.hideTimer.start(5000, True)
 
                self.onShow.append(self.__onShow)


@@ -171,7 +171,7 @@ class NumberZap(Screen):
                        })
 
                self.Timer = eTimer()
                        })
 
                self.Timer = eTimer()

-               self.Timer.timeout.get().append(self.keyOK)
+               self.Timer.callback.append(self.keyOK)

                self.Timer.start(3000, True)
 
 class InfoBarNumberZap:
                self.Timer.start(3000, True)
 
 class InfoBarNumberZap:


@@ -348,14 +348,14 @@ class InfoBarMenu:
 
        def mainMenu(self):
                print "loading mainmenu XML..."
 
        def mainMenu(self):
                print "loading mainmenu XML..."

-               menu = mdom.childNodes[0]
-               assert menu.tagName == "menu", "root element in menu must be 'menu'!"
+               menu = mdom.getroot()
+               assert menu.tag == "menu", "root element in menu must be 'menu'!"

 
                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.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)
+               self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)

 
        def mainMenuClosed(self, *val):
                self.session.infobar = None
 
        def mainMenuClosed(self, *val):
                self.session.infobar = None


@@ -404,7 +404,7 @@ class InfoBarEPG:
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),

-                               "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
+                               "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),

                                "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
                        })
 
                                "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
                        })
 


@@ -489,42 +489,60 @@ class InfoBarEPG:
                ref=self.session.nav.getCurrentlyPlayingServiceReference()
                self.session.open(EPGSelection, ref)
 
                ref=self.session.nav.getCurrentlyPlayingServiceReference()
                self.session.open(EPGSelection, ref)
 

+       def showEventInfoPlugins(self):
+               list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
+
+               if list:
+                       list.append((_("show single service EPG..."), self.openSingleServiceEPG))
+                       self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list)
+               else:
+                       self.openSingleServiceEPG()
+                       
+       def runPlugin(self, plugin):
+               plugin(session = self.session, servicelist = self.servicelist)
+               
+       def EventInfoPluginChosen(self, answer):
+               if answer is not None:
+                       answer[1]()
+

        def openSimilarList(self, eventid, refstr):
                self.session.open(EPGSelection, refstr, None, eventid)
 
        def getNowNext(self):
        def openSimilarList(self, eventid, refstr):
                self.session.open(EPGSelection, refstr, None, eventid)
 
        def getNowNext(self):

-               self.epglist = [ ]
+               epglist = [ ]

                service = self.session.nav.getCurrentService()
                info = service and service.info()
                ptr = info and info.getEvent(0)
                if ptr:
                service = self.session.nav.getCurrentService()
                info = service and service.info()
                ptr = info and info.getEvent(0)
                if ptr:

-                       self.epglist.append(ptr)
+                       epglist.append(ptr)

                ptr = info and info.getEvent(1)
                if ptr:
                ptr = info and info.getEvent(1)
                if ptr:

-                       self.epglist.append(ptr)
+                       epglist.append(ptr)
+               self.epglist = epglist

 
        def __evEventInfoChanged(self):
                if self.is_now_next and len(self.dlg_stack) == 1:
                        self.getNowNext()
                        assert self.eventView
 
        def __evEventInfoChanged(self):
                if self.is_now_next and len(self.dlg_stack) == 1:
                        self.getNowNext()
                        assert self.eventView

-                       if len(self.epglist):
+                       if self.epglist:

                                self.eventView.setEvent(self.epglist[0])
 
        def openEventView(self):
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
                self.getNowNext()
                                self.eventView.setEvent(self.epglist[0])
 
        def openEventView(self):
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
                self.getNowNext()

-               if len(self.epglist) == 0:
+               epglist = self.epglist
+               if not epglist:

                        self.is_now_next = False
                        epg = eEPGCache.getInstance()
                        ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
                        if ptr:
                        self.is_now_next = False
                        epg = eEPGCache.getInstance()
                        ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
                        if ptr:

-                               self.epglist.append(ptr)
+                               epglist.append(ptr)

                                ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
                                if ptr:
                                ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
                                if ptr:

-                                       self.epglist.append(ptr)
+                                       epglist.append(ptr)

                else:
                        self.is_now_next = True
                else:
                        self.is_now_next = True

-               if len(self.epglist) > 0:
+               if epglist:

                        self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
                        self.dlg_stack.append(self.eventView)
                else:
                        self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
                        self.dlg_stack.append(self.eventView)
                else:


@@ -532,22 +550,12 @@ class InfoBarEPG:
                        self.openMultiServiceEPG(False)
 
        def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
                        self.openMultiServiceEPG(False)
 
        def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying

-               if len(self.epglist) > 1:
-                       tmp = self.epglist[0]
-                       self.epglist[0]=self.epglist[1]
-                       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")
+               epglist = self.epglist
+               if len(epglist) > 1:
+                       tmp = epglist[0]
+                       epglist[0]=epglist[1]
+                       epglist[1]=tmp
+                       setEvent(epglist[0])

 
 class InfoBarRdsDecoder:
        """provides RDS and Rass support/display"""
 
 class InfoBarRdsDecoder:
        """provides RDS and Rass support/display"""


@@ -597,39 +605,14 @@ class InfoBarRdsDecoder:
                        self.RassSlidePicChanged()
                self.rds_display.show()
 
                        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"""
 
 class InfoBarSeek:
        """handles actions like seeking, pause"""
 

-       # ispause, isff, issm

        SEEK_STATE_PLAY = (0, 0, 0, ">")
        SEEK_STATE_PAUSE = (1, 0, 0, "||")
        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")
 
        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,
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,


@@ -638,6 +621,13 @@ class InfoBarSeek:
                                iPlayableService.evEOF: self.__evEOF,
                                iPlayableService.evSOF: self.__evSOF,
                        })
                                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):
 
                class InfoBarSeekActionMap(HelpableActionMap):
                        def __init__(self, screen, *args, **kwargs):


@@ -648,10 +638,15 @@ class InfoBarSeek:
                                print "action:", action
                                if action[:5] == "seek:":
                                        time = int(action[5:])
                                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
                                        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)
 
                                else:
                                        return HelpableActionMap.action(self, contexts, action)
 


@@ -664,18 +659,14 @@ class InfoBarSeek:
                                "seekFwd": (self.seekFwd, _("skip forward")),
                                "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
                                "seekBack": (self.seekBack, _("skip backward")),
                                "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
                        }, 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 = [ ]
 
 
                self.onPlayStateChanged = [ ]
 


@@ -683,6 +674,53 @@ class InfoBarSeek:
 
                self.__seekableStatusChanged()
 
 
                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()
        def showAfterSeek(self):
                if isinstance(self, InfoBarShowHide):
                        self.doShow()


@@ -711,18 +749,21 @@ class InfoBarSeek:
                return True
 
        def __seekableStatusChanged(self):
                return True
 
        def __seekableStatusChanged(self):

-               print "seekable status changed!"
+#              print "seekable status changed!"

                if not self.isSeekable():
                        self["SeekActions"].setEnabled(False)
                if not self.isSeekable():
                        self["SeekActions"].setEnabled(False)

-                       print "not seekable, return to play"
+#                      print "not seekable, return to play"

                        self.setSeekState(self.SEEK_STATE_PLAY)
                else:
                        self["SeekActions"].setEnabled(True)
                        self.setSeekState(self.SEEK_STATE_PLAY)
                else:
                        self["SeekActions"].setEnabled(True)

-                       print "seekable"
+#                      print "seekable"

 
        def __serviceStarted(self):
                self.seekstate = self.SEEK_STATE_PLAY
                self.__seekableStatusChanged()
 
        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()
 
        def setSeekState(self, state):
                service = self.session.nav.getCurrentService()


@@ -743,7 +784,7 @@ class InfoBarSeek:
                oldstate = self.seekstate
                self.seekstate = state
 
                oldstate = self.seekstate
                self.seekstate = state
 

-               for i in range(3):
+               for i in (0, 1, 2):

                        if oldstate[i] != self.seekstate[i]:
                                (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
 
                        if oldstate[i] != self.seekstate[i]:
                                (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
 


@@ -762,14 +803,16 @@ class InfoBarSeek:
 
        def pauseService(self):
                if self.seekstate == self.SEEK_STATE_PAUSE:
 
        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:
                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):
                        self.setSeekState(self.SEEK_STATE_PAUSE);
 
        def unPauseService(self):


@@ -778,105 +821,112 @@ class InfoBarSeek:
                        return 0
                self.setSeekState(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:
+       def doSeek(self, pts):
+               seekable = self.getSeek()
+               if seekable is None:

                        return
                        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 = 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):
 
        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):
 
        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"
 
        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"
 
        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
 
        def checkSkipShowHideLock(self):
                wantlock = self.seekstate != self.SEEK_STATE_PLAY


@@ -890,59 +940,85 @@ class InfoBarSeek:
                                self.lockShow()
                                self.lockedBecauseOfSkipping = True
 
                                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):
        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 == 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.
                        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.setSeekState(self.SEEK_STATE_EOF)

-                       self.seekRelativeToEnd(-90000)
-               else:
-                       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:
                        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:
                else:

-                       self.seek_flag = True
-
-       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
+                       self.doEofInternal(False)

 
 

-               # relative-to-end seeking is implemented as absolutes seeks with negative time
-               self.seekAbsolute(diff)
+       def doEofInternal(self, playing):
+               pass            # Defined in subclasses

 
 

-       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
 
 class InfoBarPVRState:
 
 from Screens.PVRState import PVRState, TimeshiftState
 
 class InfoBarPVRState:

-       def __init__(self, screen=PVRState):
+       def __init__(self, screen=PVRState, force_show = False):

                self.onPlayStateChanged.append(self.__playStateChanged)
                self.pvrStateDialog = self.session.instantiateDialog(screen)
                self.onShow.append(self._mayShow)
                self.onHide.append(self.pvrStateDialog.hide)
                self.onPlayStateChanged.append(self.__playStateChanged)
                self.pvrStateDialog = self.session.instantiateDialog(screen)
                self.onShow.append(self._mayShow)
                self.onHide.append(self.pvrStateDialog.hide)

+               self.force_show = force_show

 
        def _mayShow(self):
                if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
 
        def _mayShow(self):
                if self.execing and self.seekstate != self.SEEK_STATE_PLAY:


@@ -951,14 +1027,20 @@ class InfoBarPVRState:
        def __playStateChanged(self, state):
                playstateString = state[3]
                self.pvrStateDialog["state"].setText(playstateString)
        def __playStateChanged(self, state):
                playstateString = state[3]
                self.pvrStateDialog["state"].setText(playstateString)

-               self._mayShow()
+               
+               # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
+               if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
+                       self.pvrStateDialog.hide()
+               else:
+                       self._mayShow()
+                       

 
 class InfoBarTimeshiftState(InfoBarPVRState):
        def __init__(self):
 
 class InfoBarTimeshiftState(InfoBarPVRState):
        def __init__(self):

-               InfoBarPVRState.__init__(self, screen=TimeshiftState)
+               InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)

 
        def _mayShow(self):
 
        def _mayShow(self):

-               if self.execing and self.timeshift_enabled:
+               if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:

                        self.pvrStateDialog.show()
 
 class InfoBarShowMovies:
                        self.pvrStateDialog.show()
 
 class InfoBarShowMovies:


@@ -1018,7 +1100,7 @@ class InfoBarTimeshift:
                self.timeshift_enabled = 0
                self.timeshift_state = 0
                self.ts_rewind_timer = eTimer()
                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=
                        {
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {


@@ -1095,13 +1177,15 @@ class InfoBarTimeshift:
                        print "play, ..."
                        ts.activateTimeshift() # activate timeshift will automatically pause
                        self.setSeekState(self.SEEK_STATE_PAUSE)
                        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:
 
                if back:

+                       self.doSeek(-5) # seek some gops before end

                        self.ts_rewind_timer.start(200, 1)
                        self.ts_rewind_timer.start(200, 1)

+               else:
+                       self.doSeek(-1) # seek 1 gop before end

 
        def rewindService(self):
 
        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):
 
        # same as activateTimeshiftEnd, but pauses afterwards.
        def activateTimeshiftEndAndPause(self):


@@ -1112,8 +1196,8 @@ class InfoBarTimeshift:
        def __seekableStatusChanged(self):
                enabled = False
 
        def __seekableStatusChanged(self):
                enabled = False
 

-               print "self.isSeekable", self.isSeekable()
-               print "self.timeshift_enabled", self.timeshift_enabled
+#              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
 
                # when this service is not seekable, but timeshift
                # is enabled, this means we can activate


@@ -1121,7 +1205,7 @@ class InfoBarTimeshift:
                if not self.isSeekable() and self.timeshift_enabled:
                        enabled = True
 
                if not self.isSeekable() and self.timeshift_enabled:
                        enabled = True
 

-               print "timeshift activate:", enabled
+#              print "timeshift activate:", enabled

                self["TimeshiftActivateActions"].setEnabled(enabled)
 
        def __serviceStarted(self):
                self["TimeshiftActivateActions"].setEnabled(enabled)
 
        def __serviceStarted(self):


@@ -1140,7 +1224,7 @@ class InfoBarExtensions:
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                                "extensions": (self.showExtensionSelection, _("view extensions...")),
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                                "extensions": (self.showExtensionSelection, _("view extensions...")),

-                       })
+                       }, 1) # lower priority

 
        def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
                self.list.append((type, extension, key))
 
        def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
                self.list.append((type, extension, key))


@@ -1188,8 +1272,8 @@ class InfoBarExtensions:
                                        extensionsList.remove(extension)
                                else:
                                        extensionsList.remove(extension)
                                        extensionsList.remove(extension)
                                else:
                                        extensionsList.remove(extension)

-               for x in extensionsList:
-                       list.append((x[0](), x))
+               list.extend([(x[0](), x) for x in extensionsList])
+

                keys += [""] * len(extensionsList)
                self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
 
                keys += [""] * len(extensionsList)
                self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
 


@@ -1200,7 +1284,6 @@ class InfoBarExtensions:
 from Tools.BoundFunction import boundFunction
 
 # depends on InfoBarExtensions
 from Tools.BoundFunction import boundFunction
 
 # depends on InfoBarExtensions

-from Components.PluginComponent import plugins

 
 class InfoBarPlugins:
        def __init__(self):
 
 class InfoBarPlugins:
        def __init__(self):


@@ -1210,21 +1293,37 @@ class InfoBarPlugins:
                return name
 
        def getPluginList(self):
                return name
 
        def getPluginList(self):

-               list = []
-               for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
-                       list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
-               return list
+               return [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]

 
        def runPlugin(self, plugin):
 
        def runPlugin(self, plugin):

-               plugin(session = self.session, servicelist = self.servicelist)
+               if isinstance(self, InfoBarChannelSelection):
+                       plugin(session = self.session, servicelist = self.servicelist)
+               else:
+                       plugin(session = self.session)
+
+from Components.Task import job_manager
+class InfoBarJobman:
+       def __init__(self):
+               self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
+
+       def getJobList(self):
+               return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
+
+       def getJobName(self, job):
+               return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
+
+       def showJobView(self, job):
+               from Screens.TaskView import JobView
+               job_manager.in_background = False
+               self.session.openWithCallback(self.JobViewCB, JobView, job)
+       
+       def JobViewCB(self, in_background):
+               job_manager.in_background = in_background

 
 # depends on InfoBarExtensions
 class InfoBarSleepTimer:
        def __init__(self):
 
 # 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")
 
        def getSleepTimerName(self):
                return _("Sleep Timer")


@@ -1236,13 +1335,10 @@ class InfoBarSleepTimer:
 class InfoBarPiP:
        def __init__(self):
                self.session.pipshown = False
 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
 
        def pipShown(self):
                return self.session.pipshown


@@ -1304,7 +1400,7 @@ class InfoBarPiP:
                elif "stop" == use:
                        self.showPiP()
 
                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
 
 class InfoBarInstantRecord:
        """Instant Record - handles the instantRecord action in order to


@@ -1315,13 +1411,6 @@ class InfoBarInstantRecord:
                                "instantRecord": (self.instantRecord, _("Instant Record...")),
                        })
                self.recording = []
                                "instantRecord": (self.instantRecord, _("Instant Record...")),
                        })
                self.recording = []

-#### DEPRECATED CODE ####
-               self["BlinkingPoint"] = BlinkingPixmapConditional()
-               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):
                if entry is not None and entry != -1:
 
        def stopCurrentRecording(self, entry = -1):
                if entry is not None and entry != -1:


@@ -1344,8 +1433,8 @@ class InfoBarInstantRecord:
                except:
                        pass
 
                except:
                        pass
 

-               begin = time()
-               end = time() + 3600 * 10
+               begin = int(time())
+               end = begin + 3600      # dummy

                name = "instant record"
                description = ""
                eventid = None
                name = "instant record"
                description = ""
                eventid = None


@@ -1361,15 +1450,33 @@ class InfoBarInstantRecord:
                        if limitEvent:
                                self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
 
                        if limitEvent:
                                self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
 

-               data = (begin, end, name, description, eventid)
+               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
                recording.dontSave = True

-               self.recording.append(recording)
-
-#### DEPRECATED CODE ####
-               self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
-#########################
+               
+               if event is None or limitEvent == False:
+                       recording.autoincrease = True
+                       if recording.setAutoincreaseEnd():
+                               self.session.nav.RecordTimer.record(recording)
+                               self.recording.append(recording)
+               else:
+                               simulTimerList = self.session.nav.RecordTimer.record(recording)
+                               if simulTimerList is not None:  # conflict with other recording
+                                       name = simulTimerList[1].name
+                                       name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
+                                       print "[TIMER] conflicts with", name_date
+                                       recording.autoincrease = True   # start with max available length, then increment
+                                       if recording.setAutoincreaseEnd():
+                                               self.session.nav.RecordTimer.record(recording)
+                                               self.recording.append(recording)
+                                               self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
+                                       else:
+                                               self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
+                                       recording.autoincrease = False
+                               else:
+                                       self.recording.append(recording)

 
        def isInstantRecordRunning(self):
                print "self.recording:", self.recording
 
        def isInstantRecordRunning(self):
                print "self.recording:", self.recording


@@ -1427,6 +1534,8 @@ class InfoBarInstantRecord:
                        if ret[0]:
                                localendtime = localtime(ret[1])
                                print "stopping recording at", strftime("%c", localendtime)
                        if ret[0]:
                                localendtime = localtime(ret[1])
                                print "stopping recording at", strftime("%c", localendtime)

+                               if self.recording[self.selectedEntry].end != ret[1]:
+                                       self.recording[self.selectedEntry].autoincrease = False

                                self.recording[self.selectedEntry].end = ret[1]
                                self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
 
                                self.recording[self.selectedEntry].end = ret[1]
                                self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
 


@@ -1438,35 +1547,42 @@ class InfoBarInstantRecord:
        def inputCallback(self, value):
                if value is not None:
                        print "stopping recording after", int(value), "minutes."
        def inputCallback(self, value):
                if value is not None:
                        print "stopping recording after", int(value), "minutes."

-                       self.recording[self.selectedEntry].end = time() + 60 * int(value)
-                       self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
+                       entry = self.recording[self.selectedEntry]
+                       if int(value) != 0:
+                               entry.autoincrease = False
+                       entry.end = int(time()) + 60 * int(value)
+                       self.session.nav.RecordTimer.timeChanged(entry)

 
        def instantRecord(self):
 
        def instantRecord(self):

+               dir = config.movielist.last_videodir.value
+               if not fileExists(dir, 'w'):
+                       dir = resolveFilename(SCOPE_HDD)

                try:
                try:

-                       stat = os_stat(resolveFilename(SCOPE_HDD))
+                       stat = os_stat(dir)

                except:
                except:

+                       # XXX: this message is a little odd as we might be recording to a remote device

                        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?"), \
                        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"), \
-                               (_("change recording (endtime)"), "changeendtime"), \
-                               (_("add recording (indefinitely)"), "indefinitely"), \
-                               (_("add recording (stop after current event)"), "event"), \
+                               list=((_("add recording (stop after current event)"), "event"), \

                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \

-                               (_("do nothing"), "no")])
+                               (_("add recording (indefinitely)"), "indefinitely"), \
+                               (_("change recording (duration)"), "changeduration"), \
+                               (_("change recording (endtime)"), "changeendtime"), \
+                               (_("stop recording"), "stop"), \
+                               (_("do nothing"), "no")))

                else:
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
                                title=_("Start recording?"), \
                else:
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
                                title=_("Start recording?"), \

-                               list=[(_("add recording (indefinitely)"), "indefinitely"), \
-                               (_("add recording (stop after current event)"), "event"), \
+                               list=((_("add recording (stop after current event)"), "event"), \

                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (enter recording endtime)"), "manualendtime"), \

-                               (_("don't record"), "no")])
+                               (_("add recording (indefinitely)"), "indefinitely"), \
+                               (_("don't record"), "no")))

 
 from Tools.ISO639 import LanguageCodes
 
 
 from Tools.ISO639 import LanguageCodes
 


@@ -1479,16 +1595,15 @@ class InfoBarAudioSelection:
 
        def audioSelection(self):
                service = self.session.nav.getCurrentService()
 
        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
                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()
 
                tlist = []
                if n > 0:
                        self.audioChannel = service.audioChannel()
 

-                       for x in range(n):
-                               i = audio.getTrackInfo(x)
+                       idx = 0
+                       while idx < n:
+                               i = audio.getTrackInfo(idx)

                                language = i.getLanguage()
                                description = i.getDescription()
 
                                language = i.getLanguage()
                                description = i.getDescription()
 


@@ -1500,30 +1615,55 @@ class InfoBarAudioSelection:
                                else:
                                        description = language
 
                                else:
                                        description = language
 

-                               tlist.append((description, x))
+                               tlist.append((description, idx))
+                               idx += 1

 
 

-                       selectedAudio = audio.getCurrentTrack()

                        tlist.sort(key=lambda x: x[0])
 
                        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
 
                        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
 
                        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):
                                if audio[1] == "mode":
                                        keys = ["red", "green", "yellow"]
                                        selection = self.audioChannel.getCurrentChannel()
        def audioSelected(self, audio):
                if audio is not None:
                        if isinstance(audio[1], str):
                                if audio[1] == "mode":
                                        keys = ["red", "green", "yellow"]
                                        selection = self.audioChannel.getCurrentChannel()

-                                       tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
+                                       tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))

                                        self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
                        else:
                                del self.audioChannel
                                        self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
                        else:
                                del self.audioChannel


@@ -1552,16 +1692,18 @@ class InfoBarSubserviceSelection:
                        }, -1)
                self["SubserviceQuickzapAction"].setEnabled(False)
 
                        }, -1)
                self["SubserviceQuickzapAction"].setEnabled(False)
 

-               self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
+               self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+                       {
+                               iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
+                       })

 
                self.bsel = None
 
 
                self.bsel = None
 

-       def checkSubservicesAvail(self, ev):
-               if ev == iPlayableService.evUpdatedEventInfo:
-                       service = self.session.nav.getCurrentService()
-                       subservices = service and service.subServices()
-                       if not subservices or subservices.getNumberOfSubservices() == 0:
-                               self["SubserviceQuickzapAction"].setEnabled(False)
+       def checkSubservicesAvail(self):
+               service = self.session.nav.getCurrentService()
+               subservices = service and service.subServices()
+               if not subservices or subservices.getNumberOfSubservices() == 0:
+                       self["SubserviceQuickzapAction"].setEnabled(False)

 
        def nextSubservice(self):
                self.changeSubservice(+1)
 
        def nextSubservice(self):
                self.changeSubservice(+1)


@@ -1576,9 +1718,12 @@ class InfoBarSubserviceSelection:
                if n and n > 0:
                        selection = -1
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                if n and n > 0:
                        selection = -1
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()

-                       for x in range(n):
-                               if subservices.getSubservice(x).toString() == ref.toString():
-                                       selection = x
+                       idx = 0
+                       while idx < n:
+                               if subservices.getSubservice(idx).toString() == ref.toString():
+                                       selection = idx
+                                       break
+                               idx += 1

                        if selection != -1:
                                selection += direction
                                if selection >= n:
                        if selection != -1:
                                selection += direction
                                if selection >= n:


@@ -1589,7 +1734,7 @@ class InfoBarSubserviceSelection:
                                if newservice.valid():
                                        del subservices
                                        del service
                                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()
 
        def subserviceSelection(self):
                service = self.session.nav.getCurrentService()


@@ -1600,14 +1745,16 @@ class InfoBarSubserviceSelection:
                if n and n > 0:
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                        tlist = []
                if n and n > 0:
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                        tlist = []

-                       for x in range(n):
-                               i = subservices.getSubservice(x)
+                       idx = 0
+                       while idx < n:
+                               i = subservices.getSubservice(idx)

                                if i.toString() == ref.toString():
                                if i.toString() == ref.toString():

-                                       selection = x
+                                       selection = idx

                                tlist.append((i.getName(), i))
                                tlist.append((i.getName(), i))

+                               idx += 1

 
                        if self.bouquets and len(self.bouquets):
 
                        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:
                                if config.usage.multibouquet.value:
                                        tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
                                else:


@@ -1629,7 +1776,7 @@ class InfoBarSubserviceSelection:
                                        self.session.open(SubservicesQuickzap, service[2])
                        else:
                                self["SubserviceQuickzapAction"].setEnabled(True)
                                        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):
 
        def addSubserviceToBouquetCallback(self, service):
                if len(service) > 1 and isinstance(service[1], eServiceReference):


@@ -1660,63 +1807,13 @@ class InfoBarSubserviceSelection:
 class InfoBarAdditionalInfo:
        def __init__(self):
 
 class InfoBarAdditionalInfo:
        def __init__(self):
 

-               self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
+               self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)

                self["TimeshiftPossible"] = self["RecordingPossible"]
                self["TimeshiftPossible"] = self["RecordingPossible"]

+               self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
+               self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
+               self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)

                self["ExtensionsAvailable"] = Boolean(fixed=1)
 
                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")
-
-               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)
 class InfoBarNotifications:
        def __init__(self):
                self.onExecBegin.append(self.checkNotifications)


@@ -1731,10 +1828,11 @@ class InfoBarNotifications:
                        self.checkNotifications()
 
        def checkNotifications(self):
                        self.checkNotifications()
 
        def checkNotifications(self):

-               if len(Notifications.notifications):
-                       n = Notifications.notifications[0]
+               notifications = Notifications.notifications
+               if notifications:
+                       n = notifications[0]

 
 

-                       Notifications.notifications = Notifications.notifications[1:]
+                       del notifications[0]

                        cb = n[0]
 
                        if n[3].has_key("onSessionOpenCallback"):
                        cb = n[0]
 
                        if n[3].has_key("onSessionOpenCallback"):


@@ -1807,13 +1905,21 @@ class InfoBarCueSheetSupport:
 
                        if last is not None:
                                self.resume_point = last
 
                        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:
 
        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):
                self.hideAfterResume()
 
        def hideAfterResume(self):


@@ -1835,37 +1941,64 @@ class InfoBarCueSheetSupport:
                        return None
                return long(r[1])
 
                        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:
                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]
                if mark is not None:
                        pts = mark[0]

-               elif alternative is not None:
-                       pts = alternative

                else:
                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
 
        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):
 
        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
                # can be optimized

+               beforecut = False

                nearest = None
                nearest = None

+               if start:
+                       beforecut = True
+                       bestdiff = cmp(0 - pts)
+                       if bestdiff >= 0:
+                               nearest = [0, False]

                for cp in self.cut_list:
                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):
                return nearest
 
        def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):