show bskyb HD services in channelselection

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

diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index babc772fb582d4b0f94464b2b3a42019c986b972..b62a466b7d339962ce3766f1f390013dcb62b53d 100644 (file)
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -5,20 +5,13 @@ 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.RadioText import RadioText
-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
-
+from Components.config import config, ConfigBoolean, ConfigClock

 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
 
 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
 


@@ -32,7 +25,9 @@ from Screens.MinuteInput import MinuteInput
 from Screens.TimerSelection import TimerSelection
 from Screens.PictureInPicture import PictureInPicture
 from Screens.SubtitleDisplay import SubtitleDisplay
 from Screens.TimerSelection import TimerSelection
 from Screens.PictureInPicture import PictureInPicture
 from Screens.SubtitleDisplay import SubtitleDisplay

+from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive

 from Screens.SleepTimerEdit import SleepTimerEdit
 from Screens.SleepTimerEdit import SleepTimerEdit

+from Screens.TimeDateInput import TimeDateInput

 from ServiceReference import ServiceReference
 
 from Tools import Notifications
 from ServiceReference import ServiceReference
 
 from Tools import Notifications


@@ -41,7 +36,7 @@ from Tools.Directories import SCOPE_HDD, resolveFilename
 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
        iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
 
 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
        iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
 

-from time import time
+from time import time, localtime, strftime

 from os import stat as os_stat
 from bisect import insort
 
 from os import stat as os_stat
 from bisect import insort
 


@@ -51,7 +46,6 @@ from Menu import MainMenu, mdom
 class InfoBarDish:
        def __init__(self):
                self.dishDialog = self.session.instantiateDialog(Dish)
 class InfoBarDish:
        def __init__(self):
                self.dishDialog = self.session.instantiateDialog(Dish)

-               self.onLayoutFinish.append(self.dishDialog.show)

 
 class InfoBarShowHide:
        """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
 
 class InfoBarShowHide:
        """ InfoBar show/hide control, accepts toggleShow and hide actions, might start


@@ -60,30 +54,38 @@ 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"] ,
                        {
                                "toggleShow": self.toggleShow,
                                "hide": self.hide,
        def __init__(self):
                self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
                        {
                                "toggleShow": self.toggleShow,
                                "hide": self.hide,

+                       }, 1) # lower prio to make it possible to override ok and cancel..
+
+               self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+                       {
+                               iPlayableService.evStart: self.serviceStarted,

                        })
 
                self.__state = self.STATE_SHOWN
                self.__locked = 0
                        })
 
                self.__state = self.STATE_SHOWN
                self.__locked = 0

-               
-               self.onExecBegin.append(self.show)
-               
+

                self.hideTimer = eTimer()
                self.hideTimer = eTimer()

-               self.hideTimer.timeout.get().append(self.doTimerHide)
+               self.hideTimer.callback.append(self.doTimerHide)

                self.hideTimer.start(5000, True)
                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)
 

+       def serviceStarted(self):
+               if self.execing:
+                       if config.usage.show_infobar_on_zap.value:
+                               self.doShow()
+

        def __onShow(self):
                self.__state = self.STATE_SHOWN
                self.startHideTimer()
        def __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


@@ -114,7 +116,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:


@@ -123,7 +125,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


@@ -152,7 +154,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,


@@ -169,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:


@@ -192,11 +194,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 config.usage.show_infobar_on_zap.value:
-                               self.doShow()
+                       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


@@ -244,12 +248,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)
 


@@ -295,7 +299,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)
 


@@ -315,8 +319,6 @@ class InfoBarChannelSelection:
                else:
                        self.servicelist.moveUp()
                self.servicelist.zap()
                else:
                        self.servicelist.moveUp()
                self.servicelist.zap()

-               if config.usage.show_infobar_on_zap.value:
-                       self.doShow()

 
        def zapDown(self):
                if self.servicelist.inBouquet():
 
        def zapDown(self):
                if self.servicelist.inBouquet():


@@ -334,13 +336,11 @@ class InfoBarChannelSelection:
                else:
                        self.servicelist.moveDown()
                self.servicelist.zap()
                else:
                        self.servicelist.moveDown()
                self.servicelist.zap()

