git.cweiske.de / enigma2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
whitespace fixes, fix infobar summary to include progressbar (patch by Sat_Man)
[enigma2.git] / lib / python / Screens / InfoBarGenerics.py
diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index f8b6c7eac1a4eaafd6d04766fbc0d5e76d1ece13..603f476218f865aa96a3fb908f5425b2d5ad87e5 100644 (file)
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -5,17 +5,12 @@ from Components.ActionMap import NumberActionMap
 from Components.BlinkingPixmap import BlinkingPixmapConditional
 from Components.Harddisk import harddiskmanager
 from Components.Input import Input
 from Components.BlinkingPixmap import BlinkingPixmapConditional
 from Components.Harddisk import harddiskmanager
 from Components.Input import Input
-from Components.Label import *
-from Components.Pixmap import Pixmap, PixmapConditional
+from Components.Label import Label
+from Components.Pixmap import Pixmap
 from Components.PluginComponent import plugins
 from Components.PluginComponent import plugins
-from Components.ProgressBar import *
 from Components.ServiceEventTracker import ServiceEventTracker
 from Components.ServiceEventTracker import ServiceEventTracker
-from Components.Sources.CurrentService import CurrentService
-from Components.Sources.EventInfo import EventInfo
-from Components.Sources.FrontendStatus import FrontendStatus
+from Components.Sources.Source import ObsoleteSource
 from Components.Sources.Boolean import Boolean
 from Components.Sources.Boolean import Boolean
-from Components.Sources.Clock import Clock
-from Components.TimerList import TimerEntryComponent
 from Components.config import config, ConfigBoolean, ConfigClock
 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
 from Components.config import config, ConfigBoolean, ConfigClock
 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
@@ -60,7 +55,7 @@ class InfoBarShowHide:
        STATE_HIDING = 1
        STATE_SHOWING = 2
        STATE_SHOWN = 3
        STATE_HIDING = 1
        STATE_SHOWING = 2
        STATE_SHOWN = 3
-       
+
        def __init__(self):
                self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
                        {
        def __init__(self):
                self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
                        {
@@ -70,42 +65,28 @@ class InfoBarShowHide:
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
-                               iPlayableService.evStart: self.__serviceStarted,
-                               iPlayableService.evUpdatedEventInfo: self.__eventInfoChanged
+                               iPlayableService.evStart: self.serviceStarted,
                        })
 
                self.__state = self.STATE_SHOWN
                self.__locked = 0
                        })
 
                self.__state = self.STATE_SHOWN
                self.__locked = 0
-               
+
                self.hideTimer = eTimer()
                self.hideTimer.timeout.get().append(self.doTimerHide)
                self.hideTimer.start(5000, True)
                self.hideTimer = eTimer()
                self.hideTimer.timeout.get().append(self.doTimerHide)
                self.hideTimer.start(5000, True)
-               
+
                self.onShow.append(self.__onShow)
                self.onHide.append(self.__onHide)
                self.onShow.append(self.__onShow)
                self.onHide.append(self.__onHide)
-               self.current_begin_time=0
 
 
-       def __eventInfoChanged(self):
+       def serviceStarted(self):
                if self.execing:
                if self.execing:
-                       service = self.session.nav.getCurrentService()
-                       old_begin_time = self.current_begin_time
-                       info = service and service.info()
-                       ptr = info and info.getEvent(0)
-                       self.current_begin_time = ptr and ptr.getBeginTime() or 0
-                       if config.usage.show_infobar_on_event_change.value:
-                               if old_begin_time and old_begin_time != self.current_begin_time:
-                                       self.doShow()
-
-       def __serviceStarted(self):
-               if self.execing:
-                       self.current_begin_time=0
                        if config.usage.show_infobar_on_zap.value:
                                self.doShow()
 
        def __onShow(self):
                self.__state = self.STATE_SHOWN
                self.startHideTimer()
                        if config.usage.show_infobar_on_zap.value:
                                self.doShow()
 
        def __onShow(self):
                self.__state = self.STATE_SHOWN
                self.startHideTimer()
-       
+
        def startHideTimer(self):
                if self.__state == self.STATE_SHOWN and not self.__locked:
                        idx = config.usage.infobar_timeout.index
        def startHideTimer(self):
                if self.__state == self.STATE_SHOWN and not self.__locked:
                        idx = config.usage.infobar_timeout.index
@@ -136,7 +117,7 @@ class InfoBarShowHide:
                if self.execing:
                        self.show()
                        self.hideTimer.stop()
                if self.execing:
                        self.show()
                        self.hideTimer.stop()
-       
+
        def unlockShow(self):
                self.__locked = self.__locked - 1
                if self.execing:
        def unlockShow(self):
                self.__locked = self.__locked - 1
                if self.execing:
@@ -145,7 +126,7 @@ class InfoBarShowHide:
 #      def startShow(self):
 #              self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
 #              self.__state = self.STATE_SHOWN
 #      def startShow(self):
 #              self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
 #              self.__state = self.STATE_SHOWN
-#      
+#
 #      def startHide(self):
 #              self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
 #              self.__state = self.STATE_HIDDEN
 #      def startHide(self):
 #              self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
 #              self.__state = self.STATE_HIDDEN
@@ -174,7 +155,7 @@ class NumberZap(Screen):
 
                self["number"] = Label(self.field)
 
 
                self["number"] = Label(self.field)
 
