from Components.ServiceEventTracker import ServiceEventTracker
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 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
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
# 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.servicelist.moveUp()
self.servicelist.zap()
- self.doShow()
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
def zapDown(self):
if self.servicelist.inBouquet():
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 """
{
"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'!"
- 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 """
self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW)
self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT)
+class InfoBarRadioText:
+ """provides radio (RDS) text info display"""
+ def __init__(self):
+ self["RadioText"] = RadioText(self.session.nav)
+
class InfoBarServiceName:
def __init__(self):
self["CurrentService"] = CurrentService(self.session.nav)
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:
print "enable timeshift"
ts = self.getTimeshift()
if ts is None:
-# self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
-# print "no ts interface"
+ self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
+ print "no ts interface"
return 0;
if self.timeshift_enabled:
def __init__(self):
self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
-
def getPluginName(self, name):
return name
def runPlugin(self, plugin):
plugin(session = self.session)
-# depends on InfoBarExtensions and InfoBarSubtitleSupport
-class InfoBarSubtitles:
+# depends on InfoBarExtensions
+class InfoBarSleepTimer:
def __init__(self):
- self.addExtension((self.getDisableSubtitleName, self.disableSubtitles, self.subtitlesEnabled), "4")
- self.addExtension(extension = self.getSubtitleList, type = InfoBarExtensions.EXTENSION_LIST)
+ self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
- def getDisableSubtitleName(self):
- return _("Disable subtitles")
+ def available(self):
+ return True
- def getSubtitleList(self):
- list = []
- s = self.getCurrentServiceSubtitle()
- l = s and s.getSubtitleList() or [ ]
+ def getSleepTimerName(self):
+ return _("Sleep Timer")
- for x in l:
- list.append(((boundFunction(self.getSubtitleEntryName, x[0]), boundFunction(self.enableSubtitle, x[1]), lambda: True), None))
- return list
-
- def getSubtitleEntryName(self, name):
- return "Enable Subtitles: " + name
-
- def enableSubtitle(self, subtitles):
- print "enable subitles", subtitles
- self.selected_subtitle = subtitles
- self.subtitles_enabled = True
-
- def subtitlesEnabled(self):
- return self.subtitles_enabled
-
- def disableSubtitles(self):
- self.subtitles_enabled = False
+ 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), "1")
- self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "2")
- self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "3")
+ 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
language = i.getLanguage()
description = i.getDescription()
- if len(language) == 3:
- if language in LanguageCodes:
- language = LanguageCodes[language][0]
+ if LanguageCodes.has_key(language):
+ language = LanguageCodes[language][0]
if len(description):
description += " (" + language + ")"
self.audioChannel.selectChannel(mode[1])
del self.audioChannel
-
class InfoBarSubserviceSelection:
def __init__(self):
self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
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()
if newservice.valid():
del subservices
del service
- self.doShow()
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
self.session.nav.playService(newservice)
def subserviceSelection(self):
service = self.session.nav.getCurrentService()
subservices = service and service.subServices()
-
+ self.bouquets = self.servicelist.getBouquetList()
n = subservices and subservices.getNumberOfSubservices()
selection = 0
if n and n > 0:
selection = x
tlist.append((i.getName(), i))
- tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
-
- keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+ 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
+ selection += 3
+ else:
+ tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
+ keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+ selection += 2
- self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection + 2, keys = keys)
+ self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys)
def subserviceSelected(self, service):
+ del self.bouquets
if not service is None:
if isinstance(service[1], str):
if service[1] == "quickzap":
self.session.open(SubservicesQuickzap, service[2])
else:
self["SubserviceQuickzapAction"].setEnabled(True)
- self.doShow()
+ 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])
+ self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
+
+ def bouquetSelClosed(self, confirmed):
+ self.bsel = None
+ del self.selectedSubservice
+ if confirmed:
+ self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
+
+ 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(True)
+ else:
+ del self.selectedSubservice
+
class InfoBarAdditionalInfo:
def __init__(self):
self["NimA"] = Pixmap()
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
- iPlayableService.evStart: self.__serviceStarted,
+ iPlayableService.evEnd: self.__serviceStopped,
+ iPlayableService.evUpdatedInfo: self.__updatedInfo
})
+ self.cached_subtitle_checked = False
- def __serviceStarted(self):
- # reenable if it was enabled
- r = self.__subtitles_enabled
+ def __serviceStopped(self):
+ self.subtitle_window.hide()
self.__subtitles_enabled = False
- self.__selected_subtitle = None
- self.setSubtitlesEnable(r)
+ 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()
def setSubtitlesEnable(self, enable=True):
subtitle = self.getCurrentServiceSubtitle()
- if enable and self.__selected_subtitle:
+ 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()
else:
if subtitle:
subtitle.disableSubtitles(self.subtitle_window.instance)
-
- self.subtitle_window.hide()
self.__subtitles_enabled = False
+ self.subtitle_window.hide()
def setSelectedSubtitle(self, subtitle):
- if self.__selected_subtitle != subtitle and self.subtitles_enabled:
- # kick
- self.__selected_subtitle = subtitle
- self.__serviceStarted()
- else:
- self.__selected_subtitle = subtitle
+ self.__selected_subtitle = subtitle
subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
git.cweiske.de / enigma2.git / blobdiff