-               if config.usage.show_infobar_on_zap.value:
-                       self.doShow()

 
 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...")),
                        })


@@ -401,11 +401,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?


@@ -473,7 +482,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):


@@ -532,51 +541,100 @@ 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 InfoBarRadioText:
-       """provides radio (RDS) text info display"""
+class InfoBarRdsDecoder:
+       """provides RDS and Rass support/display"""

        def __init__(self):
        def __init__(self):

-               self["RadioText"] = RadioText(self.session.nav)
+               self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
+               self.rass_interactive = None
+
+               self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+                       {
+                               iPlayableService.evEnd: self.__serviceStopped,
+                               iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
+                       })
+
+               self["RdsActions"] = ActionMap(["InfobarRdsActions"],
+               {
+                       "startRassInteractive": self.startRassInteractive
+               },-1)
+
+               self["RdsActions"].setEnabled(False)
+
+               self.onLayoutFinish.append(self.rds_display.show)
+               self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
+
+       def RassInteractivePossibilityChanged(self, state):
+               self["RdsActions"].setEnabled(state)
+
+       def RassSlidePicChanged(self):
+               if not self.rass_interactive:
+                       service = self.session.nav.getCurrentService()
+                       decoder = service and service.rdsDecoder()
+                       if decoder:
+                               decoder.showRassSlidePicture()
+
+       def __serviceStopped(self):
+               if self.rass_interactive is not None:
+                       rass_interactive = self.rass_interactive
+                       self.rass_interactive = None
+                       rass_interactive.close()
+
+       def startRassInteractive(self):
+               self.rds_display.hide()
+               self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
+
+       def RassInteractiveClosed(self, *val):
+               if self.rass_interactive is not None:
+                       self.rass_interactive = None
+                       self.RassSlidePicChanged()
+               self.rds_display.show()

 
 class InfoBarServiceName:
        def __init__(self):
 
 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_SM_HALF = (0, 0, 2, "/2")
        SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4")
        SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8")

-       
-       def __init__(self):
+
+       SEEK_STATE_EOF = (1, 0, 0, "END")
+
+       def __init__(self, actionmap = "InfobarSeekActions"):

                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
                                iPlayableService.evStart: self.__serviceStarted,
                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,
                        })


@@ -585,55 +643,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):
                        def action(self, contexts, action):

+                               print "action:", action

                                if action[:5] == "seek:":
                                        time = int(action[5:])
                                        self.screen.seekRelative(time * 90000)
                                if action[:5] == "seek:":
                                        time = int(action[5:])
                                        self.screen.seekRelative(time * 90000)

+                                       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
 
                        }, prio=-1)
                        # give them a little more priority to win over color buttons
 

+               self["SeekActions"].setEnabled(False)
+

                self.seekstate = self.SEEK_STATE_PLAY
                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:


@@ -643,9 +702,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


@@ -663,37 +722,38 @@ class InfoBarSeek:
 
        def __serviceStarted(self):
                self.seekstate = self.SEEK_STATE_PLAY
 
        def __serviceStarted(self):
                self.seekstate = self.SEEK_STATE_PLAY

+               self.__seekableStatusChanged()

 
        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

-               
+

                pauseable = service.pause()
 
                if pauseable is None:
                        print "not pauseable."
                        state = self.SEEK_STATE_PLAY
                pauseable = service.pause()
 
                if pauseable is None:
                        print "not pauseable."
                        state = self.SEEK_STATE_PLAY

-               
+

                oldstate = self.seekstate
                self.seekstate = state
                oldstate = self.seekstate
                self.seekstate = state