-               self["actions"] = NumberActionMap( [ "SetupActions" ], 
+               self["actions"] = NumberActionMap( [ "SetupActions" ],
                        {
                                "cancel": self.quit,
                                "ok": self.keyOK,
                        {
                                "cancel": self.quit,
                                "ok": self.keyOK,
@@ -214,9 +195,13 @@ class InfoBarNumberZap:
        def keyNumberGlobal(self, number):
 #              print "You pressed number " + str(number)
                if number == 0:
        def keyNumberGlobal(self, number):
 #              print "You pressed number " + str(number)
                if number == 0:
-                       self.servicelist.recallPrevService()
+                       if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
+                               self.pipDoHandle0Action()
+                       else:
+                               self.servicelist.recallPrevService()
                else:
                else:
-                       self.session.openWithCallback(self.numberEntered, NumberZap, number)
+                       if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
+                               self.session.openWithCallback(self.numberEntered, NumberZap, number)
 
        def numberEntered(self, retval):
 #              print self.servicelist
 
        def numberEntered(self, retval):
 #              print self.servicelist
@@ -264,12 +249,12 @@ class InfoBarNumberZap:
 config.misc.initialchannelselection = ConfigBoolean(default = True)
 
 class InfoBarChannelSelection:
 config.misc.initialchannelselection = ConfigBoolean(default = True)
 
 class InfoBarChannelSelection:
-       """ ChannelSelection - handles the channelSelection dialog and the initial 
+       """ ChannelSelection - handles the channelSelection dialog and the initial
        channelChange actions which open the channelSelection dialog """
        def __init__(self):
                #instantiate forever
                self.servicelist = self.session.instantiateDialog(ChannelSelection)
        channelChange actions which open the channelSelection dialog """
        def __init__(self):
                #instantiate forever
                self.servicelist = self.session.instantiateDialog(ChannelSelection)
-               
+
                if config.misc.initialchannelselection.value:
                        self.onShown.append(self.firstRun)
 
                if config.misc.initialchannelselection.value:
                        self.onShown.append(self.firstRun)
 
@@ -315,7 +300,7 @@ class InfoBarChannelSelection:
        def switchChannelDown(self):
                self.servicelist.moveDown()
                self.session.execDialog(self.servicelist)
        def switchChannelDown(self):
                self.servicelist.moveDown()
                self.session.execDialog(self.servicelist)
-       
+
        def openServiceList(self):
                self.session.execDialog(self.servicelist)
 
        def openServiceList(self):
                self.session.execDialog(self.servicelist)
 
@@ -356,7 +341,7 @@ class InfoBarChannelSelection:
 class InfoBarMenu:
        """ Handles a menu action, to open the (main) menu """
        def __init__(self):
 class InfoBarMenu:
        """ Handles a menu action, to open the (main) menu """
        def __init__(self):
-               self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 
+               self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
                        {
                                "mainMenu": (self.mainMenu, _("Enter main menu...")),
                        })
                        {
                                "mainMenu": (self.mainMenu, _("Enter main menu...")),
                        })
@@ -417,11 +402,20 @@ class InfoBarEPG:
                self.dlg_stack = [ ]
                self.bouquetSel = None
                self.eventView = None
                self.dlg_stack = [ ]
                self.bouquetSel = None
                self.eventView = None
-               self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
+               self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),
+                               "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
+                               "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
                        })
 
                        })
 
+       def showEventInfoWhenNotVisible(self):
+               if self.shown:
+                       self.openEventView()
+               else:
+                       self.toggleShow()
+                       return 1
+
        def zapToService(self, service):
                if not service is None:
                        if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
        def zapToService(self, service):
                if not service is None:
                        if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
@@ -489,7 +483,7 @@ class InfoBarEPG:
                                self.dlg_stack.append(self.bouquetSel)
                        else:
                                self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
                                self.dlg_stack.append(self.bouquetSel)
                        else:
                                self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
-               elif cnt == 1: 
+               elif cnt == 1:
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
        def openSingleServiceEPG(self):
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
        def openSingleServiceEPG(self):
@@ -548,26 +542,26 @@ class InfoBarEPG:
 class InfoBarTuner:
        """provides a snr/agc/ber display"""
        def __init__(self):
 class InfoBarTuner:
        """provides a snr/agc/ber display"""
        def __init__(self):
-               self["FrontendStatus"] = FrontendStatus(service_source = self.session.nav.getCurrentService)
+               self["FrontendStatus"] = ObsoleteSource(new_source = "session.FrontendStatus", removal_date = "2008-01")
 
 class InfoBarEvent:
        """provides a current/next event info display"""
        def __init__(self):
 
 class InfoBarEvent:
        """provides a current/next event info display"""
        def __init__(self):
-               self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW)
-               self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT)
+               self["Event_Now"] = ObsoleteSource(new_source = "session.Event_Now", removal_date = "2008-01")
+               self["Event_Next"] = ObsoleteSource(new_source = "session.Event_Next", removal_date = "2008-01")
 
 class InfoBarRdsDecoder:
        """provides RDS and Rass support/display"""
        def __init__(self):
                self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
                self.rass_interactive = None
 
 class InfoBarRdsDecoder:
        """provides RDS and Rass support/display"""
        def __init__(self):
                self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
                self.rass_interactive = None
-               
+
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evEnd: self.__serviceStopped,
                                iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
                        })
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evEnd: self.__serviceStopped,
                                iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
                        })
-               
+
                self["RdsActions"] = ActionMap(["InfobarRdsActions"],
                {
                        "startRassInteractive": self.startRassInteractive
                self["RdsActions"] = ActionMap(["InfobarRdsActions"],
                {
                        "startRassInteractive": self.startRassInteractive
@@ -606,38 +600,42 @@ class InfoBarRdsDecoder:
 
 class InfoBarServiceName:
        def __init__(self):
 
 class InfoBarServiceName:
        def __init__(self):
-               self["CurrentService"] = CurrentService(self.session.nav)
+               self["CurrentService"] = ObsoleteSource(new_source = "session.CurrentService", removal_date = "2008-01")
 
 class InfoBarSeek:
        """handles actions like seeking, pause"""
 
 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")
        # 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_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_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_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_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_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):
+       def __init__(self, actionmap = "InfobarSeekActions"):
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
                                iPlayableService.evStart: self.__serviceStarted,
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
                                iPlayableService.evStart: self.__serviceStarted,
-                               
+
                                iPlayableService.evEOF: self.__evEOF,
                                iPlayableService.evSOF: self.__evSOF,
                        })
                                iPlayableService.evEOF: self.__evEOF,
                                iPlayableService.evSOF: self.__evSOF,
                        })
