git.cweiske.de / enigma2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
fix getBouquetList
[enigma2.git] / lib / python / Screens / InfoBarGenerics.py
diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index e296038b2344fcd317016072a9852bcc507a6298..dc5ddecc3fef92950a89cc96f5e576b2c31f28ad 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.RadioText import RadioText
+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, ConfigBoolean
 
 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
 
 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
@@ -30,6 +31,8 @@ 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 Screens.SleepTimerEdit import SleepTimerEdit
 from ServiceReference import ServiceReference
 
 from Tools import Notifications
 from ServiceReference import ServiceReference
 
 from Tools import Notifications
@@ -42,8 +45,6 @@ import time
 import os
 import bisect
 
 import os
 import bisect
 
-from Components.config import config, currentConfigSelectionElement
-
 # hack alert!
 from Menu import MainMenu, mdom
 
 # hack alert!
 from Menu import MainMenu, mdom
 
@@ -85,7 +86,9 @@ class InfoBarShowHide:
        
        def startHideTimer(self):
                if self.__state == self.STATE_SHOWN and not self.__locked:
        
        def startHideTimer(self):
                if self.__state == self.STATE_SHOWN and not self.__locked:
-                       self.hideTimer.start(5000, True)
+                       idx = config.usage.infobar_timeout.index
+                       if idx:
+                               self.hideTimer.start(idx*1000, True)
 
        def __onHide(self):
                self.__state = self.STATE_HIDDEN
 
        def __onHide(self):
                self.__state = self.STATE_HIDDEN
@@ -190,7 +193,8 @@ class InfoBarNumberZap:
 #              print "You pressed number " + str(number)
                if number == 0:
                        self.servicelist.recallPrevService()
 #              print "You pressed number " + str(number)
                if number == 0:
                        self.servicelist.recallPrevService()
-                       self.doShow()
+                       if config.usage.show_infobar_on_zap.value:
+                               self.doShow()
                else:
                        self.session.openWithCallback(self.numberEntered, NumberZap, number)
 
                else:
                        self.session.openWithCallback(self.numberEntered, NumberZap, number)
 
@@ -238,7 +242,7 @@ class InfoBarNumberZap:
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 
-config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1);
+config.misc.initialchannelselection = ConfigBoolean(default = True)
 
 class InfoBarChannelSelection:
        """ ChannelSelection - handles the channelSelection dialog and the initial 
 
 class InfoBarChannelSelection:
        """ ChannelSelection - handles the channelSelection dialog and the initial 
@@ -247,25 +251,38 @@ class InfoBarChannelSelection:
                #instantiate forever
                self.servicelist = self.session.instantiateDialog(ChannelSelection)
                
                #instantiate forever
                self.servicelist = self.session.instantiateDialog(ChannelSelection)
                
-               if config.misc.initialchannelselection.value == 1:
+               if config.misc.initialchannelselection.value:
                        self.onShown.append(self.firstRun)
 
                self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
                        {
                        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")),
                                "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)
        def firstRun(self):
                self.onShown.remove(self.firstRun)
-               config.misc.initialchannelselection.value = 0
+               config.misc.initialchannelselection.value = False
                config.misc.initialchannelselection.save()
                self.switchChannelDown()
                config.misc.initialchannelselection.save()
                self.switchChannelDown()
-               
+
        def historyBack(self):
                self.servicelist.historyBack()
 
        def historyBack(self):
                self.servicelist.historyBack()
 
@@ -279,36 +296,70 @@ 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):
 
        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 config.usage.quickzap_bouquet_change.value:
+                                               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.servicelist.zap()
-               self.doShow()
+               if config.usage.show_infobar_on_zap.value:
+                       self.doShow()
 
        def zapDown(self):
 
        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 config.usage.quickzap_bouquet_change.value 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()
                else:
                        self.servicelist.moveDown()
                self.servicelist.zap()
-               self.doShow()
+               if config.usage.show_infobar_on_zap.value:
+                       self.doShow()
 
 class InfoBarMenu:
        """ Handles a menu action, to open the (main) menu """
        def __init__(self):
                self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 
                        {
 
 class InfoBarMenu:
        """ Handles a menu action, to open the (main) menu """
        def __init__(self):
                self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 
                        {
-                               "mainMenu": (self.mainMenu, "Enter main menu..."),
+                               "mainMenu": (self.mainMenu, _("Enter main menu...")),
                        })
                        })
