make resume optional
[enigma2.git] / lib / python / Screens / InfoBarGenerics.py
index 954e9d1fcb2e59fe4cd523af58a6a897d22ed632..754b673ac04d3b91d5cea9ae4bde489acae4b124 100644 (file)
@@ -1,29 +1,38 @@
-from Screen import Screen
+from ChannelSelection import ChannelSelection, BouquetSelector
+
 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.Pixmap import Pixmap, PixmapConditional
+from Components.PluginComponent import plugins
 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 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 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.Standby import Standby
 from Screens.EventView import EventViewEPGSelect, EventViewSimple
+from Screens.InputBox import InputBox
+from Screens.MessageBox import MessageBox
 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 *
@@ -162,41 +171,6 @@ class NumberZap(Screen):
                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):
@@ -266,23 +240,47 @@ class InfoBarNumberZap:
                        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)
+               
+               if config.misc.initialchannelselection.value == 1:
+                       self.onShown.append(self.firstRun)
 
                self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
                        {
-                               "switchChannelUp": self.switchChannelUp,
-                               "switchChannelDown": self.switchChannelDown,
+                               "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
+                               "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
                                "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 servicelist")),
                        })
 
+       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()
 
@@ -296,18 +294,41 @@ class InfoBarChannelSelection:
        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":
-                       if self.servicelist.inBouquet() and self.servicelist.atBegin():
-                               self.servicelist.prevBouquet()
-               self.servicelist.moveUp()
+               if self.servicelist.inBouquet():
+                       prev = self.servicelist.getCurrentSelection()
+                       if prev:
+                               prev = prev.toString()
+                               while True:
+                                       if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes":
+                                               if self.servicelist.atBegin():
+                                                       self.servicelist.prevBouquet()
+                                       self.servicelist.moveUp()
+                                       cur = self.servicelist.getCurrentSelection()
+                                       if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
+                                               break
+               else:
+                       self.servicelist.moveUp()
                self.servicelist.zap()
                self.doShow()
 
        def zapDown(self):
-               if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.inBouquet() and self.servicelist.atEnd():
-                       self.servicelist.nextBouquet()
+               if self.servicelist.inBouquet():
+                       prev = self.servicelist.getCurrentSelection()
+                       if prev:
+                               prev = prev.toString()
+                               while True:
+                                       if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.atEnd():
+                                               self.servicelist.nextBouquet()
+                                       else:
+                                               self.servicelist.moveDown()
+                                       cur = self.servicelist.getCurrentSelection()
+                                       if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
+                                               break
                else:
                        self.servicelist.moveDown()
                self.servicelist.zap()
@@ -318,7 +339,7 @@ class InfoBarMenu:
        def __init__(self):
                self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 
                        {
-                               "mainMenu": (self.mainMenu, "Enter main menu..."),
+                               "mainMenu": (self.mainMenu, _("Enter main menu...")),
                        })
 
        def mainMenu(self):
@@ -359,6 +380,15 @@ class InfoBarSimpleEventView:
 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...")),
@@ -374,8 +404,7 @@ class InfoBarEPG:
                        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:
@@ -386,16 +415,39 @@ class InfoBarEPG:
                                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:
-                               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:
-                               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:
-                       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()
@@ -405,38 +457,55 @@ class InfoBarEPG:
                        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:
-                               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()
-               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()
-               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)
-               ptr=info.getEvent(1)
+               ptr = info and info.getEvent(1)
                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:
+                       self.is_now_next = False
                        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)
+               else:
+                       self.is_now_next = True
                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)
@@ -448,67 +517,20 @@ class InfoBarEPG:
                        self.epglist[1]=tmp
                        setEvent(self.epglist[0])
 
-from math import log
-
 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):
-               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):
-               self["ServiceName"] = ServiceName(self.session.nav)
+               self["CurrentService"] = CurrentService(self.session.nav)
 
 class InfoBarSeek:
        """handles actions like seeking, pause"""
@@ -551,18 +573,19 @@ class InfoBarSeek:
                                if action[:5] == "seek:":
                                        time = int(action[5:])
                                        self.screen.seekRelative(time * 90000)
+                                       return 1
                                else:
-                                       HelpableActionMap.action(self, contexts, action)
+                                       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"),
+                               "seekFwd": (self.seekFwd, _("skip forward")),
                                "seekFwdDown": self.seekFwdDown,
                                "seekFwdUp": self.seekFwdUp,
-                               "seekBack": (self.seekBack, "skip backward"),
+                               "seekBack": (self.seekBack, _("skip backward")),
                                "seekBackDown": self.seekBackDown,
                                "seekBackUp": self.seekBackUp,
                        }, prio=-1)
@@ -596,7 +619,7 @@ class InfoBarSeek:
        def getSeek(self):
                service = self.session.nav.getCurrentService()
                if service is None:
-                       return False
+                       return None
 
                seek = service.seek()
 
@@ -652,7 +675,7 @@ class InfoBarSeek:
                self.checkSkipShowHideLock()
 
                return True
-               
+
        def pauseService(self):
                if self.seekstate == self.SEEK_STATE_PAUSE:
                        print "pause, but in fact unpause"
@@ -667,6 +690,8 @@ class InfoBarSeek:
                
        def unPauseService(self):
                print "unpause"
+               if self.seekstate == self.SEEK_STATE_PLAY:
+                       return 0
                self.setSeekState(self.SEEK_STATE_PLAY);
        
        def doSeek(self, seektime):
@@ -748,7 +773,7 @@ class InfoBarSeek:
                if self.seekstate == self.SEEK_STATE_PAUSE:
                        seekable = self.getSeek()
                        if seekable is not None:
-                               seekable.seekRelative(-1, 2)
+                               seekable.seekRelative(-1, 3)
 
        def fwdTimerFire(self):
                print "Display seek fwd"
@@ -802,17 +827,17 @@ class InfoBarSeek:
                if seekable is not None:
                        seekable.seekRelative(1, diff)
 
-from Screens.PVRState import PVRState
+from Screens.PVRState import PVRState, TimeshiftState
 
 class InfoBarPVRState:
-       def __init__(self):
+       def __init__(self, screen=PVRState):
                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):
-               if self.seekstate != self.SEEK_STATE_PLAY:
+               if self.seekstate != self.SEEK_STATE_PLAY and self.execing:
                        self.pvrStateDialog.show()
 
        def __playStateChanged(self, state):
@@ -820,6 +845,10 @@ class InfoBarPVRState:
                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. 
@@ -865,8 +894,8 @@ class InfoBarTimeshift:
        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"],
                        {
@@ -881,27 +910,32 @@ class InfoBarTimeshift:
 
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
+                               iPlayableService.evStart: self.__serviceStarted,
                                iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
                        })
        
        def getTimeshift(self):
                service = self.session.nav.getCurrentService()
-               return service.timeshift()
+               return service and service.timeshift()
 
        def startTimeshift(self):
                print "enable timeshift"
                ts = self.getTimeshift()
                if ts is None:
-                       self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
-                       print "no ts interface"
-                       return
+#                      self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
+#                      print "no ts interface"
+                       return 0;
                
                if self.timeshift_enabled:
                        print "hu, timeshift already enabled?"
                else:
                        if not ts.startTimeshift():
+                               import time
                                self.timeshift_enabled = 1
-                               
+
+                               # we remove the "relative time" for now.
+                               #self.pvrStateDialog["timeshift"].setRelative(time.time())
+                                       
                                # PAUSE.
                                self.setSeekState(self.SEEK_STATE_PAUSE)
                                
@@ -913,11 +947,11 @@ class InfoBarTimeshift:
 
        def stopTimeshift(self):
                if not self.timeshift_enabled:
-                       return
+                       return 0
                print "disable timeshift"
                ts = self.getTimeshift()
                if ts is None:
-                       return
+                       return 0
                self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
 
        def stopTimeshiftConfirmed(self, confirmed):