-               
+

                for i in range(3):
                        if oldstate[i] != self.seekstate[i]:
                                (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
 
                for c in self.onPlayStateChanged:
                        c(self.seekstate)
                for i in range(3):
                        if oldstate[i] != self.seekstate[i]:
                                (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
 
                for c in self.onPlayStateChanged:
                        c(self.seekstate)

-               
+

                self.checkSkipShowHideLock()
 
                return True
                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()


@@ -711,41 +771,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 = {


@@ -753,104 +796,139 @@ 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,

-                               self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
+                               self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER,
+                               self.SEEK_STATE_EOF: self.SEEK_STATE_EOF,

                        }
                self.setSeekState(lookup[self.seekstate])
                        }
                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_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_SM_EIGHTH: self.SEEK_STATE_PAUSE,
+                               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
 
        def __evEOF(self):
                        if wantlock and not self.lockedBecauseOfSkipping:
                                self.lockShow()
                                self.lockedBecauseOfSkipping = True
 
        def __evEOF(self):

-               if self.seekstate != self.SEEK_STATE_PLAY:
-                       self.setSeekState(self.SEEK_STATE_PAUSE)
-                       # HACK
-                       #self.getSeek().seekRelative(1, -90000)
-                       self.setSeekState(self.SEEK_STATE_PLAY)
+               if self.seekstate == self.SEEK_STATE_EOF:
+                       return
+               if self.seekstate[1] < 0: # SEEK_STATE_BACK_*X
+                       print "end of stream while seeking back, ignoring."
+                       return
+
+               # if we are seeking, we try to end up ~1s before the end, and pause there.
+               if not self.seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
+                       self.setSeekState(self.SEEK_STATE_EOF)
+                       self.seekRelativeToEnd(-90000)

                else:
                else:

-                       self.setSeekState(self.SEEK_STATE_PAUSE)
-       
+                       self.setSeekState(self.SEEK_STATE_EOF)
+

        def __evSOF(self):
                self.setSeekState(self.SEEK_STATE_PLAY)
                self.doSeek(0)
 
        def seekRelative(self, diff):
        def __evSOF(self):
                self.setSeekState(self.SEEK_STATE_PLAY)
                self.doSeek(0)
 
        def seekRelative(self, diff):

-               seekable = self.getSeek()
-               if seekable is not None:
-                       seekable.seekRelative(1, diff)
+               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:
+                       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
+
+               # relative-to-end seeking is implemented as absolutes seeks with negative time
+               self.seekAbsolute(diff)

 
        def seekAbsolute(self, abs):
                seekable = self.getSeek()
 
        def seekAbsolute(self, abs):
                seekable = self.getSeek()


@@ -885,15 +963,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!


@@ -903,7 +981,7 @@ class InfoBarShowMovies:
 # Timeshift works the following way:
 #                                         demux0   demux1                    "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
 # - normal playback                       TUNER    unused      PLAY               enable                disable              disable
 # Timeshift works the following way:
 #                                         demux0   demux1                    "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
 # - normal playback                       TUNER    unused      PLAY               enable                disable              disable

-# - user presses "yellow" button.         TUNER    record      PAUSE              enable                disable              enable
+# - user presses "yellow" button.         FILE     record      PAUSE              enable                disable              enable

 # - user presess pause again              FILE     record      PLAY               enable                disable              enable
 # - user fast forwards                    FILE     record      FF                 enable                disable              enable
 # - end of timeshift buffer reached       TUNER    record      PLAY               enable                enable               disable
 # - user presess pause again              FILE     record      PLAY               enable                disable              enable
 # - user fast forwards                    FILE     record      FF                 enable                disable              enable
 # - end of timeshift buffer reached       TUNER    record      PLAY               enable                enable               disable


@@ -926,28 +1004,28 @@ 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'
                        }, prio=1)
                self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
                        {
                        {
                                "timeshiftStart": (self.startTimeshift, _("start timeshift")),  # the "yellow key"
                                "timeshiftStop": (self.stopTimeshift, _("stop timeshift"))      # currently undefined :), probably 'TV'
                        }, prio=1)
                self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
                        {

-                               "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key"
-                               "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause  # something like "backward key"
+                               "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
+                               "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause  # something like "pause key"

                        }, prio=-1) # priority over record
 
                self.timeshift_enabled = 0
                self.timeshift_state = 0
                        }, prio=-1) # priority over record
 
                self.timeshift_enabled = 0
                self.timeshift_state = 0

-               self.ts_pause_timer = eTimer()
-               self.ts_pause_timer.timeout.get().append(self.pauseService)
+               self.ts_rewind_timer = eTimer()
+               self.ts_rewind_timer.callback.append(self.rewindService)

 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evStart: self.__serviceStarted,
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
                        })
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evStart: self.__serviceStarted,
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
                        })

