replace subservice selection screen with ChoiceBox screen

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

diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index 037fe18e4542472ef1bf9aafad242219c4e149f9..788a67b1f374fb51184e92087388aa56109c04a3 100644 (file)
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -15,6 +15,8 @@ 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.ServiceName import ServiceName
 from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean
 from Components.config import configfile, configsequencearg

+from Components.TimerList import TimerEntryComponent
+from Components.TunerInfo import TunerInfo

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


@@ -26,7 +28,8 @@ from Screens.EventView import EventViewEPGSelect, EventViewSimple
 from Screens.InputBox import InputBox
 from Screens.MessageBox import MessageBox
 from Screens.MinuteInput import MinuteInput
 from Screens.InputBox import InputBox
 from Screens.MessageBox import MessageBox
 from Screens.MinuteInput import MinuteInput

-from Screens.Standby import Standby
+from Screens.TimerSelection import TimerSelection
+from Screens.PictureInPicture import PictureInPicture

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


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

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

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


@@ -374,6 +342,8 @@ 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.dlg_stack = [ ]
+               self.bouquetSel = None

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


@@ -389,8 +359,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:


@@ -401,16 +370,37 @@ 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

                if ret:
                if ret:

-                       self.close(ret)
+                       dlgs=len(self.dlg_stack)
+                       assert 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()


@@ -420,16 +410,19 @@ 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 openSimilarList(self, eventid, refstr):
+               self.session.open(EPGSelection, refstr, None, eventid)

 
        def openEventView(self):
                self.epglist = [ ]
 
        def openEventView(self):
                self.epglist = [ ]


@@ -451,7 +444,7 @@ class InfoBarEPG:
                                if ptr:
                                        self.epglist.append(ptr)
                if len(self.epglist) > 0:
                                if ptr:
                                        self.epglist.append(ptr)
                if len(self.epglist) > 0:

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

                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)


@@ -463,49 +456,30 @@ class InfoBarEPG:
                        self.epglist[1]=tmp
                        setEvent(self.epglist[0])
 
                        self.epglist[1]=tmp
                        setEvent(self.epglist[0])
 

-from math import log
-

 class InfoBarTuner:
        """provides a snr/agc/ber display"""
        def __init__(self):
                self["snr"] = Label()
                self["agc"] = Label()
                self["ber"] = Label()
 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["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)
 
                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():
        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["snr_percent"].update()
+                       self["agc_percent"].update()
+                       self["ber_count"].update()
+                       self["snr_progress"].update()
+                       self["agc_progress"].update()
+                       self["ber_progress"].update()

 
 class InfoBarEvent:
        """provides a current/next event info display"""
 
 class InfoBarEvent:
        """provides a current/next event info display"""


@@ -612,7 +586,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()
 


@@ -668,7 +642,7 @@ class InfoBarSeek:
                self.checkSkipShowHideLock()
 
                return True
                self.checkSkipShowHideLock()
 
                return True

-               
+

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


@@ -828,7 +802,7 @@ class InfoBarPVRState:
                self.onHide.append(self.pvrStateDialog.hide)
        
        def __mayShow(self):
                self.onHide.append(self.pvrStateDialog.hide)
        
        def __mayShow(self):

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

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


@@ -908,7 +882,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"


@@ -1009,6 +983,45 @@ class InfoBarTimeshift:
                self.timeshift_enabled = False
                self.__seekableStatusChanged()
 
                self.timeshift_enabled = False
                self.__seekableStatusChanged()
 

+class InfoBarExtensions:
+       def __init__(self):
+               self.pipshown = False
+               
+               self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
+                       {
+                               "extensions": (self.extensions, "Extensions..."),
+                       })
+                       
+       def extensions(self):
+               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)
+
+       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
+       
+                       elif answer[1] == "pipoff":
+                               #self.pip.hide()
+                               self.pipservice = None
+                               del self.pip
+                               self.pipshown = False
+

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


@@ -1019,15 +1032,16 @@ class 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)
 
                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()
                
        def startInstantRecording(self, limitEvent = False):
                serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
                


@@ -1063,40 +1077,64 @@ class InfoBarInstantRecord:
                                
                data = (begin, end, name, description, eventid)
                
                                
                data = (begin, end, name, description, eventid)
                

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

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

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

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

+               print "pre:\n", self.recording
+               

                if answer is None or answer[1] == "no":
                        return
                if answer is None or answer[1] == "no":
                        return

-               
-               if self.isInstantRecordRunning():
-                       if answer[1] == "manualduration":
-                               self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)                             
+               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:
                        else:

-                               self.stopCurrentRecording()
-               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":
                        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)
                                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."
 
        def inputCallback(self, value):
                if value is not None:
                        print "stopping recording after", int(value), "minutes."

-                       if self.recording is not None:
-                               self.recording.end = time.time() + 60 * int(value)
-                               self.session.nav.RecordTimer.timeChanged(self.recording)
+                       self.recording[self.selectedEntry].end = time.time() + 60 * int(value)
+                       self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])

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


@@ -1106,11 +1144,9 @@ class InfoBarInstantRecord:
                        return
        
                if self.isInstantRecordRunning():
                        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"), "yes"), (_("enter recording duration"), "manualduration"), (_("do nothing"), "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:
                else:

-                       self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("record indefinitely"), "indefinitely"), (_("stop after current event"), "event"), (_("enter recording duration"), "manualduration"),(_("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 Screens.AudioSelection import AudioSelection
 


@@ -1128,8 +1164,6 @@ class InfoBarAudioSelection:
                if n > 0:
                        self.session.open(AudioSelection, audio)
 
                if n > 0:
                        self.session.open(AudioSelection, audio)
 

-from Screens.SubserviceSelection import SubserviceSelection
-

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


@@ -1140,13 +1174,23 @@ class InfoBarSubserviceSelection:
        def subserviceSelection(self):
                service = self.session.nav.getCurrentService()
                subservices = service.subServices()
        def subserviceSelection(self):
                service = self.session.nav.getCurrentService()
                subservices = service.subServices()

+               

                n = subservices.getNumberOfSubservices()
                n = subservices.getNumberOfSubservices()

+               selection = 0

                if n > 0:
                if n > 0:

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

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

-                       self.session.nav.playService(service)
+                       self.session.nav.playService(service[1])

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


@@ -1172,9 +1216,9 @@ class InfoBarAdditionalInfo:
                self.onLayoutFinish.append(self["ButtonYellowText"].update)
 
                self["ButtonBlue"] = PixmapConditional(withTimer = False)
                self.onLayoutFinish.append(self["ButtonYellowText"].update)
 
                self["ButtonBlue"] = PixmapConditional(withTimer = False)

-               self["ButtonBlue"].setConnect(lambda: False)
+               self["ButtonBlue"].setConnect(lambda: True)

                self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)
                self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)

-               self["ButtonBlueText"].setConnect(lambda: False)
+               self["ButtonBlueText"].setConnect(lambda: True)

                self.onLayoutFinish.append(self["ButtonBlue"].update)
                self.onLayoutFinish.append(self["ButtonBlueText"].update)
 
                self.onLayoutFinish.append(self["ButtonBlue"].update)
                self.onLayoutFinish.append(self["ButtonBlueText"].update)