@@ -981,6 +1015,77 @@ class InfoBarTimeshift:
                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(("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:
@@ -989,67 +1094,111 @@ class 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"].hide()
                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, limitEvent = False):
                serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
                
                # try to get event info
                event = None
-               if limitEvent:
-                       try:
-                               service = self.session.nav.getCurrentService()
-                               epg = eEPGCache.getInstance()
-                               event = epg.lookupEventTime(serviceref, -1, 0)
-                               if event is None:
-                                       info = service.info()
-                                       ev = info.getEvent(0)
-                                       event = ev
-                       except:
-                               pass
+               try:
+                       service = self.session.nav.getCurrentService()
+                       epg = eEPGCache.getInstance()
+                       event = epg.lookupEventTime(serviceref, -1, 0)
                        if event is None:
-                               self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
+                               info = service.info()
+                               ev = info.getEvent(0)
+                               event = ev
+               except:
+                       pass
 
+               begin = time.time()
+               end = time.time() + 3600 * 10
+               name = "instant record"
+               description = ""
+               eventid = 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:
-                       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):
-               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):
+               print "pre:\n", self.recording
+               
                if answer is None or answer[1] == "no":
                        return
-               
-               if self.isInstantRecordRunning():
-                       self.stopCurrentRecording()
-               else:
+               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:
@@ -1057,148 +1206,209 @@ class InfoBarInstantRecord:
                except:
                        self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
                        return
-       
+
                if self.isInstantRecordRunning():
-                       self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Do you want to stop the current\n(instant) recording?"), list=[(_("yes"), "yes"), (_("no"), "no")])
-#                      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:
-                       self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Do you want to stop the current\n(instant) recording?"), list=[(_("record indefinitely"), "indefinitely"), (_("stop after current event"), "event"), (_("don't record"), "no")])
-                       #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", 
                        {
-                               "audioSelection": (self.audioSelection, "Audio Options..."),
+                               "audioSelection": (self.audioSelection, _("Audio Options...")),
                        })
 
        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",
                        {
-                               "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()
-               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:
-                       self.session.nav.playService(service)
+                       self["SubserviceQuickzapAction"].setEnabled(True)
+                       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: 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"].hide()
-               self["ButtonGreenText"].hide()
+               self["NimA"] = Pixmap()
+               self["NimB"] = Pixmap()
+               self["NimA_Active"] = Pixmap()
+               self["NimB_Active"] = Pixmap()
 
-       def showSubServiceIndication(self):
-               self["ButtonGreen"].show()
-               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"].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:
-                       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:
-                       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()
-               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)
+               self.onClose.append(self.__removeNotification)
+       
+       def __removeNotification(self):
+               Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
        
        def checkNotificationsIfExecing(self):
                if self.execing:
@@ -1208,12 +1418,11 @@ class InfoBarNotifications:
                if len(Notifications.notifications):
                        n = Notifications.notifications[0]
                        Notifications.notifications = Notifications.notifications[1:]
-                       print "open",n
                        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:
-                               self.session.open(*n[1:])
+                               self.session.open(n[1], *n[2], **n[3])
 
 class InfoBarServiceNotifications:
        def __init__(self):
@@ -1234,6 +1443,9 @@ class InfoBarCueSheetSupport:
        CUT_TYPE_IN = 0
        CUT_TYPE_OUT = 1
        CUT_TYPE_MARK = 2
+       CUT_TYPE_LAST = 3
+       
+       ENABLE_RESUME_SUPPORT = False
        
        def __init__(self):
                self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions", 
@@ -1244,14 +1456,34 @@ class InfoBarCueSheetSupport:
                        }, prio=1) 
                
                self.cut_list = [ ]
+               self.is_closing = False
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evStart: self.__serviceStarted,
                        })
 
        def __serviceStarted(self):
+               if self.is_closing:
+                       return
                print "new service started! trying to download cuts!"
                self.downloadCuesheet()
+               
+               if self.ENABLE_RESUME_SUPPORT:
+                       last = None
+                       
+                       for (pts, what) in self.cut_list:
+                               if what == self.CUT_TYPE_LAST:
+                                       last = pts
+                       
+                       if last is not None:
+                               self.resume_point = last
+                               Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
+
+       def playLastCB(self, answer):
+               if answer == True:
+                       seekable = self.__getSeekable()
+                       if seekable is not None:
+                               seekable.seekTo(self.resume_point)
 
        def __getSeekable(self):
                service = self.session.nav.getCurrentService()
@@ -1349,3 +1581,91 @@ class InfoBarCueSheetSupport:
                        print "upload failed, no cuesheet interface"
                        return
                self.cut_list = cue.getCutList()
+
+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)