convert to new skin system

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

diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index c7076225c6838df4baec265dcc69257ec3b4aa6e..dd5aadecbe5fe3e7d1860c5bd6830634eaa9563e 100644 (file)
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -3,8 +3,6 @@ from ChannelSelection import ChannelSelection, BouquetSelector
 from Components.ActionMap import ActionMap, HelpableActionMap
 from Components.ActionMap import NumberActionMap
 from Components.BlinkingPixmap import BlinkingPixmapConditional
 from Components.ActionMap import ActionMap, HelpableActionMap
 from Components.ActionMap import NumberActionMap
 from Components.BlinkingPixmap import BlinkingPixmapConditional

-from Components.Clock import Clock
-from Components.EventInfo import EventInfo, EventInfoProgress

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


@@ -12,11 +10,14 @@ from Components.Pixmap import Pixmap, PixmapConditional
 from Components.PluginComponent import plugins
 from Components.ProgressBar import *
 from Components.ServiceEventTracker import ServiceEventTracker
 from Components.PluginComponent import plugins
 from Components.ProgressBar import *
 from Components.ServiceEventTracker import ServiceEventTracker

-from Components.ServiceName import ServiceName
-from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean
-from Components.config import configfile, configsequencearg
+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.TimerList import TimerEntryComponent

-from Components.TunerInfo import TunerInfo
+from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry
+from Components.config import configfile, configsequencearg

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


@@ -30,6 +31,7 @@ from Screens.MessageBox import MessageBox
 from Screens.MinuteInput import MinuteInput
 from Screens.TimerSelection import TimerSelection
 from Screens.PictureInPicture import PictureInPicture
 from Screens.MinuteInput import MinuteInput
 from Screens.TimerSelection import TimerSelection
 from Screens.PictureInPicture import PictureInPicture

+from Screens.SubtitleDisplay import SubtitleDisplay

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


@@ -257,15 +259,28 @@ class InfoBarChannelSelection:
                                "zapUp": (self.zapUp, _("previous channel")),
                                "zapDown": (self.zapDown, _("next channel")),
                                "historyBack": (self.historyBack, _("previous channel in history")),
                                "zapUp": (self.zapUp, _("previous channel")),
                                "zapDown": (self.zapDown, _("next channel")),
                                "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 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()
 


@@ -279,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":


@@ -448,7 +466,8 @@ class InfoBarEPG:
                if self.is_now_next and len(self.dlg_stack) == 1:
                        self.getNowNext()
                        assert self.eventView
                if self.is_now_next and len(self.dlg_stack) == 1:
                        self.getNowNext()
                        assert self.eventView

-                       self.eventView.setEvent(self.epglist[0])
+                       if len(self.epglist):
+                               self.eventView.setEvent(self.epglist[0])

 
        def openEventView(self):
                ref = self.session.nav.getCurrentlyPlayingServiceReference()
 
        def openEventView(self):
                ref = self.session.nav.getCurrentlyPlayingServiceReference()