@@ -646,59 +644,56 @@ class InfoBarSeek:
                        def __init__(self, screen, *args, **kwargs):
                                HelpableActionMap.__init__(self, screen, *args, **kwargs)
                                self.screen = screen
                        def __init__(self, screen, *args, **kwargs):
                                HelpableActionMap.__init__(self, screen, *args, **kwargs)
                                self.screen = screen
-                               
+
                        def action(self, contexts, action):
                                print "action:", action
                                if action[:5] == "seek:":
                                        time = int(action[5:])
                                        self.screen.seekRelative(time * 90000)
                        def action(self, contexts, action):
                                print "action:", action
                                if action[:5] == "seek:":
                                        time = int(action[5:])
                                        self.screen.seekRelative(time * 90000)
-                                       self.screen.doShow()
+                                       if config.usage.show_infobar_on_skip.value:
+                                               self.screen.showAfterSeek()
                                        return 1
                                else:
                                        return HelpableActionMap.action(self, contexts, action)
 
                                        return 1
                                else:
                                        return HelpableActionMap.action(self, contexts, action)
 
-               self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", 
+               self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
                        {
                        {
-                               "playpauseService": (self.playpauseService, _("pause")),
+                               "playpauseService": self.playpauseService,
                                "pauseService": (self.pauseService, _("pause")),
                                "unPauseService": (self.unPauseService, _("continue")),
                                "pauseService": (self.pauseService, _("pause")),
                                "unPauseService": (self.unPauseService, _("continue")),
-                               
+
                                "seekFwd": (self.seekFwd, _("skip forward")),
                                "seekFwd": (self.seekFwd, _("skip forward")),
-                               "seekFwdDown": self.seekFwdDown,
-                               "seekFwdUp": self.seekFwdUp,
+                               "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
                                "seekBack": (self.seekBack, _("skip backward")),
                                "seekBack": (self.seekBack, _("skip backward")),
-                               "seekBackDown": self.seekBackDown,
-                               "seekBackUp": self.seekBackUp,
+                               "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")),
+
+                               "seekFwdDef": (self.seekFwdDef, _("skip forward (self defined)")),
+                               "seekBackDef": (self.seekBackDef, _("skip backward (self defined)"))
                        }, 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.onClose.append(self.delTimer)
-               
-               self.fwdtimer = False
-               self.fwdKeyTimer = eTimer()
-               self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire)
-
-               self.rwdtimer = False
-               self.rwdKeyTimer = eTimer()
-               self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
-               
+
+               self.seek_flag = True
+
                self.onPlayStateChanged = [ ]
                self.onPlayStateChanged = [ ]
-               
+
                self.lockedBecauseOfSkipping = False
 
                self.lockedBecauseOfSkipping = False
 
+               self.__seekableStatusChanged()
+
+       def showAfterSeek(self):
+               if isinstance(self, InfoBarShowHide):
+                       self.doShow()
+
        def up(self):
                pass
        def up(self):
                pass
-       
+
        def down(self):
                pass
        def down(self):
                pass
-       
-       def delTimer(self):
-               del self.fwdKeyTimer
-               del self.rwdKeyTimer
-       
+
        def getSeek(self):
                service = self.session.nav.getCurrentService()
                if service is None:
        def getSeek(self):
                service = self.session.nav.getCurrentService()
                if service is None:
@@ -708,9 +703,9 @@ class InfoBarSeek:
 
                if seek is None or not seek.isCurrentlySeekable():
                        return None
 
                if seek is None or not seek.isCurrentlySeekable():
                        return None
-               
+
                return seek
                return seek
-       
+
        def isSeekable(self):
                if self.getSeek() is None:
                        return False
        def isSeekable(self):
                if self.getSeek() is None:
                        return False
@@ -732,10 +727,10 @@ class InfoBarSeek:
 
        def setSeekState(self, state):
                service = self.session.nav.getCurrentService()
 
        def setSeekState(self, state):
                service = self.session.nav.getCurrentService()
-               
+
                if service is None:
                        return False
                if service is None:
                        return False
-               
+
                if not self.isSeekable():
                        if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
                                state = self.SEEK_STATE_PLAY
                if not self.isSeekable():
                        if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
                                state = self.SEEK_STATE_PLAY
@@ -759,7 +754,7 @@ class InfoBarSeek:
                self.checkSkipShowHideLock()
 
                return True
                self.checkSkipShowHideLock()
 
                return True
-       
+
        def playpauseService(self):
                if self.seekstate != self.SEEK_STATE_PLAY:
                        self.unPauseService()
        def playpauseService(self):
                if self.seekstate != self.SEEK_STATE_PLAY:
                        self.unPauseService()
@@ -777,41 +772,24 @@ class InfoBarSeek:
                                print "no", self.seekstate
                        print "pause"
                        self.setSeekState(self.SEEK_STATE_PAUSE);
                                print "no", self.seekstate
                        print "pause"
                        self.setSeekState(self.SEEK_STATE_PAUSE);
-               
+
        def unPauseService(self):
                print "unpause"
                if self.seekstate == self.SEEK_STATE_PLAY:
                        return 0
                self.setSeekState(self.SEEK_STATE_PLAY)
        def unPauseService(self):
                print "unpause"
                if self.seekstate == self.SEEK_STATE_PLAY:
                        return 0
                self.setSeekState(self.SEEK_STATE_PLAY)
-       
+
        def doSeek(self, seektime):
                print "doseek", seektime
                service = self.session.nav.getCurrentService()
                if service is None:
                        return
        def doSeek(self, seektime):
                print "doseek", seektime
                service = self.session.nav.getCurrentService()
                if service is None:
                        return
-               
+
                seekable = self.getSeek()
                if seekable is None:
                        return
                seekable = self.getSeek()
                if seekable is None:
                        return
