make some texts translatable and translate it to german languag

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

diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index 8d4360130eb6d3e13295dbe14e310415bbefe590..0241b6dcd6afb17d084f992b7a1b113eb515f607 100644 (file)
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -1,28 +1,38 @@
-from Screen import Screen
+from ChannelSelection import ChannelSelection, BouquetSelector
+

 from Components.ActionMap import ActionMap, HelpableActionMap
 from Components.ActionMap import NumberActionMap
 from Components.ActionMap import ActionMap, HelpableActionMap
 from Components.ActionMap import NumberActionMap

+from Components.BlinkingPixmap import BlinkingPixmapConditional
+from Components.Harddisk import harddiskmanager
+from Components.Input import Input

 from Components.Label import *
 from Components.Label import *

+from Components.Pixmap import Pixmap, PixmapConditional
+from Components.PluginComponent import plugins

 from Components.ProgressBar import *
 from Components.ProgressBar import *

+from Components.ServiceEventTracker import ServiceEventTracker
+from Components.Sources.CurrentService import CurrentService
+from Components.Sources.EventInfo import EventInfo
+from Components.Sources.FrontendStatus import FrontendStatus
+from Components.Sources.Boolean import Boolean
+from Components.Sources.Clock import Clock
+from Components.TimerList import TimerEntryComponent
+from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry

 from Components.config import configfile, configsequencearg
 from Components.config import configfile, configsequencearg

-from Components.config import config, configElement, ConfigSubsection, configSequence
-from ChannelSelection import ChannelSelection, BouquetSelector
-
-from Components.Pixmap import Pixmap, PixmapConditional
-from Components.BlinkingPixmap import BlinkingPixmapConditional
-from Components.ServiceName import ServiceName
-from Components.EventInfo import EventInfo, EventInfoProgress

 
 

-from ServiceReference import ServiceReference

 from EpgSelection import EPGSelection
 from EpgSelection import EPGSelection

+from Plugins.Plugin import PluginDescriptor

 
 

-from Screens.MessageBox import MessageBox
+from Screen import Screen
+from Screens.ChoiceBox import ChoiceBox

 from Screens.Dish import Dish
 from Screens.Dish import Dish

-from Screens.Standby import Standby
-from Screens.EventView import EventViewEPGSelect
+from Screens.EventView import EventViewEPGSelect, EventViewSimple
+from Screens.InputBox import InputBox
+from Screens.MessageBox import MessageBox

 from Screens.MinuteInput import MinuteInput
 from Screens.MinuteInput import MinuteInput

-from Components.Harddisk import harddiskmanager
-
-from Components.ServiceEventTracker import ServiceEventTracker
+from Screens.TimerSelection import TimerSelection
+from Screens.PictureInPicture import PictureInPicture
+from Screens.SubtitleDisplay import SubtitleDisplay
+from ServiceReference import ServiceReference

 
 from Tools import Notifications
 from Tools.Directories import *
 
 from Tools import Notifications
 from Tools.Directories import *


@@ -161,41 +171,6 @@ class NumberZap(Screen):
                self.Timer.timeout.get().append(self.keyOK)
                self.Timer.start(3000, True)
 
                self.Timer.timeout.get().append(self.keyOK)
                self.Timer.start(3000, True)
 