-       
+

        def getTimeshift(self):
                service = self.session.nav.getCurrentService()
                return service and service.timeshift()
        def getTimeshift(self):
                service = self.session.nav.getCurrentService()
                return service and service.timeshift()


@@ -958,8 +1036,8 @@ class InfoBarTimeshift:
                if ts is None:
                        self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
                        print "no ts interface"
                if ts is None:
                        self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
                        print "no ts interface"

-                       return 0;
-               
+                       return 0
+

                if self.timeshift_enabled:
                        print "hu, timeshift already enabled?"
                else:
                if self.timeshift_enabled:
                        print "hu, timeshift already enabled?"
                else:


@@ -968,10 +1046,11 @@ class InfoBarTimeshift:
 
                                # we remove the "relative time" for now.
                                #self.pvrStateDialog["timeshift"].setRelative(time.time())
 
                                # we remove the "relative time" for now.
                                #self.pvrStateDialog["timeshift"].setRelative(time.time())

-                                       
+

                                # PAUSE.
                                # PAUSE.

-                               self.setSeekState(self.SEEK_STATE_PAUSE)
-                               
+                               #self.setSeekState(self.SEEK_STATE_PAUSE)
+                               self.activateTimeshiftEnd(False)
+

                                # enable the "TimeshiftEnableActions", which will override
                                # the startTimeshift actions
                                self.__seekableStatusChanged()
                                # enable the "TimeshiftEnableActions", which will override
                                # the startTimeshift actions
                                self.__seekableStatusChanged()


@@ -1000,45 +1079,42 @@ class InfoBarTimeshift:
 
                # disable actions
                self.__seekableStatusChanged()
 
                # disable actions
                self.__seekableStatusChanged()

-       
+

        # activates timeshift, and seeks to (almost) the end
        # activates timeshift, and seeks to (almost) the end

-       def activateTimeshiftEnd(self):
+       def activateTimeshiftEnd(self, back = True):

                ts = self.getTimeshift()
                ts = self.getTimeshift()

-               
+               print "activateTimeshiftEnd"
+

                if ts is None:
                        return
                if ts is None:
                        return

-               
+

                if ts.isTimeshiftActive():
                        print "!! activate timeshift called - but shouldn't this be a normal pause?"
                        self.pauseService()
                else:
                if ts.isTimeshiftActive():
                        print "!! activate timeshift called - but shouldn't this be a normal pause?"
                        self.pauseService()
                else:

-                       self.setSeekState(self.SEEK_STATE_PLAY)
-                       ts.activateTimeshift()
-                       self.seekRelative(0)
-       
+                       print "play, ..."
+                       ts.activateTimeshift() # activate timeshift will automatically pause
+                       self.setSeekState(self.SEEK_STATE_PAUSE)
+                       self.seekRelativeToEnd(-90000) # seek approx. 1 sec before end
+
+               if back:
+                       self.ts_rewind_timer.start(200, 1)
+
+       def rewindService(self):
+               self.setSeekState(self.SEEK_STATE_BACK_16X)
+

        # same as activateTimeshiftEnd, but pauses afterwards.
        def activateTimeshiftEndAndPause(self):
        # same as activateTimeshiftEnd, but pauses afterwards.
        def activateTimeshiftEndAndPause(self):

-               state = self.seekstate
-               self.activateTimeshiftEnd()
-               
-               # well, this is "andPause", but it could be pressed from pause,
-               # when pausing on the (fake-)"live" picture, so an un-pause
-               # is perfectly ok.
-               
-               print "now, pauseService"
-               if state == self.SEEK_STATE_PLAY:
-                       print "is PLAYING, start pause timer"
-                       self.ts_pause_timer.start(200, 1)
-               else:
-                       print "unpause"
-                       self.unPauseService()
-       
+               print "activateTimeshiftEndAndPause"
+               #state = self.seekstate
+               self.activateTimeshiftEnd(False)
+

        def __seekableStatusChanged(self):
                enabled = False
        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


@@ -1057,10 +1133,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...")),


@@ -1068,13 +1144,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):


@@ -1083,7 +1159,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" ]


@@ -1129,10 +1205,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):


@@ -1140,13 +1216,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
 