-               
-               seekable.seekTo(90 * seektime)
-
-       def seekFwdDown(self):
-               print "start fwd timer"
-               self.fwdtimer = True
-               self.fwdKeyTimer.start(1000)
 
 
-       def seekBackDown(self):
-               print "start rewind timer"
-               self.rwdtimer = True
-               self.rwdKeyTimer.start(1000)
-
-       def seekFwdUp(self):
-               print "seekFwdUp"
-               if self.fwdtimer:
-                       self.fwdKeyTimer.stop()
-                       self.fwdtimer = False
-                       self.seekFwd()
+               seekable.seekTo(90 * seektime)
 
        def seekFwd(self):
                lookup = {
 
        def seekFwd(self):
                lookup = {
@@ -819,13 +797,17 @@ class InfoBarSeek:
                                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_PAUSE: self.SEEK_STATE_SM_EIGHTH,
                                self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
                                self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
-                               self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
-                               self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
+                               self.SEEK_STATE_FF_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_FF_64X: self.SEEK_STATE_FF_128X,
                                self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
-                               self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY,
+                               self.SEEK_STATE_BACK_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_32X: self.SEEK_STATE_BACK_16X,
-                               self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
+                               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_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,
@@ -833,71 +815,78 @@ class InfoBarSeek:
                                self.SEEK_STATE_EOF: self.SEEK_STATE_EOF,
                        }
                self.setSeekState(lookup[self.seekstate])
                                self.SEEK_STATE_EOF: self.SEEK_STATE_EOF,
                        }
                self.setSeekState(lookup[self.seekstate])
-       
-       def seekBackUp(self):
-               print "seekBackUp"
-               if self.rwdtimer:
-                       self.rwdKeyTimer.stop()
-                       self.rwdtimer = False
-                       self.seekBack()
-               
+
        def seekBack(self):
                lookup = {
        def seekBack(self):
                lookup = {
-                               self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X,
+                               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_PAUSE: self.SEEK_STATE_PAUSE,
                                self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
                                self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
                                self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
-                               self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
-                               self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
+                               self.SEEK_STATE_FF_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_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_16X: self.SEEK_STATE_BACK_32X,
-                               self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
+                               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_BACK_64X: self.SEEK_STATE_BACK_128X,
                                self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
                                self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
                                self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
                                self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE,
-                               self.SEEK_STATE_EOF: self.SEEK_STATE_BACK_16X,
+                               self.SEEK_STATE_EOF: self.SEEK_STATE_BACK_8X,
                        }
                self.setSeekState(lookup[self.seekstate])
                        }
                self.setSeekState(lookup[self.seekstate])
-               
+
                if self.seekstate == self.SEEK_STATE_PAUSE:
                        seekable = self.getSeek()
                        if seekable is not None:
                                seekable.seekRelative(-1, 3)
 
                if self.seekstate == self.SEEK_STATE_PAUSE:
                        seekable = self.getSeek()
                        if seekable is not None:
                                seekable.seekRelative(-1, 3)
 
-       def fwdTimerFire(self):
-               print "Display seek fwd"
-               self.fwdKeyTimer.stop()
-               self.fwdtimer = False
+       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)
+
+       def seekFwdManual(self):
                self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
                self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
-               
+
        def fwdSeekTo(self, minutes):
                print "Seek", minutes, "minutes forward"
                if minutes != 0:
                        seekable = self.getSeek()
                        if seekable is not None:
                                seekable.seekRelative(1, minutes * 60 * 90000)
        def fwdSeekTo(self, minutes):
                print "Seek", minutes, "minutes forward"
                if minutes != 0:
                        seekable = self.getSeek()
                        if seekable is not None:
                                seekable.seekRelative(1, minutes * 60 * 90000)
-       
-       def rwdTimerFire(self):
-               print "rwdTimerFire"
-               self.rwdKeyTimer.stop()
-               self.rwdtimer = False
+
+       def seekBackManual(self):
                self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
                self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
-       
+
        def rwdSeekTo(self, minutes):
                print "rwdSeekTo"
                self.fwdSeekTo(0 - minutes)
        def rwdSeekTo(self, minutes):
                print "rwdSeekTo"
                self.fwdSeekTo(0 - minutes)
-       
+
        def checkSkipShowHideLock(self):
                wantlock = self.seekstate != self.SEEK_STATE_PLAY
        def checkSkipShowHideLock(self):
                wantlock = self.seekstate != self.SEEK_STATE_PLAY
-               
-               if config.usage.show_infobar_on_zap.value:
+
+               if config.usage.show_infobar_on_skip.value:
                        if self.lockedBecauseOfSkipping and not wantlock:
                                self.unlockShow()
                                self.lockedBecauseOfSkipping = False
                        if self.lockedBecauseOfSkipping and not wantlock:
                                self.unlockShow()
                                self.lockedBecauseOfSkipping = False
-               
+
                        if wantlock and not self.lockedBecauseOfSkipping:
                                self.lockShow()
                                self.lockedBecauseOfSkipping = True
                        if wantlock and not self.lockedBecauseOfSkipping:
                                self.lockShow()
                                self.lockedBecauseOfSkipping = True
@@ -915,17 +904,20 @@ class InfoBarSeek:
                        self.seekRelativeToEnd(-90000)
                else:
                        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):
        def __evSOF(self):
                self.setSeekState(self.SEEK_STATE_PLAY)
                self.doSeek(0)
 
        def seekRelative(self, diff):
-               seekable = self.getSeek()
-               if seekable is not None:
-                       print "seekRelative: res:", seekable.seekRelative(1, diff)
+               if self.seek_flag == True:
+                       seekable = self.getSeek()
+                       if seekable is not None:
+                               print "seekRelative: res:", seekable.seekRelative(1, diff)
+                       else:
+                               print "seek failed!"
                else:
                else:
-                       print "seek failed!"
+                       self.seek_flag = True
 
        def seekRelativeToEnd(self, diff):
                assert diff <= 0, "diff is expected to be negative!"
 
        def seekRelativeToEnd(self, diff):
                assert diff <= 0, "diff is expected to be negative!"
@@ -972,15 +964,15 @@ class InfoBarTimeshiftState(InfoBarPVRState):
 
 class InfoBarShowMovies:
 
 
 class InfoBarShowMovies:
 
-       # i don't really like this class. 
+       # i don't really like this class.
        # it calls a not further specified "movie list" on up/down/movieList,
        # so this is not more than an action map
        def __init__(self):
        # it calls a not further specified "movie list" on up/down/movieList,
        # so this is not more than an action map
        def __init__(self):
-               self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", 
+               self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
                        {
                        {
-                               "movieList": (self.showMovies, "movie list"),
-                               "up": (self.showMovies, "movie list"),
-                               "down": (self.showMovies, "movie list")
+                               "movieList": (self.showMovies, _("movie list")),
+                               "up": (self.showMovies, _("movie list")),
+                               "down": (self.showMovies, _("movie list"))
                        })
 
 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
                        })
 
 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
@@ -1013,7 +1005,7 @@ class InfoBarShowMovies:
 
 class InfoBarTimeshift:
        def __init__(self):
 
 class InfoBarTimeshift:
        def __init__(self):
-               self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", 
+               self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
                        {
                                "timeshiftStart": (self.startTimeshift, _("start timeshift")),  # the "yellow key"
                                "timeshiftStop": (self.stopTimeshift, _("stop timeshift"))      # currently undefined :), probably 'TV'
                        {
                                "timeshiftStart": (self.startTimeshift, _("start timeshift")),  # the "yellow key"
                                "timeshiftStop": (self.stopTimeshift, _("stop timeshift"))      # currently undefined :), probably 'TV'
@@ -1117,13 +1109,13 @@ class InfoBarTimeshift:
                print "activateTimeshiftEndAndPause"
                #state = self.seekstate
                self.activateTimeshiftEnd(False)
                print "activateTimeshiftEndAndPause"
                #state = self.seekstate
                self.activateTimeshiftEnd(False)
-       
+
        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
                # the timeshift
                # when this service is not seekable, but timeshift
                # is enabled, this means we can activate
                # the timeshift
@@ -1142,10 +1134,10 @@ from Screens.PiPSetup import PiPSetup
 class InfoBarExtensions:
        EXTENSION_SINGLE = 0
        EXTENSION_LIST = 1
 class InfoBarExtensions:
        EXTENSION_SINGLE = 0
        EXTENSION_LIST = 1
-       
+
        def __init__(self):
                self.list = []
        def __init__(self):
                self.list = []
-               
+
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                                "extensions": (self.showExtensionSelection, _("view extensions...")),
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                                "extensions": (self.showExtensionSelection, _("view extensions...")),
@@ -1153,13 +1145,13 @@ class InfoBarExtensions:
 
        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))
-               
+
        def updateExtension(self, extension, key = None):
                self.extensionsList.append(extension)
                if key is not None:
                        if self.extensionKeys.has_key(key):
                                key = None
        def updateExtension(self, extension, key = None):
                self.extensionsList.append(extension)
                if key is not None:
                        if self.extensionKeys.has_key(key):
                                key = None
-               
+
                if key is None:
                        for x in self.availableKeys:
                                if not self.extensionKeys.has_key(x):
                if key is None:
                        for x in self.availableKeys:
                                if not self.extensionKeys.has_key(x):
@@ -1168,7 +1160,7 @@ class InfoBarExtensions:
 
                if key is not None:
                        self.extensionKeys[key] = len(self.extensionsList) - 1
 
                if key is not None:
                        self.extensionKeys[key] = len(self.extensionsList) - 1
-                       
+
        def updateExtensions(self):
                self.extensionsList = []
                self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
        def updateExtensions(self):
                self.extensionsList = []
                self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
@@ -1214,10 +1206,10 @@ from Components.PluginComponent import plugins
 class InfoBarPlugins:
        def __init__(self):
                self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
 class InfoBarPlugins:
        def __init__(self):
                self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
-               
+
        def getPluginName(self, name):
                return name
        def getPluginName(self, name):
                return name
-               
+
        def getPluginList(self):
                list = []
                for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
        def getPluginList(self):
                list = []
                for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
@@ -1225,13 +1217,13 @@ class InfoBarPlugins:
                return list
 
        def runPlugin(self, plugin):
                return list
 
        def runPlugin(self, plugin):
-               plugin(session = self.session)
+               plugin(session = self.session, servicelist = self.servicelist)
 
 # 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")      
-               
+               self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
+
        def available(self):
                return True
 
        def available(self):
                return True
 
@@ -1249,31 +1241,35 @@ class InfoBarPiP:
                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")
                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
        def available(self):
                return True
-       
+
        def pipShown(self):
                return self.session.pipshown
        def pipShown(self):
                return self.session.pipshown
-       
+
+       def pipHandles0Action(self):
+               return self.pipShown() and config.usage.pip_zero_button.value != "standard"
+
        def getShowHideName(self):
                if self.session.pipshown:
                        return _("Disable Picture in Picture")
                else:
                        return _("Activate Picture in Picture")
        def getShowHideName(self):
                if self.session.pipshown:
                        return _("Disable Picture in Picture")
                else:
                        return _("Activate Picture in Picture")
-               
+
        def getSwapName(self):
                return _("Swap Services")
        def getSwapName(self):
                return _("Swap Services")
-               
+
        def getMoveName(self):
                return _("Move Picture in Picture")
        def getMoveName(self):
                return _("Move Picture in Picture")
-       
+
        def showPiP(self):
                if self.session.pipshown:
                        del self.session.pip
                        self.session.pipshown = False
                else:
                        self.session.pip = self.session.instantiateDialog(PictureInPicture)
        def showPiP(self):
                if self.session.pipshown:
                        del self.session.pip
                        self.session.pipshown = False
                else:
                        self.session.pip = self.session.instantiateDialog(PictureInPicture)