+               self.session.infobar = None
 
        def mainMenu(self):
                print "loading mainmenu XML..."
                menu = mdom.childNodes[0]
                assert menu.tagName == "menu", "root element in menu must be 'menu'!"
 
        def mainMenu(self):
                print "loading mainmenu XML..."
                menu = mdom.childNodes[0]
                assert menu.tagName == "menu", "root element in menu must be 'menu'!"
-               self.session.open(MainMenu, menu, menu.childNodes)
+
+               self.session.infobar = self
+               # so we can access the currently active infobar from screens opened from within the mainmenu
+               # at the moment used from the SubserviceSelection
+
+               self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu, menu.childNodes)
+
+       def mainMenuClosed(self, *val):
+               self.session.infobar = None
 
 class InfoBarSimpleEventView:
        """ Opens the Eventview for now/next """
 
 class InfoBarSimpleEventView:
        """ Opens the Eventview for now/next """
@@ -342,6 +393,15 @@ class InfoBarSimpleEventView:
 class InfoBarEPG:
        """ EPG - Opens an EPG list when the showEPGList action fires """
        def __init__(self):
 class InfoBarEPG:
        """ EPG - Opens an EPG list when the showEPGList action fires """
        def __init__(self):
+               self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+                       {
+                               iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
+                       })
+
+               self.is_now_next = False
+               self.dlg_stack = [ ]
+               self.bouquetSel = None
+               self.eventView = None
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),
                self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 
                        {
                                "showEventInfo": (self.openEventView, _("show EPG...")),
@@ -357,8 +417,7 @@ class InfoBarEPG:
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 
                        self.servicelist.setCurrentSelection(service) #select the service in servicelist
                        self.servicelist.zap()
 
-       def openBouquetEPG(self, bouquet, withCallback=True):
-               ptr=eEPGCache.getInstance()
+       def getBouquetServices(self, bouquet):
                services = [ ]
                servicelist = eServiceCenter.getInstance().list(bouquet)
                if not servicelist is None:
                services = [ ]
                servicelist = eServiceCenter.getInstance().list(bouquet)
                if not servicelist is None:
@@ -369,16 +428,39 @@ class InfoBarEPG:
                                if service.flags: #ignore non playable services
                                        continue
                                services.append(ServiceReference(service))
                                if service.flags: #ignore non playable services
                                        continue
                                services.append(ServiceReference(service))
+               return services
+
+       def openBouquetEPG(self, bouquet, withCallback=True):
+               services = self.getBouquetServices(bouquet)
                if len(services):
                        self.epg_bouquet = bouquet
                        if withCallback:
                if len(services):
                        self.epg_bouquet = bouquet
                        if withCallback:
-                               self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService)
+                               self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
                        else:
                        else:
-                               self.session.open(EPGSelection, services, self.zapToService)
+                               self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
 
 
-       def closed(self, ret):
+       def changeBouquetCB(self, direction, epg):
+               if self.bouquetSel:
+                       if direction > 0:
+                               self.bouquetSel.down()
+                       else:
+                               self.bouquetSel.up()
+                       bouquet = self.bouquetSel.getCurrent()
+                       services = self.getBouquetServices(bouquet)
+                       if len(services):
+                               self.epg_bouquet = bouquet
+                               epg.setServices(services)
+
+       def closed(self, ret=False):
+               closedScreen = self.dlg_stack.pop()
+               if self.bouquetSel and closedScreen == self.bouquetSel:
+                       self.bouquetSel = None
+               elif self.eventView and closedScreen == self.eventView:
+                       self.eventView = None
                if ret:
                if ret:
-                       self.close(ret)
+                       dlgs=len(self.dlg_stack)
+                       if dlgs > 0:
+                               self.dlg_stack[dlgs-1].close(dlgs > 1)
 
        def openMultiServiceEPG(self, withCallback=True):
                bouquets = self.servicelist.getBouquetList()
 
        def openMultiServiceEPG(self, withCallback=True):
                bouquets = self.servicelist.getBouquetList()
