X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/48f2728ecdeabde7de0f497f8a69dbddcb047b90..aae38e1ee4006cee455ee8cf0a2b38cb6921158e:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index 2624209c..62d4e969 100644 --- 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.Clock import Clock -from Components.EventInfo import EventInfo, EventInfoProgress 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.ServiceName import ServiceName -from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry -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.TunerInfo import TunerInfo +from Components.config import config, ConfigBoolean 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.SubtitleDisplay import SubtitleDisplay +from Screens.SleepTimerEdit import SleepTimerEdit from ServiceReference import ServiceReference from Tools import Notifications @@ -42,8 +45,6 @@ import time import os import bisect -from Components.config import config, currentConfigSelectionElement - # 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: - 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 @@ -190,7 +193,8 @@ class InfoBarNumberZap: # 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) @@ -238,7 +242,7 @@ class InfoBarNumberZap: 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 @@ -247,22 +251,35 @@ class InfoBarChannelSelection: #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", { - "switchChannelUp": self.switchChannelUp, - "switchChannelDown": self.switchChannelDown, + "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")), + "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")), "zapUp": (self.zapUp, _("previous channel")), "zapDown": (self.zapDown, _("next channel")), "historyBack": (self.historyBack, _("previous channel in history")), - "historyNext": (self.historyNext, _("next channel in history")) + "historyNext": (self.historyNext, _("next channel in history")), + "openServiceList": (self.openServiceList, _("open servicelist")), }) + def showTvChannelList(self, zap=False): + self.servicelist.setModeTv() + if zap: + self.servicelist.zap() + self.session.execDialog(self.servicelist) + + def showRadioChannelList(self, zap=False): + self.servicelist.setModeRadio() + if zap: + self.servicelist.zap() + self.session.execDialog(self.servicelist) + def firstRun(self): self.onShown.remove(self.firstRun) - config.misc.initialchannelselection.value = 0 + config.misc.initialchannelselection.value = False config.misc.initialchannelselection.save() self.switchChannelDown() @@ -279,36 +296,70 @@ class InfoBarChannelSelection: def switchChannelDown(self): self.servicelist.moveDown() self.session.execDialog(self.servicelist) + + def openServiceList(self): + self.session.execDialog(self.servicelist) def zapUp(self): - if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes": - if self.servicelist.inBouquet() and self.servicelist.atBegin(): - self.servicelist.prevBouquet() - self.servicelist.moveUp() + if self.servicelist.inBouquet(): + prev = self.servicelist.getCurrentSelection() + if prev: + prev = prev.toString() + while True: + if 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.doShow() + if config.usage.show_infobar_on_zap.value: + self.doShow() def zapDown(self): - if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.inBouquet() and self.servicelist.atEnd(): - self.servicelist.nextBouquet() + if self.servicelist.inBouquet(): + prev = self.servicelist.getCurrentSelection() + if prev: + prev = prev.toString() + while True: + if 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() - 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", { - "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'!" - 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 """ @@ -482,45 +533,22 @@ class InfoBarEPG: 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): - 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): - self["ServiceName"] = ServiceName(self.session.nav) + self["CurrentService"] = CurrentService(self.session.nav) class InfoBarSeek: """handles actions like seeking, pause""" @@ -569,13 +597,13 @@ class InfoBarSeek: self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", { - "pauseService": (self.pauseService, "pause"), - "unPauseService": (self.unPauseService, "continue"), + "pauseService": (self.pauseService, _("pause")), + "unPauseService": (self.unPauseService, _("continue")), - "seekFwd": (self.seekFwd, "skip forward"), + "seekFwd": (self.seekFwd, _("skip forward")), "seekFwdDown": self.seekFwdDown, "seekFwdUp": self.seekFwdUp, - "seekBack": (self.seekBack, "skip backward"), + "seekBack": (self.seekBack, _("skip backward")), "seekBackDown": self.seekBackDown, "seekBackUp": self.seekBackUp, }, prio=-1) @@ -680,7 +708,9 @@ class InfoBarSeek: 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 @@ -789,13 +819,14 @@ class InfoBarSeek: 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: @@ -815,6 +846,11 @@ class InfoBarSeek: 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: @@ -837,7 +873,6 @@ class InfoBarTimeshiftState(InfoBarPVRState): def __init__(self): InfoBarPVRState.__init__(self, screen=TimeshiftState) - class InfoBarShowMovies: # i don't really like this class. @@ -883,8 +918,8 @@ class InfoBarTimeshift: def __init__(self): self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", { - "timeshiftStart": (self.startTimeshift, "start timeshift"), # the "yellow key" - "timeshiftStop": (self.stopTimeshift, "stop timeshift") # currently undefined :), probably 'TV' + "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key" + "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV' }, prio=1) self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"], { @@ -913,7 +948,7 @@ class InfoBarTimeshift: 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?" @@ -921,8 +956,10 @@ class InfoBarTimeshift: 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) @@ -934,11 +971,11 @@ class InfoBarTimeshift: def stopTimeshift(self): if not self.timeshift_enabled: - return + return 0 print "disable timeshift" ts = self.getTimeshift() if ts is None: - return + return 0 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO) def stopTimeshiftConfirmed(self, confirmed): @@ -1009,52 +1046,164 @@ class InfoBarTimeshift: from Screens.PiPSetup import PiPSetup class InfoBarExtensions: + EXTENSION_SINGLE = 0 + EXTENSION_LIST = 1 + def __init__(self): - self.pipshown = False + self.list = [] self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions", { - "extensions": (self.extensions, "Extensions..."), + "extensions": (self.showExtensionSelection, _("view extensions...")), }) - PIPON = 0 - PIPOFF = 1 - MOVEPIP = 2 - PIPSWAP = 3 + 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 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 extensions(self): + + def showExtensionSelection(self): + self.updateExtensions() + extensionsList = self.extensionsList[:] + keys = [] list = [] - if self.pipshown == False: - list.append((_("Activate Picture in Picture"), self.PIPON)) - elif self.pipshown == True: - list.append((_("Disable Picture in Picture"), self.PIPOFF)) - list.append((_("Move Picture in Picture"), self.MOVEPIP)) - list.append((_("Swap services"), self.PIPSWAP)) - 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: - if answer[1] == self.PIPON: - self.pip = self.session.instantiateDialog(PictureInPicture) - - newservice = self.session.nav.getCurrentlyPlayingServiceReference() - - if self.pip.playService(newservice): - self.pipshown = True - else: - self.pipshown = False - del self.pip - self.session.nav.playService(newservice) - elif answer[1] == self.PIPOFF: - del self.pip - self.pipshown = False - elif answer[1] == self.PIPSWAP: - swapservice = self.pip.getCurrentService() - self.pip.playService(self.session.nav.getCurrentlyPlayingServiceReference()) - self.session.nav.playService(swapservice) - - elif answer[1] == self.MOVEPIP: - self.session.open(PiPSetup, pip = 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") + + 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 @@ -1064,7 +1213,7 @@ class InfoBarInstantRecord: def __init__(self): self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord", { - "instantRecord": (self.instantRecord, "Instant Record..."), + "instantRecord": (self.instantRecord, _("Instant Record...")), }) self.recording = [] self["BlinkingPoint"] = BlinkingPixmapConditional() @@ -1075,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]) - + def startInstantRecording(self, limitEvent = False): serviceref = self.session.nav.getCurrentlyPlayingServiceReference() @@ -1176,7 +1325,7 @@ class InfoBarInstantRecord: except: self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR) return - + if self.isInstantRecordRunning(): self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("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: @@ -1188,26 +1337,27 @@ class InfoBarAudioSelection: def __init__(self): self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions", { - "audioSelection": (self.audioSelection, "Audio Options..."), + "audioSelection": (self.audioSelection, _("Audio Options...")), }) def audioSelection(self): service = self.session.nav.getCurrentService() - audio = service.audioTracks() + audio = service and service.audioTracks() self.audioTracks = audio - n = audio.getNumberOfTracks() + 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: -# self.audioChannel = service.audioChannel() -# config.audio.audiochannel = configElement_nonSave("config.audio.audiochannel", configSelection, self.audioChannel.getCurrentChannel(), (("left", _("Left >")), ("stereo", _("< Stereo >")), ("right", _("< Right")))) - tlist = [] + self.audioChannel = service.audioChannel() + for x in range(n): i = audio.getTrackInfo(x) language = i.getLanguage() - description = i.getDescription(); + description = i.getDescription() - if len(language) == 3: - if language in LanguageCodes: - language = LanguageCodes[language][0] + if LanguageCodes.has_key(language): + language = LanguageCodes[language][0] if len(description): description += " (" + language + ")" @@ -1219,25 +1369,38 @@ class InfoBarAudioSelection: selectedAudio = tlist[0][1] tlist.sort(lambda x,y : cmp(x[0], y[0])) -# tlist.insert(0, getConfigListEntry(_("Audio Channel"), config.audio.audiochannel)) - - selection = 0 + selection = 2 for x in tlist: if x[1] != selectedAudio: selection += 1 else: break - - self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection) + + tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist + self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys) else: del self.audioTracks def audioSelected(self, audio): if audio is not None: - self.audioTracks.selectTrack(audio[1]) + if isinstance(audio[1], str): + if audio[1] == "mode": + keys = ["red", "green", "yellow"] + selection = self.audioChannel.getCurrentChannel() + tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)] + self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys) + else: + del self.audioChannel + if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]: + self.audioTracks.selectTrack(audio[1]) + else: + del self.audioChannel del self.audioTracks -# del self.audioChannel -# del config.audio.audiochannel + + def modeSelected(self, mode): + if mode is not None: + self.audioChannel.selectChannel(mode[1]) + del self.audioChannel class InfoBarSubserviceSelection: def __init__(self): @@ -1258,8 +1421,8 @@ class InfoBarSubserviceSelection: def checkSubservicesAvail(self, ev): if ev == iPlayableService.evUpdatedEventInfo: service = self.session.nav.getCurrentService() - subservices = service.subServices() - if subservices.getNumberOfSubservices() == 0: + subservices = service and service.subServices() + if not subservices or subservices.getNumberOfSubservices() == 0: self["SubserviceQuickzapAction"].setEnabled(False) def nextSubservice(self): @@ -1270,9 +1433,9 @@ class InfoBarSubserviceSelection: def changeSubservice(self, direction): service = self.session.nav.getCurrentService() - subservices = service.subServices() - n = subservices.getNumberOfSubservices() - if n > 0: + 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): @@ -1288,15 +1451,17 @@ class InfoBarSubserviceSelection: 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() - subservices = service.subServices() + subservices = service and service.subServices() - n = subservices.getNumberOfSubservices() + n = subservices and subservices.getNumberOfSubservices() selection = 0 - if n > 0: + if n and n > 0: ref = self.session.nav.getCurrentlyPlayingServiceReference() tlist = [] for x in range(n): @@ -1305,124 +1470,85 @@ class InfoBarSubserviceSelection: selection = x tlist.append((i.getName(), i)) - self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection) + 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): if not service is None: - self["SubserviceQuickzapAction"].setEnabled(True) - self.session.nav.playService(service[1]) + 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]) class InfoBarAdditionalInfo: def __init__(self): - self["DolbyActive"] = Pixmap() - self["CryptActive"] = Pixmap() - self["FormatActive"] = Pixmap() - - self["ButtonRed"] = PixmapConditional(withTimer = False) - self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonRed"].update) - self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False) - self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonRedText"].update) - - self["ButtonGreen"] = Pixmap() - self["ButtonGreenText"] = Label(_("Subservices")) - - self["ButtonYellow"] = PixmapConditional(withTimer = False) - self["ButtonYellow"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self["ButtonYellowText"] = LabelConditional(text = _("Timeshifting"), withTimer = False) - self["ButtonYellowText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonYellow"].update) - self.onLayoutFinish.append(self["ButtonYellowText"].update) - - self["ButtonBlue"] = PixmapConditional(withTimer = False) - self["ButtonBlue"].setConnect(lambda: True) - self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False) - self["ButtonBlueText"].setConnect(lambda: True) - self.onLayoutFinish.append(self["ButtonBlue"].update) - self.onLayoutFinish.append(self["ButtonBlueText"].update) - - self.session.nav.event.append(self.gotServiceEvent) # we like to get service events - - def hideSubServiceIndication(self): - self["ButtonGreen"].hide() - self["ButtonGreenText"].hide() + self["NimA"] = Pixmap() + self["NimB"] = Pixmap() + self["NimA_Active"] = Pixmap() + self["NimB_Active"] = Pixmap() - def showSubServiceIndication(self): - self["ButtonGreen"].show() - self["ButtonGreenText"].show() + self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0) + self["TimeshiftPossible"] = self["RecordingPossible"] + self["ExtensionsAvailable"] = Boolean(fixed=1) - def checkFormat(self, service): - info = service.info() - if info is not None: - aspect = info.getInfo(iServiceInformation.sAspect) - if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]: - self["FormatActive"].show() - else: - self["FormatActive"].hide() + self.session.nav.event.append(self.gotServiceEvent) # we like to get service events + res_mgr = eDVBResourceManagerPtr() + if eDVBResourceManager.getInstance(res_mgr) == 0: + res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged) - def checkSubservices(self, service): - if service.subServices().getNumberOfSubservices() > 0: - self.showSubServiceIndication() + def tunerUseMaskChanged(self, mask): + if mask&1: + self["NimA_Active"].show() else: - self.hideSubServiceIndication() - - def checkDolby(self, service): - # FIXME - dolby = False - audio = service.audioTracks() - if audio is not None: - n = audio.getNumberOfTracks() - for x in range(n): - i = audio.getTrackInfo(x) - description = i.getDescription(); - if description.find("AC3") != -1 or description.find("DTS") != -1: - dolby = True - break - if dolby: - self["DolbyActive"].show() + self["NimA_Active"].hide() + if mask&2: + self["NimB_Active"].show() else: - self["DolbyActive"].hide() - - def checkCrypted(self, service): - info = service.info() - if info is not None: - if info.getInfo(iServiceInformation.sIsCrypted) > 0: - self["CryptActive"].show() - else: - self["CryptActive"].hide() + self["NimB_Active"].hide() + + def checkTunerState(self, service): + info = service.frontendInfo() + feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber) + if feNumber is None: + self["NimA"].hide() + self["NimB"].hide() + elif feNumber == 0: + self["NimB"].hide() + self["NimA"].show() + elif feNumber == 1: + self["NimA"].hide() + self["NimB"].show() def gotServiceEvent(self, ev): service = self.session.nav.getCurrentService() - if ev == iPlayableService.evUpdatedEventInfo: - self.checkSubservices(service) - self.checkFormat(service) - elif ev == iPlayableService.evUpdatedInfo: - self.checkCrypted(service) - self.checkDolby(service) - elif ev == iPlayableService.evEnd: - self.hideSubServiceIndication() - self["CryptActive"].hide() - self["DolbyActive"].hide() - self["FormatActive"].hide() + if ev == iPlayableService.evStart: + self.checkTunerState(service) class InfoBarNotifications: def __init__(self): self.onExecBegin.append(self.checkNotifications) Notifications.notificationAdded.append(self.checkNotificationsIfExecing) + self.onClose.append(self.__removeNotification) + + def __removeNotification(self): + Notifications.notificationAdded.remove(self.checkNotificationsIfExecing) def checkNotificationsIfExecing(self): - try: - if self.execing: - self.checkNotifications() - except: - print "******************************* A SEVERE ERROR HAPPENED... Someone who understands the code... please fix :) *******" + if self.execing: + self.checkNotifications() def checkNotifications(self): if len(Notifications.notifications): n = Notifications.notifications[0] Notifications.notifications = Notifications.notifications[1:] - print "open",n cb = n[0] if cb is not None: self.session.openWithCallback(cb, n[1], *n[2], **n[3]) @@ -1448,6 +1574,9 @@ class InfoBarCueSheetSupport: CUT_TYPE_IN = 0 CUT_TYPE_OUT = 1 CUT_TYPE_MARK = 2 + CUT_TYPE_LAST = 3 + + ENABLE_RESUME_SUPPORT = False def __init__(self): self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions", @@ -1458,14 +1587,34 @@ class InfoBarCueSheetSupport: }, prio=1) self.cut_list = [ ] + self.is_closing = False self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { iPlayableService.evStart: self.__serviceStarted, }) def __serviceStarted(self): + if self.is_closing: + return print "new service started! trying to download cuts!" self.downloadCuesheet() + + if self.ENABLE_RESUME_SUPPORT: + last = None + + for (pts, what) in self.cut_list: + if what == self.CUT_TYPE_LAST: + last = pts + + if last is not None: + self.resume_point = last + Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10) + + def playLastCB(self, answer): + if answer == True: + seekable = self.__getSeekable() + if seekable is not None: + seekable.seekTo(self.resume_point) def __getSeekable(self): service = self.session.nav.getCurrentService() @@ -1567,14 +1716,18 @@ class InfoBarCueSheetSupport: class InfoBarSummary(Screen): skin = """ - - + + WithSeconds + + + Name + """ 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): @@ -1593,10 +1746,62 @@ class InfoBarTeletextPlugin: 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()) + +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)