+                       self.session.pip.show()
                        newservice = self.session.nav.getCurrentlyPlayingServiceReference()
                        if self.session.pip.playService(newservice):
                                self.session.pipshown = True
                        newservice = self.session.nav.getCurrentlyPlayingServiceReference()
                        if self.session.pip.playService(newservice):
                                self.session.pipshown = True
@@ -1282,7 +1278,7 @@ class InfoBarPiP:
                                self.session.pipshown = False
                                del self.session.pip
                        self.session.nav.playService(newservice)
                                self.session.pipshown = False
                                del self.session.pip
                        self.session.nav.playService(newservice)
-       
+
        def swapPiP(self):
                swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
                if self.session.pip.servicePath:
        def swapPiP(self):
                swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
                if self.session.pip.servicePath:
@@ -1295,14 +1291,24 @@ class InfoBarPiP:
                                self.session.nav.stopService() # stop portal
                                self.session.nav.playService(pipref) # start subservice
                        self.session.pip.servicePath=servicepath
                                self.session.nav.stopService() # stop portal
                                self.session.nav.playService(pipref) # start subservice
                        self.session.pip.servicePath=servicepath
-       
+
        def movePiP(self):
                self.session.open(PiPSetup, pip = self.session.pip)
 
        def movePiP(self):
                self.session.open(PiPSetup, pip = self.session.pip)
 
+       def pipDoHandle0Action(self):
+               use = config.usage.pip_zero_button.value
+               if "swap" == use:
+                       self.swapPiP()
+               elif "swapstop" == use:
+                       self.swapPiP()
+                       self.showPiP()
+               elif "stop" == use:
+                       self.showPiP()
+
 from RecordTimer import parseEvent
 
 class InfoBarInstantRecord:
 from RecordTimer import parseEvent
 
 class InfoBarInstantRecord:
-       """Instant Record - handles the instantRecord action in order to 
+       """Instant Record - handles the instantRecord action in order to
        start/stop instant records"""
        def __init__(self):
                self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
        start/stop instant records"""
        def __init__(self):
                self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
@@ -1314,14 +1320,14 @@ class InfoBarInstantRecord:
                self["BlinkingPoint"].hide()
                self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
 
                self["BlinkingPoint"].hide()
                self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
 
-       def stopCurrentRecording(self, entry = -1):     
+       def stopCurrentRecording(self, entry = -1):
                if entry is not None and entry != -1:
                        self.session.nav.RecordTimer.removeEntry(self.recording[entry])
                        self.recording.remove(self.recording[entry])
 
        def startInstantRecording(self, limitEvent = False):
                serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
                if entry is not None and entry != -1:
                        self.session.nav.RecordTimer.removeEntry(self.recording[entry])
                        self.recording.remove(self.recording[entry])
 
        def startInstantRecording(self, limitEvent = False):
                serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
-               
+
                # try to get event info
                event = None
                try:
                # try to get event info
                event = None
                try:
@@ -1340,7 +1346,7 @@ class InfoBarInstantRecord:
                name = "instant record"
                description = ""
                eventid = None
                name = "instant record"
                description = ""
                eventid = None
-               
+
                if event is not None:
                        curEvent = parseEvent(event)
                        name = curEvent[2]
                if event is not None:
                        curEvent = parseEvent(event)
                        name = curEvent[2]
@@ -1351,15 +1357,15 @@ class InfoBarInstantRecord:
                else:
                        if limitEvent:
                                self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
                else:
                        if limitEvent:
                                self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
-                               
+
                data = (begin, end, name, description, eventid)
                data = (begin, end, name, description, eventid)
-               
+
                recording = self.session.nav.recordWithTimer(serviceref, *data)
                recording.dontSave = True
                self.recording.append(recording)
                recording = self.session.nav.recordWithTimer(serviceref, *data)
                recording.dontSave = True
                self.recording.append(recording)
-               
+
                #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
                #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
-               
+
        def isInstantRecordRunning(self):
                print "self.recording:", self.recording
                if len(self.recording) > 0:
        def isInstantRecordRunning(self):
                print "self.recording:", self.recording
                if len(self.recording) > 0:
@@ -1370,7 +1376,7 @@ class InfoBarInstantRecord:
 
        def recordQuestionCallback(self, answer):
                print "pre:\n", self.recording
 
        def recordQuestionCallback(self, answer):
                print "pre:\n", self.recording
-               
+
                if answer is None or answer[1] == "no":
                        return
                list = []
                if answer is None or answer[1] == "no":
                        return
                list = []
@@ -1379,7 +1385,7 @@ class InfoBarInstantRecord:
                        if not x in self.session.nav.RecordTimer.timer_list:
                                self.recording.remove(x)
                        elif x.dontSave and x.isRunning():
                        if not x in self.session.nav.RecordTimer.timer_list:
                                self.recording.remove(x)
                        elif x.dontSave and x.isRunning():
-                               list.append(TimerEntryComponent(x, False))              
+                               list.append((x, False))
 
                if answer[1] == "changeduration":
                        if len(self.recording) == 1:
 
                if answer[1] == "changeduration":
                        if len(self.recording) == 1:
@@ -1461,7 +1467,7 @@ from Tools.ISO639 import LanguageCodes
 
 class InfoBarAudioSelection:
        def __init__(self):
 
 class InfoBarAudioSelection:
        def __init__(self):
-               self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", 
+               self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
                        {
                                "audioSelection": (self.audioSelection, _("Audio Options...")),
                        })
                        {
                                "audioSelection": (self.audioSelection, _("Audio Options...")),
                        })
@@ -1473,7 +1479,6 @@ class InfoBarAudioSelection:
                n = audio and audio.getNumberOfTracks() or 0
                keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
                tlist = []
                n = audio and audio.getNumberOfTracks() or 0
                keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
                tlist = []