@@ -388,38 +470,55 @@ class InfoBarEPG:
                        cnt = len(bouquets)
                if cnt > 1: # show bouquet list
                        if withCallback:
                        cnt = len(bouquets)
                if cnt > 1: # show bouquet list
                        if withCallback:
-                               self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG)
+                               self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
+                               self.dlg_stack.append(self.bouquetSel)
                        else:
                        else:
-                               self.session.open(BouquetSelector, bouquets, self.openBouquetEPG)
+                               self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
                elif cnt == 1: 
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
        def openSingleServiceEPG(self):
                ref=self.session.nav.getCurrentlyPlayingServiceReference()
                elif cnt == 1: 
                        self.openBouquetEPG(bouquets[0][1], withCallback)
 
        def openSingleServiceEPG(self):
                ref=self.session.nav.getCurrentlyPlayingServiceReference()
-               ptr=eEPGCache.getInstance()
-               self.session.openWithCallback(self.closed, EPGSelection, ref)
+               self.session.open(EPGSelection, ref)
 
 
-       def openEventView(self):
+       def openSimilarList(self, eventid, refstr):
+               self.session.open(EPGSelection, refstr, None, eventid)
+
+       def getNowNext(self):
                self.epglist = [ ]
                service = self.session.nav.getCurrentService()
                self.epglist = [ ]
                service = self.session.nav.getCurrentService()
-               ref = self.session.nav.getCurrentlyPlayingServiceReference()
-               info = service.info()
-               ptr=info.getEvent(0)
+               info = service and service.info()
+               ptr = info and info.getEvent(0)
                if ptr:
                        self.epglist.append(ptr)
                if ptr:
                        self.epglist.append(ptr)
-               ptr=info.getEvent(1)
+               ptr = info and info.getEvent(1)
                if ptr:
                        self.epglist.append(ptr)
                if ptr:
                        self.epglist.append(ptr)
+
+       def __evEventInfoChanged(self):
+               if self.is_now_next and len(self.dlg_stack) == 1:
+                       self.getNowNext()
+                       assert self.eventView
+                       if len(self.epglist):
+                               self.eventView.setEvent(self.epglist[0])
+
+       def openEventView(self):
+               ref = self.session.nav.getCurrentlyPlayingServiceReference()
+               self.getNowNext()
                if len(self.epglist) == 0:
                if len(self.epglist) == 0:
+                       self.is_now_next = False
                        epg = eEPGCache.getInstance()
                        epg = eEPGCache.getInstance()
-                       ptr = epg.lookupEventTime(ref, -1)
+                       ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
                        if ptr:
                                self.epglist.append(ptr)
                                ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
                                if ptr:
                                        self.epglist.append(ptr)
                        if ptr:
                                self.epglist.append(ptr)
                                ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
                                if ptr:
                                        self.epglist.append(ptr)
+               else:
+                       self.is_now_next = True
                if len(self.epglist) > 0:
                if len(self.epglist) > 0:
-                       self.session.open(EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG)
+                       self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
+                       self.dlg_stack.append(self.eventView)
                else:
                        print "no epg for the service avail.. so we show multiepg instead of eventinfo"
                        self.openMultiServiceEPG(False)
                else:
                        print "no epg for the service avail.. so we show multiepg instead of eventinfo"
                        self.openMultiServiceEPG(False)