@@ -1164,31 +1240,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


@@ -1197,7 +1277,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:


@@ -1210,14 +1290,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",


@@ -1225,18 +1315,22 @@ class InfoBarInstantRecord:
                                "instantRecord": (self.instantRecord, _("Instant Record...")),
                        })
                self.recording = []
                                "instantRecord": (self.instantRecord, _("Instant Record...")),
                        })
                self.recording = []

+#### DEPRECATED CODE ####

                self["BlinkingPoint"] = BlinkingPixmapConditional()
                self["BlinkingPoint"] = BlinkingPixmapConditional()

-               self["BlinkingPoint"].hide()

                self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
                self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)

+               self["BlinkingPoint"].deprecationInfo = (
+                       "session.RecordState source, Pixmap renderer and "
+                       "ConditionalShowHide/Blink Converter", "2008-02")
+#########################

 
 

-       def stopCurrentRecording(self, entry = -1):     
+       def stopCurrentRecording(self, entry = -1):

                if entry is not None and entry != -1:
                        self.session.nav.RecordTimer.removeEntry(self.recording[entry])
                        self.recording.remove(self.recording[entry])
 
        def startInstantRecording(self, limitEvent = False):
                serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
                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:


@@ -1255,7 +1349,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]


@@ -1266,15 +1360,17 @@ 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())
-               
+
+#### DEPRECATED CODE ####
+               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:


@@ -1285,7 +1381,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 = []


@@ -1294,29 +1390,46 @@ 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:
                                self.changeDuration(0)
                        else:
                                self.session.openWithCallback(self.changeDuration, TimerSelection, list)
 
                if answer[1] == "changeduration":
                        if len(self.recording) == 1:
                                self.changeDuration(0)
                        else:
                                self.session.openWithCallback(self.changeDuration, TimerSelection, list)

+               elif answer[1] == "changeendtime":
+                       if len(self.recording) == 1:
+                               self.setEndtime(0)
+                       else:
+                               self.session.openWithCallback(self.setEndtime, TimerSelection, list)

                elif answer[1] == "stop":
                        if len(self.recording) == 1:
                                self.stopCurrentRecording(0)
                        else:
                                self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
                elif answer[1] == "stop":
                        if len(self.recording) == 1:
                                self.stopCurrentRecording(0)
                        else:
                                self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)

-               if answer[1] == "indefinitely" or answer[1] == "manualduration" or answer[1] == "event":
-                       limitEvent = False
-                       if answer[1] == "event":
-                               limitEvent = True
+               elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
+                       self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)

                        if answer[1] == "manualduration":
                        if answer[1] == "manualduration":

-                               self.selectedEntry = len(self.recording)
-                               self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
-                       self.startInstantRecording(limitEvent = limitEvent)
-                       
+                               self.changeDuration(len(self.recording)-1)
+                       elif answer[1] == "manualendtime":
+                               self.setEndtime(len(self.recording)-1)

                print "after:\n", self.recording
 
                print "after:\n", self.recording
 

+       def setEndtime(self, entry):
+               if entry is not None:
+                       self.selectedEntry = entry
+                       self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
+                       dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
+                       dlg.setTitle(_("Please change recording endtime"))
+
+       def TimeDateInputClosed(self, ret):
+               if len(ret) > 1:
+                       if ret[0]:
+                               localendtime = localtime(ret[1])
+                               print "stopping recording at", strftime("%c", localendtime)
+                               self.recording[self.selectedEntry].end = ret[1]
+                               self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
+

        def changeDuration(self, entry):
                if entry is not None:
                        self.selectedEntry = entry
        def changeDuration(self, entry):
                if entry is not None:
                        self.selectedEntry = entry


@@ -1340,9 +1453,11 @@ class InfoBarInstantRecord:
                                title=_("A recording is currently running.\nWhat do you want to do?"), \
                                list=[(_("stop recording"), "stop"), \
                                (_("change recording (duration)"), "changeduration"), \
                                title=_("A recording is currently running.\nWhat do you want to do?"), \
                                list=[(_("stop recording"), "stop"), \
                                (_("change recording (duration)"), "changeduration"), \

+                               (_("change recording (endtime)"), "changeendtime"), \

                                (_("add recording (indefinitely)"), "indefinitely"), \
                                (_("add recording (stop after current event)"), "event"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                (_("add recording (indefinitely)"), "indefinitely"), \
                                (_("add recording (stop after current event)"), "event"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \

+                               (_("add recording (enter recording endtime)"), "manualendtime"), \

                                (_("do nothing"), "no")])
                else:
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
                                (_("do nothing"), "no")])
                else:
                        self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \


@@ -1350,13 +1465,14 @@ class InfoBarInstantRecord:
                                list=[(_("add recording (indefinitely)"), "indefinitely"), \
                                (_("add recording (stop after current event)"), "event"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \
                                list=[(_("add recording (indefinitely)"), "indefinitely"), \
                                (_("add recording (stop after current event)"), "event"), \
                                (_("add recording (enter recording duration)"), "manualduration"), \

+                               (_("add recording (enter recording endtime)"), "manualendtime"), \

                                (_("don't record"), "no")])
 
 from Tools.ISO639 import LanguageCodes
 
 class InfoBarAudioSelection:
        def __init__(self):
                                (_("don't record"), "no")])
 
 from Tools.ISO639 import LanguageCodes
 
 class InfoBarAudioSelection:
        def __init__(self):

-               self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", 
+               self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",

                        {
                                "audioSelection": (self.audioSelection, _("Audio Options...")),
                        })
                        {
                                "audioSelection": (self.audioSelection, _("Audio Options...")),
                        })


@@ -1368,7 +1484,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()
 


@@ -1376,19 +1491,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:


@@ -1474,8 +1589,6 @@ class InfoBarSubserviceSelection:
                                if newservice.valid():
                                        del subservices
                                        del service
                                if newservice.valid():
                                        del subservices
                                        del service

-                                       if config.usage.show_infobar_on_zap.value:
-                                               self.doShow()

                                        self.session.nav.playService(newservice)
 
        def subserviceSelection(self):
                                        self.session.nav.playService(newservice)
 
        def subserviceSelection(self):


@@ -1516,8 +1629,6 @@ class InfoBarSubserviceSelection:
                                        self.session.open(SubservicesQuickzap, service[2])
                        else:
                                self["SubserviceQuickzapAction"].setEnabled(True)
                                        self.session.open(SubservicesQuickzap, service[2])
                        else:
                                self["SubserviceQuickzapAction"].setEnabled(True)

-                               if config.usage.show_infobar_on_zap.value:
-                                       self.doShow()

                                self.session.nav.playService(service[1])
 
        def addSubserviceToBouquetCallback(self, service):
                                self.session.nav.playService(service[1])
 
        def addSubserviceToBouquetCallback(self, service):


@@ -1548,20 +1659,35 @@ class InfoBarSubserviceSelection:
 
 class InfoBarAdditionalInfo:
        def __init__(self):
 
 class InfoBarAdditionalInfo:
        def __init__(self):

-               self["NimA"] = Pixmap()
-               self["NimB"] = Pixmap()
-               self["NimA_Active"] = Pixmap()
-               self["NimB_Active"] = Pixmap()

 
                self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
                self["TimeshiftPossible"] = self["RecordingPossible"]
                self["ExtensionsAvailable"] = Boolean(fixed=1)
 
 
                self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
                self["TimeshiftPossible"] = self["RecordingPossible"]
                self["ExtensionsAvailable"] = Boolean(fixed=1)
 

-               self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
+######### 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)
 
                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()
        def tunerUseMaskChanged(self, mask):
                if mask&1:
                        self["NimA_Active"].show()


@@ -1573,7 +1699,7 @@ class InfoBarAdditionalInfo:
                        self["NimB_Active"].hide()
 
        def checkTunerState(self, service):
                        self["NimB_Active"].hide()
 
        def checkTunerState(self, service):

-               info = service.frontendInfo()
+               info = service and service.frontendInfo()

                feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber)
                if feNumber is None:
                        self["NimA"].hide()
                feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber)
                if feNumber is None:
                        self["NimA"].hide()


@@ -1587,18 +1713,19 @@ class InfoBarAdditionalInfo:
 
        def gotServiceEvent(self, ev):
                service = self.session.nav.getCurrentService()
 
        def gotServiceEvent(self, ev):
                service = self.session.nav.getCurrentService()