-               print "tlist:", tlist
                if n > 0:
                        self.audioChannel = service.audioChannel()
 
                if n > 0:
                        self.audioChannel = service.audioChannel()
 
@@ -1481,19 +1486,19 @@ class InfoBarAudioSelection:
                                i = audio.getTrackInfo(x)
                                language = i.getLanguage()
                                description = i.getDescription()
                                i = audio.getTrackInfo(x)
                                language = i.getLanguage()
                                description = i.getDescription()
-       
+
                                if LanguageCodes.has_key(language):
                                        language = LanguageCodes[language][0]
                                if LanguageCodes.has_key(language):
                                        language = LanguageCodes[language][0]
-       
+
                                if len(description):
                                        description += " (" + language + ")"
                                else:
                                        description = language
                                if len(description):
                                        description += " (" + language + ")"
                                else:
                                        description = language
-       
+
                                tlist.append((description, x))
                                tlist.append((description, x))
-                       
-                       selectedAudio = tlist[0][1]
-                       tlist.sort(lambda x,y : cmp(x[0], y[0]))
+
+                       selectedAudio = audio.getCurrentTrack()
+                       tlist.sort(key=lambda x: x[0])
 
                        selection = 2
                        for x in tlist:
 
                        selection = 2
                        for x in tlist:
@@ -1696,10 +1701,10 @@ class InfoBarNotifications:
                self.onExecBegin.append(self.checkNotifications)
                Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
                self.onClose.append(self.__removeNotification)
                self.onExecBegin.append(self.checkNotifications)
                Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
                self.onClose.append(self.__removeNotification)
-       
+
        def __removeNotification(self):
                Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
        def __removeNotification(self):
                Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
-       
+
        def checkNotificationsIfExecing(self):
                if self.execing:
                        self.checkNotifications()
        def checkNotificationsIfExecing(self):
                if self.execing:
                        self.checkNotifications()
@@ -1707,7 +1712,7 @@ class InfoBarNotifications:
        def checkNotifications(self):
                if len(Notifications.notifications):
                        n = Notifications.notifications[0]
        def checkNotifications(self):
                if len(Notifications.notifications):
                        n = Notifications.notifications[0]
-                       
+
                        Notifications.notifications = Notifications.notifications[1:]
                        cb = n[0]
 
                        Notifications.notifications = Notifications.notifications[1:]
                        cb = n[0]
 
@@ -1719,7 +1724,7 @@ class InfoBarNotifications:
                                dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
                        else:
                                dlg = self.session.open(n[1], *n[2], **n[3])
                                dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
                        else:
                                dlg = self.session.open(n[1], *n[2], **n[3])
-                       
+
                        # remember that this notification is currently active
                        d = (n[4], dlg)
                        Notifications.current_notifications.append(d)
                        # remember that this notification is currently active
                        d = (n[4], dlg)
                        Notifications.current_notifications.append(d)
@@ -1748,17 +1753,17 @@ class InfoBarCueSheetSupport:
        CUT_TYPE_OUT = 1
        CUT_TYPE_MARK = 2
        CUT_TYPE_LAST = 3
        CUT_TYPE_OUT = 1
        CUT_TYPE_MARK = 2
        CUT_TYPE_LAST = 3
-       
+
        ENABLE_RESUME_SUPPORT = False
        ENABLE_RESUME_SUPPORT = False
-       
-       def __init__(self):
-               self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions", 
+
+       def __init__(self, actionmap = "InfobarCueSheetActions"):
+               self["CueSheetActions"] = HelpableActionMap(self, actionmap,
                        {
                        {
-                               "jumpPreviousMark": (self.jumpPreviousMark, "jump to next marked position"),
-                               "jumpNextMark": (self.jumpNextMark, "jump to previous marked position"),
-                               "toggleMark": (self.toggleMark, "toggle a cut mark at the current position")
-                       }, prio=1) 
-               
+                               "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
+                               "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
+                               "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
+                       }, prio=1)
+
                self.cut_list = [ ]
                self.is_closing = False
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                self.cut_list = [ ]
                self.is_closing = False
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
@@ -1771,14 +1776,14 @@ class InfoBarCueSheetSupport:
                        return
                print "new service started! trying to download cuts!"
                self.downloadCuesheet()
                        return
                print "new service started! trying to download cuts!"
                self.downloadCuesheet()
-               
+
                if self.ENABLE_RESUME_SUPPORT:
                        last = None
                if self.ENABLE_RESUME_SUPPORT:
                        last = None
-                       
+
                        for (pts, what) in self.cut_list:
                                if what == self.CUT_TYPE_LAST:
                                        last = pts
                        for (pts, what) in self.cut_list:
                                if what == self.CUT_TYPE_LAST:
                                        last = pts
-                       
+
                        if last is not None:
                                self.resume_point = last
                                Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
                        if last is not None:
                                self.resume_point = last
                                Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
@@ -1788,6 +1793,11 @@ class InfoBarCueSheetSupport:
                        seekable = self.__getSeekable()
                        if seekable is not None:
                                seekable.seekTo(self.resume_point)
                        seekable = self.__getSeekable()
                        if seekable is not None:
                                seekable.seekTo(self.resume_point)
+               self.hideAfterResume()
+
+       def hideAfterResume(self):
+               if isinstance(self, InfoBarShowHide):
+                       self.hide()
 
        def __getSeekable(self):
                service = self.session.nav.getCurrentService()
 
        def __getSeekable(self):
                service = self.session.nav.getCurrentService()
@@ -1833,7 +1843,7 @@ class InfoBarCueSheetSupport:
                nearest = None
                for cp in self.cut_list:
                        diff = cmp(cp[0] - pts)
                nearest = None
                for cp in self.cut_list:
                        diff = cmp(cp[0] - pts)
-                       if diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
+                       if cp[1] == self.CUT_TYPE_MARK and diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
                                nearest = cp
                return nearest
 
                                nearest = cp
                return nearest
 