-class InfoBarPowerKey:
-       """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
-       
-       def __init__(self):
-               self.powerKeyTimer = eTimer()
-               self.powerKeyTimer.timeout.get().append(self.powertimer)
-               self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
-                       {
-                               "powerdown": self.powerdown,
-                               "powerup": self.powerup,
-                               "discreteStandby": (self.standby, "Go standby"),
-                               "discretePowerOff": (self.quit, "Go to deep standby"),
-                       })
-
-       def powertimer(self):   
-               print "PowerOff - Now!"
-               self.quit()
-       
-       def powerdown(self):
-               self.standbyblocked = 0
-               self.powerKeyTimer.start(3000, True)
-
-       def powerup(self):
-               self.powerKeyTimer.stop()
-               if self.standbyblocked == 0:
-                       self.standbyblocked = 1
-                       self.standby()
-
-       def standby(self):
-               self.session.open(Standby, self)
-
-       def quit(self):
-               # halt
-               quitMainloop(1)
-

 class InfoBarNumberZap:
        """ Handles an initial number for NumberZapping """
        def __init__(self):
 class InfoBarNumberZap:
        """ Handles an initial number for NumberZapping """
        def __init__(self):


@@ -265,23 +240,47 @@ class InfoBarNumberZap:
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 

+config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1);
+

 class InfoBarChannelSelection:
        """ 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)
 class InfoBarChannelSelection:
        """ 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)

+               
+               if config.misc.initialchannelselection.value == 1:
+                       self.onShown.append(self.firstRun)

 
                self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
                        {
                                "switchChannelUp": self.switchChannelUp,
                                "switchChannelDown": self.switchChannelDown,
 
                self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
                        {
                                "switchChannelUp": self.switchChannelUp,
                                "switchChannelDown": self.switchChannelDown,

-                               "zapUp": (self.zapUp, _("next channel")),
-                               "zapDown": (self.zapDown, _("previous channel")),
+                               "zapUp": (self.zapUp, _("previous channel")),
+                               "zapDown": (self.zapDown, _("next channel")),

                                "historyBack": (self.historyBack, _("previous channel in history")),
                                "historyBack": (self.historyBack, _("previous channel in history")),

-                               "historyNext": (self.historyNext, _("next channel in history"))
+                               "historyNext": (self.historyNext, _("next channel in history")),
+                               "openServiceList": (self.openServiceList, _("open service list")),

                        })
 
                        })
 

+       def showTvChannelList(self, zap=False):
+               self.servicelist.setModeTv()
+               if zap:
+                       self.servicelist.zap()
+               self.session.execDialog(self.servicelist)
+
+       def showRadioChannelList(self, zap=False):
+               self.servicelist.setModeRadio()
+               if zap:
+                       self.servicelist.zap()
+               self.session.execDialog(self.servicelist)
+
+       def firstRun(self):
+               self.onShown.remove(self.firstRun)
+               config.misc.initialchannelselection.value = 0
+               config.misc.initialchannelselection.save()
+               self.switchChannelDown()
+

        def historyBack(self):
                self.servicelist.historyBack()
 
        def historyBack(self):
                self.servicelist.historyBack()
 


@@ -295,6 +294,9 @@ 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 zapUp(self):
                if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes":
 
        def zapUp(self):
                if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes":


@@ -317,7 +319,7 @@ class InfoBarMenu:
        def __init__(self):
                self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 
                        {
        def __init__(self):
                self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 
                        {

-                               "mainMenu": (self.mainMenu, "Enter main menu..."),
+                               "mainMenu": (self.mainMenu, _("Enter main menu...")),

                        })
 
        def mainMenu(self):
                        })
 
        def mainMenu(self):


@@ -326,9 +328,47 @@ class InfoBarMenu:
                assert menu.tagName == "menu", "root element in menu must be 'menu'!"
                self.session.open(MainMenu, menu, menu.childNodes)
 
                assert menu.tagName == "menu", "root element in menu must be 'menu'!"
                self.session.open(MainMenu, menu, menu.childNodes)
 

+class InfoBarSimpleEventView:
+       """ Opens the Eventview for now/next """
+       def __init__(self):
+               self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
+                       {
+                               "showEventInfo": (self.openEventView, _("show event details")),
+                       })
+
+       def openEventView(self):
+               self.epglist = [ ]
+               service = self.session.nav.getCurrentService()
+               ref = self.session.nav.getCurrentlyPlayingServiceReference()
+               info = service.info()
+               ptr=info.getEvent(0)
+               if ptr:
+                       self.epglist.append(ptr)
+               ptr=info.getEvent(1)
+               if ptr:
+                       self.epglist.append(ptr)
+               if len(self.epglist) > 0:
+                       self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
+
+       def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
+               if len(self.epglist) > 1:
+                       tmp = self.epglist[0]
+                       self.epglist[0]=self.epglist[1]
+                       self.epglist[1]=tmp
+                       setEvent(self.epglist[0])
+

 class InfoBarEPG:
        """ EPG - Opens an EPG list when the showEPGList action fires """
        def __init__(self):
 class InfoBarEPG:
        """ EPG - Opens an EPG list when the showEPGList action fires """
        def __init__(self):

+               self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+                       {
+                               iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
+                       })
+
+               self.is_now_next = False
+               self.dlg_stack = [ ]
+               self.bouquetSel = None
+               self.eventView = None

                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),


@@ -344,8 +384,7 @@ class InfoBarEPG:
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 

-       def openBouquetEPG(self, bouquet, withCallback=True):
-               ptr=eEPGCache.getInstance()
+       def getBouquetServices(self, bouquet):

                services = [ ]
                servicelist = eServiceCenter.getInstance().list(bouquet)
                if not servicelist is None:
                services = [ ]
                servicelist = eServiceCenter.getInstance().list(bouquet)
                if not servicelist is None:


@@ -356,16 +395,39 @@ class InfoBarEPG:
                                if service.flags: #ignore non playable services
                                        continue
                                services.append(ServiceReference(service))
                                if service.flags: #ignore non playable services
                                        continue
                                services.append(ServiceReference(service))

+               return services
+
+       def openBouquetEPG(self, bouquet, withCallback=True):
+               services = self.getBouquetServices(bouquet)

                if len(services):
                        self.epg_bouquet = bouquet
                        if withCallback:
                if len(services):
                        self.epg_bouquet = bouquet
                        if withCallback:

-                               self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService)
+                               self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))

                        else:
                        else:

-                               self.session.open(EPGSelection, services, self.zapToService)
+                               self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)

 
 

-       def closed(self, ret):
+       def changeBouquetCB(self, direction, epg):
+               if self.bouquetSel:
+                       if direction > 0:
+                               self.bouquetSel.down()
+                       else:
+                               self.bouquetSel.up()
+                       bouquet = self.bouquetSel.getCurrent()
+                       services = self.getBouquetServices(bouquet)
+                       if len(services):
+                               self.epg_bouquet = bouquet
+                               epg.setServices(services)
+
+       def closed(self, ret=False):
+               closedScreen = self.dlg_stack.pop()
+               if self.bouquetSel and closedScreen == self.bouquetSel:
+                       self.bouquetSel = None
+               elif self.eventView and closedScreen == self.eventView:
+                       self.eventView = None

                if ret:
                if ret:

-                       self.close(ret)
+                       dlgs=len(self.dlg_stack)
+                       if dlgs > 0:
+                               self.dlg_stack[dlgs-1].close(dlgs > 1)

 
        def openMultiServiceEPG(self, withCallback=True):
                bouquets = self.servicelist.getBouquetList()
 
        def openMultiServiceEPG(self, withCallback=True):
                bouquets = self.servicelist.getBouquetList()


@@ -375,38 +437,55 @@ class InfoBarEPG:
                        cnt = len(bouquets)
                if cnt > 1: # show bouquet list
                        if withCallback:
                        cnt = len(bouquets)
                if cnt > 1: # show bouquet list
                        if withCallback:

-                               self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG)
+                               self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
+                               self.dlg_stack.append(self.bouquetSel)

                        else:
                        else:

-                               self.session.open(BouquetSelector, bouquets, self.openBouquetEPG)
+                               self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)

                elif cnt == 1: 
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
        def openSingleServiceEPG(self):
                ref=self.session.nav.getCurrentlyPlayingServiceReference()
                elif cnt == 1: 
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
        def openSingleServiceEPG(self):
                ref=self.session.nav.getCurrentlyPlayingServiceReference()

-               ptr=eEPGCache.getInstance()
-               self.session.openWithCallback(self.closed, EPGSelection, ref)
+               self.session.open(EPGSelection, ref)

 
 

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

                self.epglist = [ ]
                service = self.session.nav.getCurrentService()
                self.epglist = [ ]
                service = self.session.nav.getCurrentService()

-               ref = self.session.nav.getCurrentlyPlayingServiceReference()
-               info = service.info()
-               ptr=info.getEvent(0)
+               info = service and service.info()
+               ptr = info and info.getEvent(0)

                if ptr:
                        self.epglist.append(ptr)
                if ptr:
                        self.epglist.append(ptr)

-               ptr=info.getEvent(1)
+               ptr = info and info.getEvent(1)

                if ptr:
                        self.epglist.append(ptr)
                if ptr:
                        self.epglist.append(ptr)

+
+       def __evEventInfoChanged(self):
+               if self.is_now_next and len(self.dlg_stack) == 1:
+                       self.getNowNext()
+                       assert self.eventView
+                       if len(self.epglist):
+                               self.eventView.setEvent(self.epglist[0])
+
+       def openEventView(self):
+               ref = self.session.nav.getCurrentlyPlayingServiceReference()
+               self.getNowNext()

                if len(self.epglist) == 0:
                if len(self.epglist) == 0:

+                       self.is_now_next = False

                        epg = eEPGCache.getInstance()
                        epg = eEPGCache.getInstance()

-                       ptr = epg.lookupEventTime(ref, -1)
+                       ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)

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

+               else:
+                       self.is_now_next = True

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

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

                else:
                        print "no epg for the service avail.. so we show multiepg instead of eventinfo"
                        self.openMultiServiceEPG(False)
                else:
                        print "no epg for the service avail.. so we show multiepg instead of eventinfo"
                        self.openMultiServiceEPG(False)


@@ -418,67 +497,20 @@ class InfoBarEPG:
                        self.epglist[1]=tmp
                        setEvent(self.epglist[0])
 
                        self.epglist[1]=tmp
                        setEvent(self.epglist[0])
 

-from math import log
-

 class InfoBarTuner:
        """provides a snr/agc/ber display"""
        def __init__(self):
 class InfoBarTuner:
        """provides a snr/agc/ber display"""
        def __init__(self):

-               self["snr"] = Label()
-               self["agc"] = Label()
-               self["ber"] = Label()
-               self["snr_percent"] = Label()
-               self["agc_percent"] = Label()
-               self["ber_count"] = Label()
-               self["snr_progress"] = ProgressBar()
-               self["agc_progress"] = ProgressBar()
-               self["ber_progress"] = ProgressBar()
-               self.timer = eTimer()
-               self.timer.timeout.get().append(self.updateTunerInfo)
-               self.timer.start(1000)
-
-       def calc(self,val):
-               if not val:
-                       return 0
-               if val < 2500:
-                       return (long)(log(val)/log(2))
-               return val*100/65535
-
-       def updateTunerInfo(self):
-               if self.instance.isVisible():
-                       service = self.session.nav.getCurrentService()
-                       snr=0
-                       agc=0
-                       ber=0
-                       if service is not None:
-                               feinfo = service.frontendStatusInfo()
-                               if feinfo is not None:
-                                       ber=feinfo.getFrontendInfo(iFrontendStatusInformation.bitErrorRate)
-                                       snr=feinfo.getFrontendInfo(iFrontendStatusInformation.signalPower)*100/65536
-                                       agc=feinfo.getFrontendInfo(iFrontendStatusInformation.signalQuality)*100/65536
-                       self["snr_percent"].setText("%d%%"%(snr))
-                       self["agc_percent"].setText("%d%%"%(agc))
-                       self["ber_count"].setText("%d"%(ber))
-                       self["snr_progress"].setValue(snr)
-                       self["agc_progress"].setValue(agc)
-                       self["ber_progress"].setValue(self.calc(ber))
+               self["FrontendStatus"] = FrontendStatus(service_source = self.session.nav.getCurrentService)

 
 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_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
-               self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
-                               
-               self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
-               self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
-
-               self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Remaining)
-               self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
-
-               self["Now_ProgressBar"] = EventInfoProgress(self.session.nav, EventInfo.Now)
+               self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW)
+               self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT)

 
 class InfoBarServiceName:
        def __init__(self):
 
 class InfoBarServiceName:
        def __init__(self):

-               self["ServiceName"] = ServiceName(self.session.nav)
+               self["CurrentService"] = CurrentService(self.session.nav)

 
 class InfoBarSeek:
        """handles actions like seeking, pause"""
 
 class InfoBarSeek:
        """handles actions like seeking, pause"""


@@ -511,15 +543,31 @@ class InfoBarSeek:
                                iPlayableService.evEOF: self.__evEOF,
                                iPlayableService.evSOF: self.__evSOF,
                        })
                                iPlayableService.evEOF: self.__evEOF,
                                iPlayableService.evSOF: self.__evSOF,
                        })

-               self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions", 
+
+               class InfoBarSeekActionMap(HelpableActionMap):
+                       def __init__(self, screen, *args, **kwargs):
+                               HelpableActionMap.__init__(self, screen, *args, **kwargs)
+                               self.screen = screen
+                               
+                       def action(self, contexts, action):
+                               if action[:5] == "seek:":
+                                       time = int(action[5:])
+                                       self.screen.seekRelative(time * 90000)
+                                       return 1
+                               else:
+                                       return HelpableActionMap.action(self, contexts, action)
+
+               self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", 

                        {
                        {

-                               "pauseService": (self.pauseService, "pause"),
-                               "unPauseService": (self.unPauseService, "continue"),
+                               "pauseService": (self.pauseService, _("pause")),
+                               "unPauseService": (self.unPauseService, _("continue")),

                                
                                

-                               "seekFwd": (self.seekFwd, "skip forward"),
-                               "seekFwdUp": (self.seekFwdUp, "skip forward"),
-                               "seekBack": (self.seekBack, "skip backward"),
-                               "seekBackUp": (self.seekBackUp, "skip backward"),
+                               "seekFwd": (self.seekFwd, _("skip forward")),
+                               "seekFwdDown": self.seekFwdDown,
+                               "seekFwdUp": self.seekFwdUp,
+                               "seekBack": (self.seekBack, _("skip backward")),
+                               "seekBackDown": self.seekBackDown,
+                               "seekBackUp": self.seekBackUp,

                        }, 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
 


@@ -551,7 +599,7 @@ class InfoBarSeek:
        def getSeek(self):
                service = self.session.nav.getCurrentService()
                if service is None:
        def getSeek(self):
                service = self.session.nav.getCurrentService()
                if service is None:

-                       return False
+                       return None

 
                seek = service.seek()
 
 
                seek = service.seek()
 


@@ -607,7 +655,7 @@ class InfoBarSeek:
                self.checkSkipShowHideLock()
 
                return True
                self.checkSkipShowHideLock()
 
                return True

-               
+

        def pauseService(self):
                if self.seekstate == self.SEEK_STATE_PAUSE:
                        print "pause, but in fact unpause"
        def pauseService(self):
                if self.seekstate == self.SEEK_STATE_PAUSE:
                        print "pause, but in fact unpause"


@@ -622,6 +670,8 @@ class InfoBarSeek:
                
        def unPauseService(self):
                print "unpause"
                
        def unPauseService(self):
                print "unpause"

+               if self.seekstate == self.SEEK_STATE_PLAY:
+                       return 0

                self.setSeekState(self.SEEK_STATE_PLAY);
        
        def doSeek(self, seektime):
                self.setSeekState(self.SEEK_STATE_PLAY);
        
        def doSeek(self, seektime):


@@ -636,12 +686,12 @@ class InfoBarSeek:
                
                seekable.seekTo(90 * seektime)
 
                
                seekable.seekTo(90 * seektime)
 

-       def seekFwd(self):
+       def seekFwdDown(self):

                print "start fwd timer"
                self.fwdtimer = True
                self.fwdKeyTimer.start(1000)
 
                print "start fwd timer"
                self.fwdtimer = True
                self.fwdKeyTimer.start(1000)
 

-       def seekBack(self):
+       def seekBackDown(self):

                print "start rewind timer"
                self.rwdtimer = True
                self.rwdKeyTimer.start(1000)
                print "start rewind timer"
                self.rwdtimer = True
                self.rwdKeyTimer.start(1000)


@@ -651,50 +701,60 @@ class InfoBarSeek:
                if self.fwdtimer:
                        self.fwdKeyTimer.stop()
                        self.fwdtimer = False
                if self.fwdtimer:
                        self.fwdKeyTimer.stop()
                        self.fwdtimer = False

-                       lookup = {
-                                       self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
-                                       self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
-                                       self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
-                                       self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
-                                       self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
-                                       self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
-                                       self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
-                                       self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
-                                       self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY,
-                                       self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X,
-                                       self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
-                                       self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
-                                       self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
-                                       self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
-                                       self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
-                               }
-                       self.setSeekState(lookup[self.seekstate]);
+                       self.seekFwd()
+
+       def seekFwd(self):
+               lookup = {
+                               self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
+                               self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
+                               self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
+                               self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
+                               self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
+                               self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
+                               self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
+                               self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
+                               self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY,
+                               self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X,
+                               self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
+                               self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
+                               self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
+                               self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
+                               self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
+                       }
+               self.setSeekState(lookup[self.seekstate])

        
        def seekBackUp(self):
                print "seekBackUp"
                if self.rwdtimer:
                        self.rwdKeyTimer.stop()
                        self.rwdtimer = False
        
        def seekBackUp(self):
                print "seekBackUp"
                if self.rwdtimer:
                        self.rwdKeyTimer.stop()
                        self.rwdtimer = False

+                       self.seekBack()

                
                

-                       lookup = {
-                                       self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X,
-                                       self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
-                                       self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
-                                       self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
-                                       self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
-                                       self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
-                                       self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
-                                       self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
-                                       self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X,
-                                       self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
-                                       self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
-                                       self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
-                                       self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
-                                       self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
-                                       self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
-                               }
-                       self.setSeekState(lookup[self.seekstate]);
+       def seekBack(self):
+               lookup = {
+                               self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X,
+                               self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
+                               self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
+                               self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
+                               self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
+                               self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
+                               self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
+                               self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
+                               self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X,
+                               self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
+                               self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
+                               self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
+                               self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
+                               self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
+                               self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
+                       }
+               self.setSeekState(lookup[self.seekstate])

                
                

+               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()
        def fwdTimerFire(self):
                print "Display seek fwd"
                self.fwdKeyTimer.stop()


@@ -733,7 +793,7 @@ class InfoBarSeek:
                if self.seekstate != self.SEEK_STATE_PLAY:
                        self.setSeekState(self.SEEK_STATE_PAUSE)
                        # HACK
                if self.seekstate != self.SEEK_STATE_PLAY:
                        self.setSeekState(self.SEEK_STATE_PAUSE)
                        # HACK

-                       self.getSeek().seekRelative(1, -90000)
+                       #self.getSeek().seekRelative(1, -90000)

                        self.setSeekState(self.SEEK_STATE_PLAY)
                else:
                        self.setSeekState(self.SEEK_STATE_PAUSE)
                        self.setSeekState(self.SEEK_STATE_PLAY)
                else:
                        self.setSeekState(self.SEEK_STATE_PAUSE)


@@ -745,19 +805,19 @@ class InfoBarSeek:
        def seekRelative(self, diff):
                seekable = self.getSeek()
                if seekable is not None:
        def seekRelative(self, diff):
                seekable = self.getSeek()
                if seekable is not None:

-                       seekable.seekRelative(0, diff)
+                       seekable.seekRelative(1, diff)

 
 

-from Screens.PVRState import PVRState
+from Screens.PVRState import PVRState, TimeshiftState

 
 class InfoBarPVRState:
 
 class InfoBarPVRState:

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

                self.onPlayStateChanged.append(self.__playStateChanged)
                self.onPlayStateChanged.append(self.__playStateChanged)

-               self.pvrStateDialog = self.session.instantiateDialog(PVRState)
+               self.pvrStateDialog = self.session.instantiateDialog(screen)

                self.onShow.append(self.__mayShow)
                self.onHide.append(self.pvrStateDialog.hide)
        
        def __mayShow(self):
                self.onShow.append(self.__mayShow)
                self.onHide.append(self.pvrStateDialog.hide)
        
        def __mayShow(self):

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

                        self.pvrStateDialog.show()
 
        def __playStateChanged(self, state):
                        self.pvrStateDialog.show()
 
        def __playStateChanged(self, state):


@@ -765,6 +825,11 @@ class InfoBarPVRState:
                self.pvrStateDialog["state"].setText(playstateString)
                self.__mayShow()
 
                self.pvrStateDialog["state"].setText(playstateString)
                self.__mayShow()
 

+class InfoBarTimeshiftState(InfoBarPVRState):
+       def __init__(self):
+               InfoBarPVRState.__init__(self, screen=TimeshiftState)
+
+

 class InfoBarShowMovies:
 
        # i don't really like this class. 
 class InfoBarShowMovies:
 
        # i don't really like this class. 


@@ -810,8 +875,8 @@ class InfoBarTimeshift:
        def __init__(self):
                self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", 
                        {
        def __init__(self):
                self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", 
                        {

-                               "timeshiftStart": (self.startTimeshift, "start timeshift"),  # the "yellow key"
-                               "timeshiftStop": (self.stopTimeshift, "stop timeshift")      # currently undefined :), probably 'TV'
+                               "timeshiftStart": (self.startTimeshift, _("start timeshift")),  # the "yellow key"
+                               "timeshiftStop": (self.stopTimeshift, _("stop timeshift"))      # currently undefined :), probably 'TV'

                        }, prio=1)
                self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
                        {
                        }, prio=1)
                self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
                        {


@@ -826,12 +891,13 @@ class InfoBarTimeshift:
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {

+                               iPlayableService.evStart: self.__serviceStarted,

                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
                        })
        
        def getTimeshift(self):
                service = self.session.nav.getCurrentService()
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
                        })
        
        def getTimeshift(self):
                service = self.session.nav.getCurrentService()

-               return service.timeshift()
+               return service and service.timeshift()

 
        def startTimeshift(self):
                print "enable timeshift"
 
        def startTimeshift(self):
                print "enable timeshift"


@@ -845,8 +911,12 @@ class InfoBarTimeshift:
                        print "hu, timeshift already enabled?"
                else:
                        if not ts.startTimeshift():
                        print "hu, timeshift already enabled?"
                else:
                        if not ts.startTimeshift():

+                               import time

                                self.timeshift_enabled = 1
                                
                                self.timeshift_enabled = 1
                                

+                               # we remove the "relative time" for now.
+                               #self.pvrStateDialog["timeshift"].setRelative(time.time())
+                                       

                                # PAUSE.
                                self.setSeekState(self.SEEK_STATE_PAUSE)
                                
                                # PAUSE.
                                self.setSeekState(self.SEEK_STATE_PAUSE)
                                


@@ -926,6 +996,77 @@ class InfoBarTimeshift:
                print "timeshift activate:", enabled
                self["TimeshiftActivateActions"].setEnabled(enabled)
 
                print "timeshift activate:", enabled
                self["TimeshiftActivateActions"].setEnabled(enabled)
 

+       def __serviceStarted(self):
+               self.timeshift_enabled = False
+               self.__seekableStatusChanged()
+
+from Screens.PiPSetup import PiPSetup
+
+class InfoBarExtensions:
+       def __init__(self):
+               self.session.pipshown = False
+               
+               self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
+                       {
+                               "extensions": (self.extensions, _("view extensions...")),
+                       })
+
+       PIPON = 0
+       PIPOFF = 1
+       MOVEPIP = 2
+       PIPSWAP = 3
+       ENABLE_SUBTITLE = 4
+
+       def extensions(self):
+               list = []
+               if self.session.pipshown == False:
+                       list.append((_("Activate Picture in Picture"), self.PIPON))
+               elif self.session.pipshown == True:
+                       list.append((_("Disable Picture in Picture"), self.PIPOFF))
+                       list.append((_("Move Picture in Picture"), self.MOVEPIP))
+                       list.append((_("Swap services"), self.PIPSWAP))
+               
+               s = self.getCurrentServiceSubtitle()
+               l = s and s.getSubtitleList() or [ ]
+               
+               for x in l:
+                       list.append(("DEBUG: Enable Subtitles: " + x[0], self.ENABLE_SUBTITLE, x[1]))
+               
+               self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list)
+
+       def extensionCallback(self, answer):
+               if answer is not None:
+                       if answer[1] == self.PIPON:
+                               self.session.pip = self.session.instantiateDialog(PictureInPicture)
+                               newservice = self.session.nav.getCurrentlyPlayingServiceReference()
+                               if self.session.pip.playService(newservice):
+                                       self.session.pipshown = True
+                                       self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
+                               else:
+                                       self.session.pipshown = False
+                                       del self.session.pip
+                               self.session.nav.playService(newservice)
+                       elif answer[1] == self.PIPOFF:
+                               del self.session.pip
+                               self.session.pipshown = False
+                       elif answer[1] == self.PIPSWAP:
+                               swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
+                               if self.session.pip.servicePath:
+                                       servicepath = self.servicelist.getCurrentServicePath()
+                                       ref=servicepath[len(servicepath)-1]
+                                       pipref=self.session.pip.getCurrentService()
+                                       self.session.pip.playService(swapservice)
+                                       self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
+                                       if pipref.toString() != ref.toString(): # is a subservice ?
+                                               self.session.nav.stopService() # stop portal
+                                               self.session.nav.playService(pipref) # start subservice
+                                       self.session.pip.servicePath=servicepath
+                       elif answer[1] == self.MOVEPIP:
+                               self.session.open(PiPSetup, pip = self.session.pip)
+                       elif answer[1] == self.ENABLE_SUBTITLE:
+                               self.selected_subtitle = answer[2]
+                               self.subtitles_enabled = True
+

 from RecordTimer import parseEvent
 
 class InfoBarInstantRecord:
 from RecordTimer import parseEvent
 
 class InfoBarInstantRecord:


@@ -934,59 +1075,111 @@ class InfoBarInstantRecord:
        def __init__(self):
                self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
                        {
        def __init__(self):
                self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
                        {

-                               "instantRecord": (self.instantRecord, "Instant Record..."),
+                               "instantRecord": (self.instantRecord, _("Instant Record...")),

                        })
                        })

-               self.recording = None
+               self.recording = []

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

-               self.onLayoutFinish.append(self["BlinkingPoint"].hideWidget)
+               self["BlinkingPoint"].hide()

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

-       def stopCurrentRecording(self): 
-               self.session.nav.RecordTimer.removeEntry(self.recording)
-               self.recording = None
+       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):
+       def startInstantRecording(self, limitEvent = False):

                serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
                
                # try to get event info
                event = None
                try:
                        service = self.session.nav.getCurrentService()
                serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
                
                # try to get event info
                event = None
                try:
                        service = self.session.nav.getCurrentService()

-                       info = service.info()
-                       ev = info.getEvent(0)
-                       event = ev
+                       epg = eEPGCache.getInstance()
+                       event = epg.lookupEventTime(serviceref, -1, 0)
+                       if event is None:
+                               info = service.info()
+                               ev = info.getEvent(0)
+                               event = ev

                except:
                        pass
                except:
                        pass

+
+               begin = time.time()
+               end = time.time() + 3600 * 10
+               name = "instant record"
+               description = ""
+               eventid = None

                
                if event is not None:
                
                if event is not None:

-                       data = parseEvent(event)
-                       begin = time.time()
-                       end = begin + 3600 * 10
-                       
-                       data = (begin, end, data[2], data[3], data[4])
+                       curEvent = parseEvent(event)
+                       name = curEvent[2]
+                       description = curEvent[3]
+                       eventid = curEvent[4]
+                       if limitEvent:
+                               end = curEvent[1]

                else:
                else:

-                       data = (time.time(), time.time() + 3600 * 10, "instant record", "", None)
+                       if limitEvent:
+                               self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
+                               
+               data = (begin, end, name, description, eventid)

                
                

-               # fix me, description. 
-               self.recording = self.session.nav.recordWithTimer(serviceref, *data)
-               self.recording.dontSave = True
+               recording = self.session.nav.recordWithTimer(serviceref, *data)
+               recording.dontSave = True
+               self.recording.append(recording)

                
                #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
                
        def isInstantRecordRunning(self):
                
                #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
                
        def isInstantRecordRunning(self):

-               if self.recording != None:
-                       if self.recording.isRunning():
-                               return True
+               print "self.recording:", self.recording
+               if len(self.recording) > 0:
+                       for x in self.recording:
+                               if x.isRunning():
+                                       return True

                return False
 
        def recordQuestionCallback(self, answer):
                return False
 
        def recordQuestionCallback(self, answer):

-               if answer == False:
-                       return
+               print "pre:\n", self.recording

                
                

-               if self.isInstantRecordRunning():
-                       self.stopCurrentRecording()
-               else:
-                       self.startInstantRecording()
+               if answer is None or answer[1] == "no":
+                       return
+               list = []
+               recording = self.recording[:]
+               for x in recording:
+                       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))              
+
+               if answer[1] == "changeduration":
+                       if len(self.recording) == 1:
+                               self.changeDuration(0)
+                       else:
+                               self.session.openWithCallback(self.changeDuration, 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
+                       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)
+                       
+               print "after:\n", self.recording
+
+       def changeDuration(self, entry):
+               if entry is not None:
+                       self.selectedEntry = entry
+                       self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
+
+       def inputCallback(self, value):
+               if value is not None:
+                       print "stopping recording after", int(value), "minutes."
+                       self.recording[self.selectedEntry].end = time.time() + 60 * int(value)
+                       self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])

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


@@ -996,144 +1189,207 @@ class InfoBarInstantRecord:
                        return
        
                if self.isInstantRecordRunning():
                        return
        
                if self.isInstantRecordRunning():

-                       self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?"))
+                       self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("A recording is currently running.\nWhat do you want to do?"), list=[(_("stop recording"), "stop"), (_("change recording (duration)"), "changeduration"), (_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"), (_("do nothing"), "no")])

                else:
                else:

-                       self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?"))
+                       self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")])

 
 

-from Screens.AudioSelection import AudioSelection
+from Tools.ISO639 import LanguageCodes

 
 class InfoBarAudioSelection:
        def __init__(self):
                self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", 
                        {
 
 class InfoBarAudioSelection:
        def __init__(self):
                self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", 
                        {

-                               "audioSelection": (self.audioSelection, "Audio Options..."),
+                               "audioSelection": (self.audioSelection, _("Audio Options...")),

                        })
 
        def audioSelection(self):
                service = self.session.nav.getCurrentService()
                        })
 
        def audioSelection(self):
                service = self.session.nav.getCurrentService()

-               audio = service.audioTracks()
-               n = audio.getNumberOfTracks()
-               if n > 0:
-                       self.session.open(AudioSelection, audio)
+               audio = service and service.audioTracks()
+               self.audioTracks = audio
+               n = audio and audio.getNumberOfTracks()
+               keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+               tlist = []
+               print "tlist:", tlist
+               if n and n > 0:
+                       self.audioChannel = service.audioChannel()
+
+                       for x in range(n):
+                               i = audio.getTrackInfo(x)
+                               language = i.getLanguage()
+                               description = i.getDescription()
+       
+                               if len(language) == 3:
+                                       if language in LanguageCodes:
+                                               language = LanguageCodes[language][0]
+       
+                               if len(description):
+                                       description += " (" + language + ")"
+                               else:
+                                       description = language
+       
+                               tlist.append((description, x))
+                       
+                       selectedAudio = tlist[0][1]
+                       tlist.sort(lambda x,y : cmp(x[0], y[0]))
+
+                       selection = 2
+                       for x in tlist:
+                               if x[1] != selectedAudio:
+                                       selection += 1
+                               else:
+                                       break

 
 

-from Screens.SubserviceSelection import SubserviceSelection
+                       tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
+                       self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
+               else:
+                       del self.audioTracks
+
+       def audioSelected(self, audio):
+               if audio is not None:
+                       if isinstance(audio[1], str):
+                               if audio[1] == "mode":
+                                       keys = ["red", "green", "yellow"]
+                                       selection = self.audioChannel.getCurrentChannel()
+                                       tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
+                                       self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
+                       else:
+                               del self.audioChannel
+                               if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
+                                       self.audioTracks.selectTrack(audio[1])
+               else:
+                       del self.audioChannel
+               del self.audioTracks
+
+       def modeSelected(self, mode):
+               if mode is not None:
+                       self.audioChannel.selectChannel(mode[1])
+               del self.audioChannel

 
 class InfoBarSubserviceSelection:
        def __init__(self):
                self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
                        {
 
 class InfoBarSubserviceSelection:
        def __init__(self):
                self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
                        {

-                               "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
+                               "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),

                        })
 
                        })
 

+               self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
+                       {
+                               "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
+                               "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
+                       }, -1)
+               self["SubserviceQuickzapAction"].setEnabled(False)
+
+               self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
+
+       def checkSubservicesAvail(self, ev):
+               if ev == iPlayableService.evUpdatedEventInfo:
+                       service = self.session.nav.getCurrentService()
+                       subservices = service and service.subServices()
+                       if not subservices or subservices.getNumberOfSubservices() == 0:
+                               self["SubserviceQuickzapAction"].setEnabled(False)
+
+       def nextSubservice(self):
+               self.changeSubservice(+1)
+
+       def prevSubservice(self):
+               self.changeSubservice(-1)
+
+       def changeSubservice(self, direction):
+               service = self.session.nav.getCurrentService()
+               subservices = service and service.subServices()
+               n = subservices and subservices.getNumberOfSubservices()
+               if n and n > 0:
+                       selection = -1
+                       ref = self.session.nav.getCurrentlyPlayingServiceReference()
+                       for x in range(n):
+                               if subservices.getSubservice(x).toString() == ref.toString():
+                                       selection = x
+                       if selection != -1:
+                               selection += direction
+                               if selection >= n:
+                                       selection=0
+                               elif selection < 0:
+                                       selection=n-1
+                               newservice = subservices.getSubservice(selection)
+                               if newservice.valid():
+                                       del subservices
+                                       del service
+                                       self.session.nav.playService(newservice)
+

        def subserviceSelection(self):
                service = self.session.nav.getCurrentService()
        def subserviceSelection(self):
                service = self.session.nav.getCurrentService()

-               subservices = service.subServices()
-               n = subservices.getNumberOfSubservices()
-               if n > 0:
-                       self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
+               subservices = service and service.subServices()
+               
+               n = subservices and subservices.getNumberOfSubservices()
+               selection = 0
+               if n and n > 0:
+                       ref = self.session.nav.getCurrentlyPlayingServiceReference()
+                       tlist = []
+                       for x in range(n):
+                               i = subservices.getSubservice(x)
+                               if i.toString() == ref.toString():
+                                       selection = x
+                               tlist.append((i.getName(), i))
+
+                       self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection)

 
        def subserviceSelected(self, service):
                if not service is None:
 
        def subserviceSelected(self, service):
                if not service is None:

-                       self.session.nav.playService(service)
+                       self["SubserviceQuickzapAction"].setEnabled(True)
+                       self.session.nav.playService(service[1])

 
 class InfoBarAdditionalInfo:
        def __init__(self):
 
 class InfoBarAdditionalInfo:
        def __init__(self):

-               self["DolbyActive"] = Pixmap()
-               self["CryptActive"] = Pixmap()
-               self["FormatActive"] = Pixmap()
-               
-               self["ButtonRed"] = PixmapConditional(withTimer = False)
-               self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self.onLayoutFinish.append(self["ButtonRed"].update)
-               self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False)
-               self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self.onLayoutFinish.append(self["ButtonRedText"].update)
-
-               self["ButtonGreen"] = Pixmap()
-               self["ButtonGreenText"] = Label(_("Subservices"))
-
-               self["ButtonYellow"] = PixmapConditional(withTimer = False)
-               self["ButtonYellow"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self["ButtonYellowText"] = LabelConditional(text = _("Timeshifting"), withTimer = False)
-               self["ButtonYellowText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self.onLayoutFinish.append(self["ButtonYellow"].update)
-               self.onLayoutFinish.append(self["ButtonYellowText"].update)
-
-               self["ButtonBlue"] = PixmapConditional(withTimer = False)
-               self["ButtonBlue"].setConnect(lambda: False)
-               self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)
-               self["ButtonBlueText"].setConnect(lambda: False)
-               self.onLayoutFinish.append(self["ButtonBlue"].update)
-               self.onLayoutFinish.append(self["ButtonBlueText"].update)
-
-               self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
-
-       def hideSubServiceIndication(self):
-               self["ButtonGreen"].hideWidget()
-               self["ButtonGreenText"].hide()
+               self["NimA"] = Pixmap()
+               self["NimB"] = Pixmap()
+               self["NimA_Active"] = Pixmap()
+               self["NimB_Active"] = Pixmap()

 
 

-       def showSubServiceIndication(self):
-               self["ButtonGreen"].showWidget()
-               self["ButtonGreenText"].show()
+               self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
+               self["TimeshiftPossible"] = self["RecordingPossible"]
+               self["ExtensionsAvailable"] = Boolean(fixed=1)

 
 

-       def checkFormat(self, service):
-               info = service.info()
-               if info is not None:
-                       aspect = info.getInfo(iServiceInformation.sAspect)
-                       if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]:
-                               self["FormatActive"].showWidget()
-                       else:
-                               self["FormatActive"].hideWidget()
+               self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
+               res_mgr = eDVBResourceManagerPtr()
+               if eDVBResourceManager.getInstance(res_mgr) == 0:
+                       res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged)

 
 

-       def checkSubservices(self, service):
-               if service.subServices().getNumberOfSubservices() > 0:
-                       self.showSubServiceIndication()
+       def tunerUseMaskChanged(self, mask):
+               if mask&1:
+                       self["NimA_Active"].show()

                else:
                else:

-                       self.hideSubServiceIndication()
-
-       def checkDolby(self, service):
-               # FIXME
-               dolby = False
-               audio = service.audioTracks()
-               if audio is not None:
-                       n = audio.getNumberOfTracks()
-                       for x in range(n):
-                               i = audio.getTrackInfo(x)
-                               description = i.getDescription();
-                               if description.find("AC3") != -1 or description.find("DTS") != -1:
-                                       dolby = True
-                                       break
-               if dolby:
-                       self["DolbyActive"].showWidget()
+                       self["NimA_Active"].hide()
+               if mask&2:
+                       self["NimB_Active"].show()

                else:
                else:

-                       self["DolbyActive"].hideWidget()
-
-       def checkCrypted(self, service):
-               info = service.info()
-               if info is not None:
-                       if info.getInfo(iServiceInformation.sIsCrypted) > 0:
-                               self["CryptActive"].showWidget()
-                       else:
-                               self["CryptActive"].hideWidget()
+                       self["NimB_Active"].hide()
+
+       def checkTunerState(self, service):
+               info = service.frontendInfo()
+               feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber)
+               if feNumber is None:
+                       self["NimA"].hide()
+                       self["NimB"].hide()
+               elif feNumber == 0:
+                       self["NimB"].hide()
+                       self["NimA"].show()
+               elif feNumber == 1:
+                       self["NimA"].hide()
+                       self["NimB"].show()

 
        def gotServiceEvent(self, ev):
                service = self.session.nav.getCurrentService()
 
        def gotServiceEvent(self, ev):
                service = self.session.nav.getCurrentService()

-               if ev == iPlayableService.evUpdatedEventInfo:
-                       self.checkSubservices(service)
-                       self.checkFormat(service)
-               elif ev == iPlayableService.evUpdatedInfo:
-                       self.checkCrypted(service)
-                       self.checkDolby(service)
-               elif ev == iPlayableService.evEnd:
-                       self.hideSubServiceIndication()
-                       self["CryptActive"].hideWidget()
-                       self["DolbyActive"].hideWidget()
-                       self["FormatActive"].hideWidget()
+               if ev == iPlayableService.evStart:
+                       self.checkTunerState(service)

 
 class InfoBarNotifications:
        def __init__(self):
                self.onExecBegin.append(self.checkNotifications)
                Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
 
 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 checkNotificationsIfExecing(self):
                if self.execing:
        
        def checkNotificationsIfExecing(self):
                if self.execing:


@@ -1143,12 +1399,11 @@ class InfoBarNotifications:
                if len(Notifications.notifications):
                        n = Notifications.notifications[0]
                        Notifications.notifications = Notifications.notifications[1:]
                if len(Notifications.notifications):
                        n = Notifications.notifications[0]
                        Notifications.notifications = Notifications.notifications[1:]

-                       print "open",n

                        cb = n[0]
                        if cb is not None:
                        cb = n[0]
                        if cb is not None:

-                               self.session.openWithCallback(cb, *n[1:])
+                               self.session.openWithCallback(cb, n[1], *n[2], **n[3])

                        else:
                        else:

-                               self.session.open(*n[1:])
+                               self.session.open(n[1], *n[2], **n[3])

 
 class InfoBarServiceNotifications:
        def __init__(self):
 
 class InfoBarServiceNotifications:
        def __init__(self):


@@ -1194,7 +1449,7 @@ class InfoBarCueSheetSupport:
                        return None
                return service.seek()
 
                        return None
                return service.seek()
 

-       def __getCurrentPosition(self):
+       def cueGetCurrentPosition(self):

                seek = self.__getSeekable()
                if seek is None:
                        return None
                seek = self.__getSeekable()
                if seek is None:
                        return None


@@ -1204,7 +1459,7 @@ class InfoBarCueSheetSupport:
                return long(r[1])
 
        def jumpPreviousNextMark(self, cmp, alternative=None):
                return long(r[1])
 
        def jumpPreviousNextMark(self, cmp, alternative=None):

-               current_pos = self.__getCurrentPosition()
+               current_pos = self.cueGetCurrentPosition()

                if current_pos is None:
                        return
                mark = self.getNearestCutPoint(current_pos, cmp=cmp)
                if current_pos is None:
                        return
                mark = self.getNearestCutPoint(current_pos, cmp=cmp)


@@ -1220,13 +1475,11 @@ class InfoBarCueSheetSupport:
                        seekable.seekTo(pts)
 
        def jumpPreviousMark(self):
                        seekable.seekTo(pts)
 
        def jumpPreviousMark(self):

-               print "jumpPreviousMark"

                # we add 2 seconds, so if the play position is <2s after
                # the mark, the mark before will be used
                self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0)
 
        def jumpNextMark(self):
                # we add 2 seconds, so if the play position is <2s after
                # the mark, the mark before will be used
                self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0)
 
        def jumpNextMark(self):

-               print "jumpNextMark"

                self.jumpPreviousNextMark(lambda x: x)
 
        def getNearestCutPoint(self, pts, cmp=abs):
                self.jumpPreviousNextMark(lambda x: x)
 
        def getNearestCutPoint(self, pts, cmp=abs):


@@ -1238,23 +1491,31 @@ class InfoBarCueSheetSupport:
                                nearest = cp
                return nearest
 
                                nearest = cp
                return nearest
 

-       def toggleMark(self):
-               print "toggleMark"
-               current_pos = self.__getCurrentPosition()
+       def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
+               current_pos = self.cueGetCurrentPosition()

                if current_pos is None:
                        print "not seekable"
                        return
                
                if current_pos is None:
                        print "not seekable"
                        return
                

-               print "current position: ", current_pos
-

                nearest_cutpoint = self.getNearestCutPoint(current_pos)
                nearest_cutpoint = self.getNearestCutPoint(current_pos)

-               print "nearest_cutpoint: ", nearest_cutpoint

                
                

-               if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < 5*90000:
-                       self.cut_list.remove(nearest_cutpoint)
-               else:
-                       bisect.insort(self.cut_list, (current_pos, self.CUT_TYPE_MARK))
+               if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
+                       if onlyreturn:
+                               return nearest_cutpoint
+                       if not onlyadd:
+                               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):
+               bisect.insort(self.cut_list, point)
+               self.uploadCuesheet()
+
+       def removeMark(self, point):
+               self.cut_list.remove(point)

                self.uploadCuesheet()
 
        def __getCuesheet(self):
                self.uploadCuesheet()
 
        def __getCuesheet(self):


@@ -1279,4 +1540,90 @@ class InfoBarCueSheetSupport:
                        return
                self.cut_list = cue.getCutList()
 
                        return
                self.cut_list = cue.getCutList()
 

-               print "cuts:", self.cut_list
+class InfoBarSummary(Screen):
+       skin = """
+       <screen position="0,0" size="132,64">
+               <widget source="CurrentTime" render="Label" position="50,46" size="82,18" font="Regular;16" >
+                       <convert type="ClockToText">WithSeconds</convert>
+               </widget>
+               <widget source="CurrentService" render="Label" position="0,4" size="132,42" font="Regular;18" >
+                       <convert type="ServiceName">Name</convert>
+               </widget>
+       </screen>"""
+
+       def __init__(self, session, parent):
+               Screen.__init__(self, session)
+               self["CurrentService"] = CurrentService(self.session.nav)
+               self["CurrentTime"] = Clock()
+
+class InfoBarSummarySupport:
+       def __init__(self):
+               pass
+       
+       def createSummary(self):
+               return InfoBarSummary
+
+class InfoBarTeletextPlugin:
+       def __init__(self):
+               self.teletext_plugin = None
+               
+               for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
+                       self.teletext_plugin = p
+               
+               if self.teletext_plugin is not None:
+                       self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
+                               {
+                                       "startTeletext": (self.startTeletext, _("View teletext..."))
+                               })
+               else:
+                       print "no teletext plugin found!"
+
+       def startTeletext(self):
+               self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
+
+class InfoBarSubtitleSupport(object):
+       def __init__(self):
+               object.__init__(self)
+               self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
+               self.__subtitles_enabled = False
+
+               self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+                       {
+                               iPlayableService.evStart: self.__serviceStarted,
+                       })
+
+       def __serviceStarted(self):
+               # reenable if it was enabled
+               r = self.__subtitles_enabled
+               self.__subtitles_enabled = False
+               self.__selected_subtitle = None
+               self.setSubtitlesEnable(r)
+
+       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:
+                       if subtitle and not self.__subtitles_enabled:
+                               subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
+                               self.subtitle_window.show()
+                               self.__subtitles_enabled = True
+               else:
+                       if subtitle:
+                               subtitle.disableSubtitles(self.subtitle_window.instance)
+
+                       self.subtitle_window.hide()
+                       self.__subtitles_enabled = False
+
+       def setSelectedSubtitle(self, subtitle):
+               if self.__selected_subtitle != subtitle and self.subtitles_enabled:
+                       # kick
+                       self.__selected_subtitle = subtitle
+                       self.__serviceStarted()
+               else:
+                       self.__selected_subtitle = subtitle
+
+       subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
+       selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)