-               if ev == iPlayableService.evUpdatedInfo:
+               if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd:

                        self.checkTunerState(service)
                        self.checkTunerState(service)

+####################################

 
 class InfoBarNotifications:
        def __init__(self):
                self.onExecBegin.append(self.checkNotifications)
                Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
                self.onClose.append(self.__removeNotification)
 
 class InfoBarNotifications:
        def __init__(self):
                self.onExecBegin.append(self.checkNotifications)
                Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
                self.onClose.append(self.__removeNotification)

-       
+

        def __removeNotification(self):
                Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
        def __removeNotification(self):
                Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)

-       
+

        def checkNotificationsIfExecing(self):
                if self.execing:
                        self.checkNotifications()
        def checkNotificationsIfExecing(self):
                if self.execing:
                        self.checkNotifications()


@@ -1606,14 +1733,19 @@ 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]

+
+                       if n[3].has_key("onSessionOpenCallback"):
+                               n[3]["onSessionOpenCallback"]()
+                               del n[3]["onSessionOpenCallback"]
+

                        if cb is not None:
                                dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
                        else:
                                dlg = self.session.open(n[1], *n[2], **n[3])
                        if cb is not None:
                                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)


@@ -1642,17 +1774,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=


@@ -1665,14 +1797,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)


@@ -1682,6 +1814,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()


@@ -1727,7 +1864,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
 


@@ -1736,9 +1873,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


@@ -1746,17 +1883,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()


@@ -1776,40 +1919,79 @@ 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.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
+                       <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
+                       <convert type="ConditionalShowHide">Blink</convert>
+               </widget>
+               <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):
        def __init__(self, session, parent):

-               Screen.__init__(self, session)
-               self["CurrentService"] = CurrentService(self.session.nav)
-               self["CurrentTime"] = Clock()
+               Screen.__init__(self, session, parent = parent)

 
 class InfoBarSummarySupport:
        def __init__(self):
                pass
 
 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.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
+                       <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
+                       <convert type="ConditionalShowHide">Blink</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",
                                {


@@ -1833,6 +2015,7 @@ class InfoBarSubtitleSupport(object):
                                iPlayableService.evUpdatedInfo: self.__updatedInfo
                        })
                self.cached_subtitle_checked = False
                                iPlayableService.evUpdatedInfo: self.__updatedInfo
                        })
                self.cached_subtitle_checked = False

+               self.__selected_subtitle = None

 
        def __serviceStopped(self):
                self.subtitle_window.hide()
 
        def __serviceStopped(self):
                self.subtitle_window.hide()


@@ -1843,8 +2026,7 @@ class InfoBarSubtitleSupport(object):
                if not self.cached_subtitle_checked:
                        subtitle = self.getCurrentServiceSubtitle()
                        self.cached_subtitle_checked = True
                if not self.cached_subtitle_checked:
                        subtitle = self.getCurrentServiceSubtitle()
                        self.cached_subtitle_checked = True

-                       if subtitle:
-                               self.__selected_subtitle = subtitle.getCachedSubtitle()
+                       self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()

                        if self.__selected_subtitle:
                                subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
                                self.subtitle_window.show()
                        if self.__selected_subtitle:
                                subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
                                self.subtitle_window.show()


@@ -1853,7 +2035,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:


@@ -1890,7 +2072,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:


@@ -1905,7 +2087,8 @@ class InfoBarServiceErrorPopupSupport:
                        eDVBServicePMTHandler.eventNewProgramInfo: None,
                        eDVBServicePMTHandler.eventTuned: None,
                        eDVBServicePMTHandler.eventSOF: None,
                        eDVBServicePMTHandler.eventNewProgramInfo: None,
                        eDVBServicePMTHandler.eventTuned: None,
                        eDVBServicePMTHandler.eventSOF: None,

-                       eDVBServicePMTHandler.eventEOF: None
+                       eDVBServicePMTHandler.eventEOF: None,
+                       eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),

                }
 
                error = errors.get(error) #this returns None when the key not exist in the dict
                }
 
                error = errors.get(error) #this returns None when the key not exist in the dict