@@ -1842,9 +1852,9 @@ class InfoBarCueSheetSupport:
                if current_pos is None:
                        print "not seekable"
                        return
                if current_pos is None:
                        print "not seekable"
                        return
-               
+
                nearest_cutpoint = self.getNearestCutPoint(current_pos)
                nearest_cutpoint = self.getNearestCutPoint(current_pos)
-               
+
                if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
                        if onlyreturn:
                                return nearest_cutpoint
                if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
                        if onlyreturn:
                                return nearest_cutpoint
@@ -1852,17 +1862,23 @@ class InfoBarCueSheetSupport:
                                self.removeMark(nearest_cutpoint)
                elif not onlyremove and not onlyreturn:
                        self.addMark((current_pos, self.CUT_TYPE_MARK))
                                self.removeMark(nearest_cutpoint)
                elif not onlyremove and not onlyreturn:
                        self.addMark((current_pos, self.CUT_TYPE_MARK))
-               
+
                if onlyreturn:
                        return None
 
        def addMark(self, point):
                insort(self.cut_list, point)
                self.uploadCuesheet()
                if onlyreturn:
                        return None
 
        def addMark(self, point):
                insort(self.cut_list, point)
                self.uploadCuesheet()
+               self.showAfterCuesheetOperation()
 
        def removeMark(self, point):
                self.cut_list.remove(point)
                self.uploadCuesheet()
 
        def removeMark(self, point):
                self.cut_list.remove(point)
                self.uploadCuesheet()
+               self.showAfterCuesheetOperation()
+
+       def showAfterCuesheetOperation(self):
+               if isinstance(self, InfoBarShowHide):
+                       self.doShow()
 
        def __getCuesheet(self):
                service = self.session.nav.getCurrentService()
 
        def __getCuesheet(self):
                service = self.session.nav.getCurrentService()
@@ -1882,40 +1898,71 @@ class InfoBarCueSheetSupport:
                cue = self.__getCuesheet()
 
                if cue is None:
                cue = self.__getCuesheet()
 
                if cue is None:
-                       print "upload failed, no cuesheet interface"
-                       return
-               self.cut_list = cue.getCutList()
+                       print "download failed, no cuesheet interface"
+                       self.cut_list = [ ]
+               else:
+                       self.cut_list = cue.getCutList()
 
 class InfoBarSummary(Screen):
        skin = """
        <screen position="0,0" size="132,64">
 
 class InfoBarSummary(Screen):
        skin = """
        <screen position="0,0" size="132,64">
-               <widget source="CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
+               <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
                        <convert type="ClockToText">WithSeconds</convert>
                </widget>
                        <convert type="ClockToText">WithSeconds</convert>
                </widget>
-               <widget source="CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
+               <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
                        <convert type="ServiceName">Name</convert>
                </widget>
                        <convert type="ServiceName">Name</convert>
                </widget>
+               <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
+                       <convert type="EventTime">Progress</convert>
+               </widget>
        </screen>"""
 
        </screen>"""
 
+# for picon:  (path="piconlcd" will use LCD picons)
+#              <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
+#                      <convert type="ServiceName">Reference</convert>
+#              </widget>
+
        def __init__(self, session, parent):
                Screen.__init__(self, session)
        def __init__(self, session, parent):
                Screen.__init__(self, session)
-               self["CurrentService"] = CurrentService(self.session.nav)
-               self["CurrentTime"] = Clock()
 
 class InfoBarSummarySupport:
        def __init__(self):
                pass
 
 class InfoBarSummarySupport:
        def __init__(self):
                pass
-       
+
        def createSummary(self):
                return InfoBarSummary
 
        def createSummary(self):
                return InfoBarSummary
 
+class InfoBarMoviePlayerSummary(Screen):
+       skin = """
+       <screen position="0,0" size="132,64">
+               <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
+                       <convert type="ClockToText">WithSeconds</convert>
+               </widget>
+               <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
+                       <convert type="ServiceName">Name</convert>
+               </widget>
+               <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
+                       <convert type="ServicePosition">Position</convert>
+               </widget>
+       </screen>"""
+
+       def __init__(self, session, parent):
+               Screen.__init__(self, session)
+
+class InfoBarMoviePlayerSummarySupport:
+       def __init__(self):
+               pass
+
+       def createSummary(self):
+               return InfoBarMoviePlayerSummary
+
 class InfoBarTeletextPlugin:
        def __init__(self):
                self.teletext_plugin = None
 class InfoBarTeletextPlugin:
        def __init__(self):
                self.teletext_plugin = None
-               
+
                for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
                        self.teletext_plugin = p
                for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
                        self.teletext_plugin = p
-               
+
                if self.teletext_plugin is not None:
                        self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
                                {
                if self.teletext_plugin is not None:
                        self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
                                {
@@ -1959,7 +2006,7 @@ class InfoBarSubtitleSupport(object):
        def getCurrentServiceSubtitle(self):
                service = self.session.nav.getCurrentService()
                return service and service.subtitle()
        def getCurrentServiceSubtitle(self):
                service = self.session.nav.getCurrentService()
                return service and service.subtitle()
-       
+
        def setSubtitlesEnable(self, enable=True):
                subtitle = self.getCurrentServiceSubtitle()
                if enable and self.__selected_subtitle is not None:
        def setSubtitlesEnable(self, enable=True):
                subtitle = self.getCurrentServiceSubtitle()
                if enable and self.__selected_subtitle is not None:
@@ -1996,7 +2043,7 @@ class InfoBarServiceErrorPopupSupport:
                service = self.session.nav.getCurrentService()
                info = service and service.info()
                error = info and info.getInfo(iServiceInformation.sDVBState)
                service = self.session.nav.getCurrentService()
                info = service and service.info()
                error = info and info.getInfo(iServiceInformation.sDVBState)
-               
+
                if error == self.last_error:
                        error = None
                else:
                if error == self.last_error:
                        error = None
                else:
Clone of git://git.opendreambox.org/git/enigma2.git before dream multimedia removed all the engima2 sources