@@ -434,45 +533,22 @@ 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["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW)
+               self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT)
 
 
-               self["Now_ProgressBar"] = EventInfoProgress(self.session.nav, EventInfo.Now)
+class InfoBarRadioText:
+       """provides radio (RDS) text info display"""
+       def __init__(self):
+               self["RadioText"] = RadioText(self.session.nav)
 
 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"""
@@ -521,13 +597,13 @@ class InfoBarSeek:
 
                self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", 
                        {
 
                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,
                                "seekFwdDown": self.seekFwdDown,
                                "seekFwdUp": self.seekFwdUp,
-                               "seekBack": (self.seekBack, "skip backward"),
+                               "seekBack": (self.seekBack, _("skip backward")),
                                "seekBackDown": self.seekBackDown,
                                "seekBackUp": self.seekBackUp,
                        }, prio=-1)
                                "seekBackDown": self.seekBackDown,
                                "seekBackUp": self.seekBackUp,
                        }, prio=-1)
@@ -561,7 +637,7 @@ class InfoBarSeek:
        def getSeek(self):
                service = self.session.nav.getCurrentService()
                if service is None:
        def getSeek(self):
                service = self.session.nav.getCurrentService()
                if service is None:
-                       return False
+                       return None
 
                seek = service.seek()
 
 
                seek = service.seek()
 
@@ -632,7 +708,9 @@ class InfoBarSeek:
                
        def unPauseService(self):
                print "unpause"
                
        def unPauseService(self):
                print "unpause"
-               self.setSeekState(self.SEEK_STATE_PLAY);
+               if self.seekstate == self.SEEK_STATE_PLAY:
+                       return 0
+               self.setSeekState(self.SEEK_STATE_PLAY)
        
        def doSeek(self, seektime):
                print "doseek", seektime
        
        def doSeek(self, seektime):
                print "doseek", seektime
@@ -741,13 +819,14 @@ class InfoBarSeek:
        def checkSkipShowHideLock(self):
                wantlock = self.seekstate != self.SEEK_STATE_PLAY
                
        def checkSkipShowHideLock(self):
                wantlock = self.seekstate != self.SEEK_STATE_PLAY
                
-               if self.lockedBecauseOfSkipping and not wantlock:
-                       self.unlockShow()
-                       self.lockedBecauseOfSkipping = False
+               if config.usage.show_infobar_on_zap.value:
+                       if self.lockedBecauseOfSkipping and not wantlock:
+                               self.unlockShow()
+                               self.lockedBecauseOfSkipping = False
                
                
-               if wantlock and not self.lockedBecauseOfSkipping:
-                       self.lockShow()
-                       self.lockedBecauseOfSkipping = True
+                       if wantlock and not self.lockedBecauseOfSkipping:
+                               self.lockShow()
+                               self.lockedBecauseOfSkipping = True
 
        def __evEOF(self):
                if self.seekstate != self.SEEK_STATE_PLAY:
 
        def __evEOF(self):
                if self.seekstate != self.SEEK_STATE_PLAY:
@@ -767,6 +846,11 @@ class InfoBarSeek:
                if seekable is not None:
                        seekable.seekRelative(1, diff)
 
                if seekable is not None:
                        seekable.seekRelative(1, diff)
 
+       def seekAbsolute(self, abs):
+               seekable = self.getSeek()
+               if seekable is not None:
+                       seekable.seekTo(abs)
+
 from Screens.PVRState import PVRState, TimeshiftState
 
 class InfoBarPVRState:
 from Screens.PVRState import PVRState, TimeshiftState
 
 class InfoBarPVRState:
@@ -789,7 +873,6 @@ class InfoBarTimeshiftState(InfoBarPVRState):
        def __init__(self):
                InfoBarPVRState.__init__(self, screen=TimeshiftState)
 
        def __init__(self):
                InfoBarPVRState.__init__(self, screen=TimeshiftState)
 
-
 class InfoBarShowMovies:
 
        # i don't really like this class. 
 class InfoBarShowMovies:
 
        # i don't really like this class. 
@@ -835,8 +918,8 @@ class InfoBarTimeshift:
        def __init__(self):
                self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", 
                        {
        def __init__(self):
                self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", 
                        {
-                               "timeshiftStart": (self.startTimeshift, "start timeshift"),  # the "yellow key"
-                               "timeshiftStop": (self.stopTimeshift, "stop timeshift")      # currently undefined :), probably 'TV'
+                               "timeshiftStart": (self.startTimeshift, _("start timeshift")),  # the "yellow key"
+                               "timeshiftStop": (self.stopTimeshift, _("stop timeshift"))      # currently undefined :), probably 'TV'
                        }, prio=1)
                self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
                        {
                        }, prio=1)
                self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
                        {
@@ -857,7 +940,7 @@ class InfoBarTimeshift:
        
        def getTimeshift(self):
                service = self.session.nav.getCurrentService()
        
        def getTimeshift(self):
                service = self.session.nav.getCurrentService()
-               return service.timeshift()
+               return service and service.timeshift()
 
        def startTimeshift(self):
                print "enable timeshift"
 
        def startTimeshift(self):
                print "enable timeshift"
@@ -865,7 +948,7 @@ class InfoBarTimeshift:
                if ts is None:
                        self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
                        print "no ts interface"
                if ts is None:
                        self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
                        print "no ts interface"
-                       return
+                       return 0;
                
                if self.timeshift_enabled:
                        print "hu, timeshift already enabled?"
                
                if self.timeshift_enabled:
                        print "hu, timeshift already enabled?"
@@ -873,8 +956,10 @@ 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)
                                
@@ -886,11 +971,11 @@ class InfoBarTimeshift:
 
        def stopTimeshift(self):
                if not self.timeshift_enabled:
 
        def stopTimeshift(self):
                if not self.timeshift_enabled:
-                       return
+                       return 0
                print "disable timeshift"
                ts = self.getTimeshift()
                if ts is None:
                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):
                self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
 
        def stopTimeshiftConfirmed(self, confirmed):
@@ -958,43 +1043,167 @@ class InfoBarTimeshift:
                self.timeshift_enabled = False
                self.__seekableStatusChanged()
 
                self.timeshift_enabled = False
                self.__seekableStatusChanged()
 
+from Screens.PiPSetup import PiPSetup
+
 class InfoBarExtensions:
 class InfoBarExtensions:
+       EXTENSION_SINGLE = 0
+       EXTENSION_LIST = 1
+       
        def __init__(self):
        def __init__(self):
-               self.pipshown = False
+               self.list = []
                
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
                
                self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
                        {
-                               "extensions": (self.extensions, "Extensions..."),
+                               "extensions": (self.showExtensionSelection, _("view extensions...")),
                        })
                        })
+
+       def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
+               self.list.append((type, extension, key))
+               
+       def updateExtension(self, extension, key = None):
+               self.extensionsList.append(extension)
+               if key is not None:
+                       if self.extensionKeys.has_key(key):
+                               key = None
+               
+               if key is None:
+                       for x in self.availableKeys:
+                               if not self.extensionKeys.has_key(x):
+                                       key = x
+                                       break
+
+               if key is not None:
+                       self.extensionKeys[key] = len(self.extensionsList) - 1
                        
                        
-       def extensions(self):
+       def updateExtensions(self):
+               self.extensionsList = []
+               self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
+               self.extensionKeys = {}
+               for x in self.list:
+                       if x[0] == self.EXTENSION_SINGLE:
+                               self.updateExtension(x[1], x[2])
+                       else:
+                               for y in x[1]():
+                                       self.updateExtension(y[0], y[1])
+
+
+       def showExtensionSelection(self):
+               self.updateExtensions()
+               extensionsList = self.extensionsList[:]
+               keys = []
                list = []
                list = []
-               if self.pipshown == False:
-                       list.append((_("Activate Picture in Picture"), "pipon"))
-               elif self.pipshown == True:
-                       list.append((_("Disable Picture in Picture"), "pipoff"))
-               self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list)
+               for x in self.availableKeys:
+                       if self.extensionKeys.has_key(x):
+                               entry = self.extensionKeys[x]
+                               extension = self.extensionsList[entry]
+                               if extension[2]():
+                                       name = str(extension[0]())
+                                       list.append((extension[0](), extension))
+                                       keys.append(x)
+                                       extensionsList.remove(extension)
+                               else:
+                                       extensionsList.remove(extension)
+               for x in extensionsList:
+                       list.append((x[0](), x))
+               keys += [""] * len(extensionsList)
+               self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
 
        def extensionCallback(self, answer):
                if answer is not None:
 
        def extensionCallback(self, answer):
                if answer is not None:
-                       if answer[1] == "pipon":
-                               self.session.nav.stopService()
-                               self.pip = self.session.instantiateDialog(PictureInPicture)
-                               #self.pip.show()
-                               
-                               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
-                               else:
-                                       self.pipservice = None
-                                       del self.pip
+                       answer[1][1]()
+
+from Tools.BoundFunction import boundFunction
+
+# depends on InfoBarExtensions
+from Components.PluginComponent import plugins
+
+class InfoBarPlugins:
+       def __init__(self):
+               self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
+               
+       def getPluginName(self, name):
+               return name
+               
+       def getPluginList(self):
+               list = []
+               for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
+                       list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
+               return list
+
+       def runPlugin(self, plugin):
+               plugin(session = self.session)
+
+# depends on InfoBarExtensions
+class InfoBarSleepTimer:
+       def __init__(self):
+               self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")      
+               
+       def available(self):
+               return True
+
+       def getSleepTimerName(self):
+               return _("Sleep Timer")
+
+       def showSleepTimerSetup(self):
+               self.session.open(SleepTimerEdit)
+
+# depends on InfoBarExtensions
+class InfoBarPiP:
+       def __init__(self):
+               self.session.pipshown = False
+
+               self.addExtension((self.getShowHideName, self.showPiP, self.available), "blue")
+               self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
+               self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
+       
+       def available(self):
+               return True
+       
+       def pipShown(self):
+               return self.session.pipshown
+       
+       def getShowHideName(self):
+               if self.session.pipshown:
+                       return _("Disable Picture in Picture")
+               else:
+                       return _("Activate Picture in Picture")
+               
+       def getSwapName(self):
+               return _("Swap Services")
+               
+       def getMoveName(self):
+               return _("Move Picture in Picture")
        
        
-                       elif answer[1] == "pipoff":
-                               #self.pip.hide()
-                               del self.pip
-                               self.pipshown = False
+       def showPiP(self):
+               if self.session.pipshown:
+                       del self.session.pip
+                       self.session.pipshown = False
+               else:
+                       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)
+       
+       def swapPiP(self):
+               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
+       
+       def movePiP(self):
+               self.session.open(PiPSetup, pip = self.session.pip)
 
 from RecordTimer import parseEvent
 
 
 from RecordTimer import parseEvent
 
@@ -1004,7 +1213,7 @@ class InfoBarInstantRecord:
        def __init__(self):
                self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
                        {
        def __init__(self):
                self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
                        {
-                               "instantRecord": (self.instantRecord, "Instant Record..."),
+                               "instantRecord": (self.instantRecord, _("Instant Record...")),
                        })
                self.recording = []
                self["BlinkingPoint"] = BlinkingPixmapConditional()
                        })
                self.recording = []
                self["BlinkingPoint"] = BlinkingPixmapConditional()
@@ -1015,7 +1224,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()
                
@@ -1116,146 +1325,269 @@ class InfoBarInstantRecord:
                except:
                        self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
                        return
                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=_("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=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")])
 
                if self.isInstantRecordRunning():
                        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=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")])
 
-from Screens.AudioSelection import AudioSelection
+from Tools.ISO639 import LanguageCodes
 
 class InfoBarAudioSelection:
        def __init__(self):
                self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", 
                        {
 
 class InfoBarAudioSelection:
        def __init__(self):
                self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", 
                        {
-                               "audioSelection": (self.audioSelection, "Audio Options..."),
+                               "audioSelection": (self.audioSelection, _("Audio Options...")),
                        })
 
        def audioSelection(self):
                service = self.session.nav.getCurrentService()
                        })
 
        def audioSelection(self):
                service = self.session.nav.getCurrentService()
-               audio = service.audioTracks()
-               n = audio.getNumberOfTracks()
+               audio = service and service.audioTracks()
+               self.audioTracks = audio
+               n = audio and audio.getNumberOfTracks() or 0
+               keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+               tlist = []
+               print "tlist:", tlist
                if n > 0:
                if n > 0:
-                       self.session.open(AudioSelection, audio)
+                       self.audioChannel = service.audioChannel()
+
+                       for x in range(n):
+                               i = audio.getTrackInfo(x)
+                               language = i.getLanguage()
+                               description = i.getDescription()
+       
+                               if LanguageCodes.has_key(language):
+                                       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]))
 
 
-from Screens.SubserviceSelection import SubserviceSelection
+                       selection = 2
+                       for x in tlist:
+                               if x[1] != selectedAudio:
+                                       selection += 1
+                               else:
+                                       break
+
+                       tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
+                       self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
+               else:
+                       del self.audioTracks
+
+       def audioSelected(self, audio):
+               if audio is not None:
+                       if isinstance(audio[1], str):
+                               if audio[1] == "mode":
+                                       keys = ["red", "green", "yellow"]
+                                       selection = self.audioChannel.getCurrentChannel()
+                                       tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
+                                       self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
+                       else:
+                               del self.audioChannel
+                               if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
+                                       self.audioTracks.selectTrack(audio[1])
+               else:
+                       del self.audioChannel
+               del self.audioTracks
+
+       def modeSelected(self, mode):
+               if mode is not None:
+                       self.audioChannel.selectChannel(mode[1])
+               del self.audioChannel
 
 class InfoBarSubserviceSelection:
        def __init__(self):
                self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
                        {
 
 class InfoBarSubserviceSelection:
        def __init__(self):
                self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
                        {
-                               "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
+                               "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
                        })
 
                        })
 
+               self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
+                       {
+                               "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
+                               "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
+                       }, -1)
+               self["SubserviceQuickzapAction"].setEnabled(False)
+
+               self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
+
+               self.bsel = None
+
+       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
+                                       if config.usage.show_infobar_on_zap.value:
+                                               self.doShow()
+                                       self.session.nav.playService(newservice)
+
        def subserviceSelection(self):
                service = self.session.nav.getCurrentService()
        def subserviceSelection(self):
                service = self.session.nav.getCurrentService()
-               subservices = service.subServices()
-               n = subservices.getNumberOfSubservices()
-               if n > 0:
-                       self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
+               subservices = service and service.subServices()
+               self.bouquets = self.servicelist.getBouquetList()
+               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))
+
+                       if self.bouquets and len(self.bouquets):
+                               keys = ["red", "green", "",  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+                               if config.usage.multibouquet.value:
+                                       tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
+                               else:
+                                       tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
+                       else:
+                               tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
+                               keys = ["red", "",  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+
+                       self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection + 2, keys = keys)
 
        def subserviceSelected(self, service):
 
        def subserviceSelected(self, service):
+               del self.bouquets
                if not service is None:
                if not service is None:
-                       self.session.nav.playService(service)
+                       if isinstance(service[1], str):
+                               if service[1] == "quickzap":
+                                       from Screens.SubservicesQuickzap import SubservicesQuickzap
+                                       self.session.open(SubservicesQuickzap, service[2])
+                       else:
+                               self["SubserviceQuickzapAction"].setEnabled(True)
+                               if config.usage.show_infobar_on_zap.value:
+                                       self.doShow()
+                               self.session.nav.playService(service[1])
+
+       def addSubserviceToBouquetCallback(self, service):
+               if len(service) > 1 and isinstance(service[1], eServiceReference):
+                       self.selectedSubservice = service
+                       if self.bouquets is None:
+                               cnt = 0
+                       else:
+                               cnt = len(self.bouquets)
+                       if cnt > 1: # show bouquet list
+                               self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
+                       elif cnt == 1: # add to only one existing bouquet
+                               self.addSubserviceToBouquet(self.bouquets[0][1])
+                       else: #no bouquets in root.. so assume only one favourite list is used
+                               self.addSubserviceToBouquet(self.servicelist.bouquet_root)
+
+       def bouquetSelClosed(self, **args):
+               self.bsel = None
+               del self.selectedSubservice
+
+       def addSubserviceToBouquet(self, dest):
+               serviceHandler = eServiceCenter.getInstance()
+               list = dest and serviceHandler.list(dest)
+               mutableList = dest and list and list.startEdit()
+               if mutableList:
+                       if not mutableList.addService(self.selectedSubservice[1]):
+                               mutableList.flushChanges()
+                               # do some voodoo to check if the subservice is added to the
+                               # current selected bouquet in channellist
+                               cur_root = self.servicelist.getRoot();
+                               str1 = cur_root.toString()
+                               str2 = dest.toString()
+                               pos1 = str1.find("FROM BOUQUET")
+                               pos2 = str2.find("FROM BOUQUET")
+                               if pos1 != -1 and pos2 != -1 and str1[pos1:] == str2[pos2:]:
+                                       self.servicelist.setMode()
+               if self.bsel:
+                       self.bsel.close()
+               else:
+                       del self.selectedSubservice
 
 class InfoBarAdditionalInfo:
        def __init__(self):
 
 class InfoBarAdditionalInfo:
        def __init__(self):
-               self["DolbyActive"] = Pixmap()
-               self["CryptActive"] = Pixmap()
-               self["FormatActive"] = Pixmap()
-               
-               self["ButtonRed"] = PixmapConditional(withTimer = False)
-               self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self.onLayoutFinish.append(self["ButtonRed"].update)
-               self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False)
-               self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self.onLayoutFinish.append(self["ButtonRedText"].update)
-
-               self["ButtonGreen"] = Pixmap()
-               self["ButtonGreenText"] = Label(_("Subservices"))
-
-               self["ButtonYellow"] = PixmapConditional(withTimer = False)
-               self["ButtonYellow"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self["ButtonYellowText"] = LabelConditional(text = _("Timeshifting"), withTimer = False)
-               self["ButtonYellowText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
-               self.onLayoutFinish.append(self["ButtonYellow"].update)
-               self.onLayoutFinish.append(self["ButtonYellowText"].update)
-
-               self["ButtonBlue"] = PixmapConditional(withTimer = False)
-               self["ButtonBlue"].setConnect(lambda: False)
-               self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)
-               self["ButtonBlueText"].setConnect(lambda: False)
-               self.onLayoutFinish.append(self["ButtonBlue"].update)
-               self.onLayoutFinish.append(self["ButtonBlueText"].update)
-
-               self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
+               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:
@@ -1265,12 +1597,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):
@@ -1291,6 +1622,9 @@ class InfoBarCueSheetSupport:
        CUT_TYPE_IN = 0
        CUT_TYPE_OUT = 1
        CUT_TYPE_MARK = 2
        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", 
        
        def __init__(self):
                self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions", 
@@ -1301,14 +1635,34 @@ class InfoBarCueSheetSupport:
                        }, prio=1) 
                
                self.cut_list = [ ]
                        }, prio=1) 
                
                self.cut_list = [ ]
+               self.is_closing = False
                self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
                        {
                                iPlayableService.evStart: self.__serviceStarted,
                        })
 
        def __serviceStarted(self):
                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()
                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()
 
        def __getSeekable(self):
                service = self.session.nav.getCurrentService()
@@ -1410,14 +1764,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="56,46" size="82,18" font="Regular;16" >
+                       <convert type="ClockToText">WithSeconds</convert>
+               </widget>
+               <widget source="CurrentService" render="Label" position="6,4" size="120,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):
@@ -1436,10 +1794,62 @@ class InfoBarTeletextPlugin:
                if self.teletext_plugin is not None:
                        self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
                                {
                if self.teletext_plugin is not None:
                        self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
                                {
-                                       "startTeletext": (self.startTeletext, "View teletext...")
+                                       "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())
                                })
                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.evEnd: self.__serviceStopped,
+                               iPlayableService.evUpdatedInfo: self.__updatedInfo
+                       })
+               self.cached_subtitle_checked = False
+
+       def __serviceStopped(self):
+               self.subtitle_window.hide()
+               self.__subtitles_enabled = False
+               self.cached_subtitle_checked = False
+
+       def __updatedInfo(self):
+               if not self.cached_subtitle_checked:
+                       subtitle = self.getCurrentServiceSubtitle()
+                       self.cached_subtitle_checked = True
+                       if subtitle:
+                               self.__selected_subtitle = subtitle.getCachedSubtitle()
+                       if self.__selected_subtitle:
+                               subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
+                               self.subtitle_window.show()
+                               self.__subtitles_enabled = True
+
+       def getCurrentServiceSubtitle(self):
+               service = self.session.nav.getCurrentService()
+               return service and service.subtitle()
+       
+       def setSubtitlesEnable(self, enable=True):
+               subtitle = self.getCurrentServiceSubtitle()
+               if enable and self.__selected_subtitle is not None:
+                       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.__subtitles_enabled = False
+                       self.subtitle_window.hide()
+
+       def setSelectedSubtitle(self, subtitle):
+               self.__selected_subtitle = subtitle
+
+       subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
+       selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
Clone of git://git.opendreambox.org/git/enigma2.git before dream multimedia removed all the engima2 sources