@@ -481,45 +500,17 @@ 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["snr"] = Label()
-               self["agc"] = Label()
-               self["ber"] = Label()
-               self["snr_percent"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, servicefkt = self.session.nav.getCurrentService)
-               self["agc_percent"] = TunerInfo(TunerInfo.AGC_PERCENTAGE, servicefkt = self.session.nav.getCurrentService)
-               self["ber_count"] = TunerInfo(TunerInfo.BER_VALUE, servicefkt = self.session.nav.getCurrentService)
-               self["snr_progress"] = TunerInfo(TunerInfo.SNR_BAR, servicefkt = self.session.nav.getCurrentService)
-               self["agc_progress"] = TunerInfo(TunerInfo.AGC_BAR, servicefkt = self.session.nav.getCurrentService)
-               self["ber_progress"] = TunerInfo(TunerInfo.BER_BAR, servicefkt = self.session.nav.getCurrentService)
-               self.timer = eTimer()
-               self.timer.timeout.get().append(self.updateTunerInfo)
-               self.timer.start(1000)
-
-       def updateTunerInfo(self):
-               if self.instance.isVisible():
-                       self["snr_percent"].update()
-                       self["agc_percent"].update()
-                       self["ber_count"].update()
-                       self["snr_progress"].update()
-                       self["agc_progress"].update()
-                       self["ber_progress"].update()
+               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"""


@@ -679,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):


@@ -920,7 +913,9 @@ class InfoBarTimeshift:
                        if not ts.startTimeshift():
                                import time
                                self.timeshift_enabled = 1
                        if not ts.startTimeshift():
                                import time
                                self.timeshift_enabled = 1

-                               self.pvrStateDialog["timeshift"].setRelative(time.time())
+                               
+                               # 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)


@@ -1009,7 +1004,7 @@ from Screens.PiPSetup import PiPSetup
 
 class InfoBarExtensions:
        def __init__(self):
 
 class InfoBarExtensions:
        def __init__(self):

-               self.pipshown = False
+               self.session.pipshown = False

                
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {


@@ -1019,39 +1014,58 @@ class InfoBarExtensions:
        PIPON = 0
        PIPOFF = 1
        MOVEPIP = 2
        PIPON = 0
        PIPOFF = 1
        MOVEPIP = 2

+       PIPSWAP = 3
+       ENABLE_SUBTITLE = 4

 
        def extensions(self):
                list = []
 
        def extensions(self):
                list = []

-               if self.pipshown == False:
+               if self.session.pipshown == False:

                        list.append((_("Activate Picture in Picture"), self.PIPON))
                        list.append((_("Activate Picture in Picture"), self.PIPON))

-               elif self.pipshown == True:
+               elif self.session.pipshown == True:

                        list.append((_("Disable Picture in Picture"), self.PIPOFF))
                        list.append((_("Move Picture in Picture"), self.MOVEPIP))
                        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.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.nav.stopService()
-                               self.pip = self.session.instantiateDialog(PictureInPicture)
-                               #self.pip.show()
-                               
+                               self.session.pip = self.session.instantiateDialog(PictureInPicture)

                                newservice = self.session.nav.getCurrentlyPlayingServiceReference()
                                newservice = self.session.nav.getCurrentlyPlayingServiceReference()

-                               self.pipservice = eServiceCenter.getInstance().play(newservice)
-                               if self.pipservice and not self.pipservice.setTarget(1):
-                                       self.pipservice.start()
-                                       self.pipshown = True
+                               if self.session.pip.playService(newservice):
+                                       self.session.pipshown = True
+                                       self.session.pip.servicePath = self.servicelist.getCurrentServicePath()

                                else:
                                else:

-                                       self.pipservice = None
-                                       del self.pip
+                                       self.session.pipshown = False
+                                       del self.session.pip

                                self.session.nav.playService(newservice)
                        elif answer[1] == self.PIPOFF:
                                self.session.nav.playService(newservice)
                        elif answer[1] == self.PIPOFF:

-                               #self.pip.hide()
-                               self.pipservice = None
-                               del self.pip
-                               self.pipshown = False
+                               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:
                        elif answer[1] == self.MOVEPIP:

-                               self.session.open(PiPSetup, pip = self.pip)
+                               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
 
 
 from RecordTimer import parseEvent
 


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


@@ -1190,15 +1204,19 @@ class InfoBarAudioSelection:
 
        def audioSelection(self):
                service = self.session.nav.getCurrentService()
 
        def audioSelection(self):
                service = self.session.nav.getCurrentService()

-               audio = service.audioTracks()
-               self.audio = audio
-               n = audio.getNumberOfTracks()
-               if n > 0:
-                       tlist = []
+               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()
                        for x in range(n):
                                i = audio.getTrackInfo(x)
                                language = i.getLanguage()

-                               description = i.getDescription();
+                               description = i.getDescription()

        
                                if len(language) == 3:
                                        if language in LanguageCodes:
        
                                if len(language) == 3:
                                        if language in LanguageCodes:


@@ -1213,33 +1231,98 @@ class InfoBarAudioSelection:
                        
                        selectedAudio = tlist[0][1]
                        tlist.sort(lambda x,y : cmp(x[0], y[0]))
                        
                        selectedAudio = tlist[0][1]
                        tlist.sort(lambda x,y : cmp(x[0], y[0]))

-                       selection = 0
+
+                       selection = 2

                        for x in tlist:
                                if x[1] != selectedAudio:
                                        selection += 1
                                else:
                                        break
                        for x in tlist:
                                if x[1] != selectedAudio:
                                        selection += 1
                                else:
                                        break

-                       
-                       self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection)
+
+                       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:
 
        def audioSelected(self, audio):
                if audio is not None:

-                       self.audio.selectTrack(audio[1])
+                       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()
+               subservices = service and service.subServices()

                
                

-               n = subservices.getNumberOfSubservices()
+               n = subservices and subservices.getNumberOfSubservices()

                selection = 0
                selection = 0

-               if n > 0:
+               if n and n > 0:

                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                        tlist = []
                        for x in range(n):
                        ref = self.session.nav.getCurrentlyPlayingServiceReference()
                        tlist = []
                        for x in range(n):


@@ -1252,106 +1335,61 @@ class InfoBarSubserviceSelection:
 
        def subserviceSelected(self, service):
                if not service is None:
 
        def subserviceSelected(self, service):
                if not service is None:

+                       self["SubserviceQuickzapAction"].setEnabled(True)

                        self.session.nav.playService(service[1])
 
 class InfoBarAdditionalInfo:
        def __init__(self):
                        self.session.nav.playService(service[1])
 
 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: True)
-               self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)
-               self["ButtonBlueText"].setConnect(lambda: True)
-               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
+               self["NimA"] = Pixmap()
+               self["NimB"] = Pixmap()
+               self["NimA_Active"] = Pixmap()
+               self["NimB_Active"] = Pixmap()

 
 

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

 
 

-       def showSubServiceIndication(self):
-               self["ButtonGreen"].show()
-               self["ButtonGreenText"].show()
-
-       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"].show()
-                       else:
-                               self["FormatActive"].hide()
+               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"].show()
+                       self["NimA_Active"].hide()
+               if mask&2:
+                       self["NimB_Active"].show()

                else:
                else:

-                       self["DolbyActive"].hide()
-
-       def checkCrypted(self, service):
-               info = service.info()
-               if info is not None:
-                       if info.getInfo(iServiceInformation.sIsCrypted) > 0:
-                               self["CryptActive"].show()
-                       else:
-                               self["CryptActive"].hide()
+                       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"].hide()
-                       self["DolbyActive"].hide()
-                       self["FormatActive"].hide()
+               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:


@@ -1361,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):


@@ -1506,14 +1543,18 @@ class InfoBarCueSheetSupport:
 class InfoBarSummary(Screen):
        skin = """
        <screen position="0,0" size="132,64">
 class InfoBarSummary(Screen):
        skin = """
        <screen position="0,0" size="132,64">

-               <widget name="Clock" position="50,46" size="82,18" font="Regular;16" />
-               <widget name="CurrentService" position="0,4" size="132,42" font="Regular;18" />
+               <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)
        </screen>"""
 
        def __init__(self, session, parent):
                Screen.__init__(self, session)

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

 
 class InfoBarSummarySupport:
        def __init__(self):
 
 class InfoBarSummarySupport:
        def __init__(self):


@@ -1539,3 +1580,50 @@ class InfoBarTeletextPlugin:
 
        def startTeletext(self):
                self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
 
        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)