X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/f7672781a51e8a21ccbd48ce53a72ad61f5d5e7e..55ee6d8a6a357c5e7926978d07494c452d5ea7ee:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index 1dc0a117..754b673a 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 -from Components.config import configfile, configsequencearg +from Components.Sources.CurrentService import CurrentService +from Components.Sources.EventInfo import EventInfo +from Components.Sources.FrontendStatus import FrontendStatus +from Components.Sources.Boolean import Boolean +from Components.Sources.Clock import Clock from Components.TimerList import TimerEntryComponent -from Components.TunerInfo import TunerInfo +from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry +from Components.config import configfile, configsequencearg from EpgSelection import EPGSelection from Plugins.Plugin import PluginDescriptor @@ -30,6 +31,7 @@ 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 ServiceReference import ServiceReference from Tools import Notifications @@ -252,20 +254,33 @@ class InfoBarChannelSelection: self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection", { - "switchChannelUp": self.switchChannelUp, - "switchChannelDown": self.switchChannelDown, + "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")), + "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")), "zapUp": (self.zapUp, _("previous channel")), "zapDown": (self.zapDown, _("next channel")), "historyBack": (self.historyBack, _("previous channel in history")), - "historyNext": (self.historyNext, _("next channel in history")) + "historyNext": (self.historyNext, _("next channel in history")), + "openServiceList": (self.openServiceList, _("open servicelist")), }) + def showTvChannelList(self, zap=False): + self.servicelist.setModeTv() + if zap: + self.servicelist.zap() + self.session.execDialog(self.servicelist) + + def showRadioChannelList(self, zap=False): + self.servicelist.setModeRadio() + if zap: + self.servicelist.zap() + self.session.execDialog(self.servicelist) + def firstRun(self): self.onShown.remove(self.firstRun) config.misc.initialchannelselection.value = 0 config.misc.initialchannelselection.save() self.switchChannelDown() - + def historyBack(self): self.servicelist.historyBack() @@ -279,18 +294,41 @@ class InfoBarChannelSelection: def switchChannelDown(self): self.servicelist.moveDown() self.session.execDialog(self.servicelist) + + def openServiceList(self): + self.session.execDialog(self.servicelist) def zapUp(self): - if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes": - if self.servicelist.inBouquet() and self.servicelist.atBegin(): - self.servicelist.prevBouquet() - self.servicelist.moveUp() + if self.servicelist.inBouquet(): + prev = self.servicelist.getCurrentSelection() + if prev: + prev = prev.toString() + while True: + if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes": + if self.servicelist.atBegin(): + self.servicelist.prevBouquet() + self.servicelist.moveUp() + cur = self.servicelist.getCurrentSelection() + if not cur or (not (cur.flags & 64)) or cur.toString() == prev: + break + else: + self.servicelist.moveUp() self.servicelist.zap() self.doShow() def zapDown(self): - if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.inBouquet() and self.servicelist.atEnd(): - self.servicelist.nextBouquet() + if self.servicelist.inBouquet(): + prev = self.servicelist.getCurrentSelection() + if prev: + prev = prev.toString() + while True: + if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.atEnd(): + self.servicelist.nextBouquet() + else: + self.servicelist.moveDown() + cur = self.servicelist.getCurrentSelection() + if not cur or (not (cur.flags & 64)) or cur.toString() == prev: + break else: self.servicelist.moveDown() self.servicelist.zap() @@ -301,7 +339,7 @@ class InfoBarMenu: def __init__(self): self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", { - "mainMenu": (self.mainMenu, "Enter main menu..."), + "mainMenu": (self.mainMenu, _("Enter main menu...")), }) def mainMenu(self): @@ -342,6 +380,15 @@ class InfoBarSimpleEventView: class InfoBarEPG: """ EPG - Opens an EPG list when the showEPGList action fires """ def __init__(self): + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged, + }) + + self.is_now_next = False + self.dlg_stack = [ ] + self.bouquetSel = None + self.eventView = None self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", { "showEventInfo": (self.openEventView, _("show EPG...")), @@ -357,8 +404,7 @@ class InfoBarEPG: self.servicelist.setCurrentSelection(service) #select the service in servicelist self.servicelist.zap() - def openBouquetEPG(self, bouquet, withCallback=True): - ptr=eEPGCache.getInstance() + def getBouquetServices(self, bouquet): services = [ ] servicelist = eServiceCenter.getInstance().list(bouquet) if not servicelist is None: @@ -369,16 +415,39 @@ class InfoBarEPG: if service.flags: #ignore non playable services continue services.append(ServiceReference(service)) + return services + + def openBouquetEPG(self, bouquet, withCallback=True): + services = self.getBouquetServices(bouquet) if len(services): self.epg_bouquet = bouquet if withCallback: - self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService) + self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB)) else: - self.session.open(EPGSelection, services, self.zapToService) + self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB) - def closed(self, ret): + def changeBouquetCB(self, direction, epg): + if self.bouquetSel: + if direction > 0: + self.bouquetSel.down() + else: + self.bouquetSel.up() + bouquet = self.bouquetSel.getCurrent() + services = self.getBouquetServices(bouquet) + if len(services): + self.epg_bouquet = bouquet + epg.setServices(services) + + def closed(self, ret=False): + closedScreen = self.dlg_stack.pop() + if self.bouquetSel and closedScreen == self.bouquetSel: + self.bouquetSel = None + elif self.eventView and closedScreen == self.eventView: + self.eventView = None if ret: - self.close(ret) + dlgs=len(self.dlg_stack) + if dlgs > 0: + self.dlg_stack[dlgs-1].close(dlgs > 1) def openMultiServiceEPG(self, withCallback=True): bouquets = self.servicelist.getBouquetList() @@ -388,38 +457,55 @@ class InfoBarEPG: cnt = len(bouquets) if cnt > 1: # show bouquet list if withCallback: - self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG) + self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True) + self.dlg_stack.append(self.bouquetSel) else: - self.session.open(BouquetSelector, bouquets, self.openBouquetEPG) + self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True) elif cnt == 1: self.openBouquetEPG(bouquets[0][1], withCallback) def openSingleServiceEPG(self): ref=self.session.nav.getCurrentlyPlayingServiceReference() - ptr=eEPGCache.getInstance() - self.session.openWithCallback(self.closed, EPGSelection, ref) + self.session.open(EPGSelection, ref) - def openEventView(self): + def openSimilarList(self, eventid, refstr): + self.session.open(EPGSelection, refstr, None, eventid) + + def getNowNext(self): self.epglist = [ ] service = self.session.nav.getCurrentService() - ref = self.session.nav.getCurrentlyPlayingServiceReference() - info = service.info() - ptr=info.getEvent(0) + info = service and service.info() + ptr = info and info.getEvent(0) if ptr: self.epglist.append(ptr) - ptr=info.getEvent(1) + ptr = info and info.getEvent(1) if ptr: self.epglist.append(ptr) + + def __evEventInfoChanged(self): + if self.is_now_next and len(self.dlg_stack) == 1: + self.getNowNext() + assert self.eventView + if len(self.epglist): + self.eventView.setEvent(self.epglist[0]) + + def openEventView(self): + ref = self.session.nav.getCurrentlyPlayingServiceReference() + self.getNowNext() if len(self.epglist) == 0: + self.is_now_next = False epg = eEPGCache.getInstance() - ptr = epg.lookupEventTime(ref, -1) + ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1) if ptr: self.epglist.append(ptr) ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1) if ptr: self.epglist.append(ptr) + else: + self.is_now_next = True if len(self.epglist) > 0: - self.session.open(EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG) + self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList) + self.dlg_stack.append(self.eventView) else: print "no epg for the service avail.. so we show multiepg instead of eventinfo" self.openMultiServiceEPG(False) @@ -434,45 +520,17 @@ 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["Now_ProgressBar"] = EventInfoProgress(self.session.nav, EventInfo.Now) + self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW) + self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT) class InfoBarServiceName: def __init__(self): - self["ServiceName"] = ServiceName(self.session.nav) + self["CurrentService"] = CurrentService(self.session.nav) class InfoBarSeek: """handles actions like seeking, pause""" @@ -521,13 +579,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) @@ -561,7 +619,7 @@ class InfoBarSeek: def getSeek(self): service = self.session.nav.getCurrentService() if service is None: - return False + return None seek = service.seek() @@ -632,6 +690,8 @@ class InfoBarSeek: def unPauseService(self): print "unpause" + if self.seekstate == self.SEEK_STATE_PLAY: + return 0 self.setSeekState(self.SEEK_STATE_PLAY); def doSeek(self, seektime): @@ -789,7 +849,6 @@ class InfoBarTimeshiftState(InfoBarPVRState): def __init__(self): InfoBarPVRState.__init__(self, screen=TimeshiftState) - class InfoBarShowMovies: # i don't really like this class. @@ -835,8 +894,8 @@ class InfoBarTimeshift: def __init__(self): self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", { - "timeshiftStart": (self.startTimeshift, "start timeshift"), # the "yellow key" - "timeshiftStop": (self.stopTimeshift, "stop timeshift") # currently undefined :), probably 'TV' + "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key" + "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV' }, prio=1) self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"], { @@ -857,15 +916,15 @@ class InfoBarTimeshift: def getTimeshift(self): service = self.session.nav.getCurrentService() - return service.timeshift() + return service and service.timeshift() def startTimeshift(self): print "enable timeshift" ts = self.getTimeshift() if ts is None: - self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR) - print "no ts interface" - return +# self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR) +# print "no ts interface" + return 0; if self.timeshift_enabled: print "hu, timeshift already enabled?" @@ -873,8 +932,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) @@ -886,11 +947,11 @@ class InfoBarTimeshift: def stopTimeshift(self): if not self.timeshift_enabled: - return + return 0 print "disable timeshift" ts = self.getTimeshift() if ts is None: - return + return 0 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO) def stopTimeshiftConfirmed(self, confirmed): @@ -958,42 +1019,72 @@ class InfoBarTimeshift: self.timeshift_enabled = False self.__seekableStatusChanged() +from Screens.PiPSetup import PiPSetup + class InfoBarExtensions: def __init__(self): - self.pipshown = False + self.session.pipshown = False self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions", { - "extensions": (self.extensions, "Extensions..."), + "extensions": (self.extensions, _("view extensions...")), }) - + + PIPON = 0 + PIPOFF = 1 + MOVEPIP = 2 + PIPSWAP = 3 + ENABLE_SUBTITLE = 4 + 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")) + if self.session.pipshown == False: + list.append((_("Activate Picture in Picture"), self.PIPON)) + elif self.session.pipshown == True: + list.append((_("Disable Picture in Picture"), self.PIPOFF)) + list.append((_("Move Picture in Picture"), self.MOVEPIP)) + list.append((_("Swap services"), self.PIPSWAP)) + + s = self.getCurrentServiceSubtitle() + l = s and s.getSubtitleList() or [ ] + + for x in l: + list.append(("Enable Subtitles: " + x[0], self.ENABLE_SUBTITLE, x[1])) + self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list) def extensionCallback(self, answer): - if answer[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() - del self.pip - self.pipshown = False + if answer is not None: + if answer[1] == self.PIPON: + self.session.pip = self.session.instantiateDialog(PictureInPicture) + newservice = self.session.nav.getCurrentlyPlayingServiceReference() + if self.session.pip.playService(newservice): + self.session.pipshown = True + self.session.pip.servicePath = self.servicelist.getCurrentServicePath() + else: + self.session.pipshown = False + del self.session.pip + self.session.nav.playService(newservice) + elif answer[1] == self.PIPOFF: + del self.session.pip + self.session.pipshown = False + elif answer[1] == self.PIPSWAP: + swapservice = self.session.nav.getCurrentlyPlayingServiceReference() + if self.session.pip.servicePath: + servicepath = self.servicelist.getCurrentServicePath() + ref=servicepath[len(servicepath)-1] + pipref=self.session.pip.getCurrentService() + self.session.pip.playService(swapservice) + self.servicelist.setCurrentServicePath(self.session.pip.servicePath) + if pipref.toString() != ref.toString(): # is a subservice ? + self.session.nav.stopService() # stop portal + self.session.nav.playService(pipref) # start subservice + self.session.pip.servicePath=servicepath + elif answer[1] == self.MOVEPIP: + self.session.open(PiPSetup, pip = self.session.pip) + elif answer[1] == self.ENABLE_SUBTITLE: + self.selected_subtitle = answer[2] + self.subtitles_enabled = True from RecordTimer import parseEvent @@ -1003,7 +1094,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() @@ -1014,7 +1105,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() @@ -1065,11 +1156,16 @@ class InfoBarInstantRecord: return False def recordQuestionCallback(self, answer): + print "pre:\n", self.recording + if answer is None or answer[1] == "no": return list = [] - for x in self.recording: - if x.dontSave and x.isRunning(): + 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": @@ -1090,6 +1186,8 @@ class InfoBarInstantRecord: self.selectedEntry = len(self.recording) self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER) self.startInstantRecording(limitEvent = limitEvent) + + print "after:\n", self.recording def changeDuration(self, entry): if entry is not None: @@ -1108,146 +1206,209 @@ class InfoBarInstantRecord: except: self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR) return - + if self.isInstantRecordRunning(): self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("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", { - "audioSelection": (self.audioSelection, "Audio Options..."), + "audioSelection": (self.audioSelection, _("Audio Options...")), }) def audioSelection(self): service = self.session.nav.getCurrentService() - audio = service.audioTracks() - n = audio.getNumberOfTracks() - if n > 0: - self.session.open(AudioSelection, audio) + audio = service and service.audioTracks() + self.audioTracks = audio + n = audio and audio.getNumberOfTracks() + keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n + tlist = [] + print "tlist:", tlist + if n and n > 0: + self.audioChannel = service.audioChannel() -from Screens.SubserviceSelection import SubserviceSelection + for x in range(n): + i = audio.getTrackInfo(x) + language = i.getLanguage() + description = i.getDescription() + + if len(language) == 3: + if language in LanguageCodes: + language = LanguageCodes[language][0] + + if len(description): + description += " (" + language + ")" + else: + description = language + + tlist.append((description, x)) + + selectedAudio = tlist[0][1] + tlist.sort(lambda x,y : cmp(x[0], y[0])) + + selection = 2 + for x in tlist: + if x[1] != selectedAudio: + selection += 1 + else: + break + + tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist + self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys) + else: + del self.audioTracks + + def audioSelected(self, audio): + if audio is not None: + if isinstance(audio[1], str): + if audio[1] == "mode": + keys = ["red", "green", "yellow"] + selection = self.audioChannel.getCurrentChannel() + tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)] + self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys) + else: + del self.audioChannel + if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]: + self.audioTracks.selectTrack(audio[1]) + else: + del self.audioChannel + del self.audioTracks + + def modeSelected(self, mode): + if mode is not None: + self.audioChannel.selectChannel(mode[1]) + del self.audioChannel class InfoBarSubserviceSelection: def __init__(self): self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions", { - "subserviceSelection": (self.subserviceSelection, "Subservice list..."), + "subserviceSelection": (self.subserviceSelection, _("Subservice list...")), }) + self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions", + { + "nextSubservice": (self.nextSubservice, _("Switch to next subservice")), + "prevSubservice": (self.prevSubservice, _("Switch to previous subservice")) + }, -1) + self["SubserviceQuickzapAction"].setEnabled(False) + + self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events + + def checkSubservicesAvail(self, ev): + if ev == iPlayableService.evUpdatedEventInfo: + service = self.session.nav.getCurrentService() + subservices = service and service.subServices() + if not subservices or subservices.getNumberOfSubservices() == 0: + self["SubserviceQuickzapAction"].setEnabled(False) + + def nextSubservice(self): + self.changeSubservice(+1) + + def prevSubservice(self): + self.changeSubservice(-1) + + def changeSubservice(self, direction): + service = self.session.nav.getCurrentService() + subservices = service and service.subServices() + n = subservices and subservices.getNumberOfSubservices() + if n and n > 0: + selection = -1 + ref = self.session.nav.getCurrentlyPlayingServiceReference() + for x in range(n): + if subservices.getSubservice(x).toString() == ref.toString(): + selection = x + if selection != -1: + selection += direction + if selection >= n: + selection=0 + elif selection < 0: + selection=n-1 + newservice = subservices.getSubservice(selection) + if newservice.valid(): + del subservices + del service + self.session.nav.playService(newservice) + def subserviceSelection(self): service = self.session.nav.getCurrentService() - subservices = service.subServices() - n = subservices.getNumberOfSubservices() - if n > 0: - self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices) + subservices = service and service.subServices() + + n = subservices and subservices.getNumberOfSubservices() + selection = 0 + if n and n > 0: + ref = self.session.nav.getCurrentlyPlayingServiceReference() + tlist = [] + for x in range(n): + i = subservices.getSubservice(x) + if i.toString() == ref.toString(): + selection = x + tlist.append((i.getName(), i)) + + self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection) def subserviceSelected(self, service): if not service is None: - self.session.nav.playService(service) + self["SubserviceQuickzapAction"].setEnabled(True) + self.session.nav.playService(service[1]) class InfoBarAdditionalInfo: def __init__(self): - self["DolbyActive"] = Pixmap() - self["CryptActive"] = Pixmap() - self["FormatActive"] = Pixmap() - - self["ButtonRed"] = PixmapConditional(withTimer = False) - self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonRed"].update) - self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False) - self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonRedText"].update) - - self["ButtonGreen"] = Pixmap() - self["ButtonGreenText"] = Label(_("Subservices")) - - self["ButtonYellow"] = PixmapConditional(withTimer = False) - self["ButtonYellow"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self["ButtonYellowText"] = LabelConditional(text = _("Timeshifting"), withTimer = False) - self["ButtonYellowText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonYellow"].update) - self.onLayoutFinish.append(self["ButtonYellowText"].update) - - self["ButtonBlue"] = PixmapConditional(withTimer = False) - self["ButtonBlue"].setConnect(lambda: 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): if self.execing: @@ -1257,12 +1418,11 @@ class InfoBarNotifications: if len(Notifications.notifications): n = Notifications.notifications[0] Notifications.notifications = Notifications.notifications[1:] - print "open",n cb = n[0] if cb is not None: - self.session.openWithCallback(cb, *n[1:]) + self.session.openWithCallback(cb, n[1], *n[2], **n[3]) else: - self.session.open(*n[1:]) + self.session.open(n[1], *n[2], **n[3]) class InfoBarServiceNotifications: def __init__(self): @@ -1283,6 +1443,9 @@ class InfoBarCueSheetSupport: CUT_TYPE_IN = 0 CUT_TYPE_OUT = 1 CUT_TYPE_MARK = 2 + CUT_TYPE_LAST = 3 + + ENABLE_RESUME_SUPPORT = False def __init__(self): self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions", @@ -1293,14 +1456,34 @@ class InfoBarCueSheetSupport: }, prio=1) self.cut_list = [ ] + self.is_closing = False self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { iPlayableService.evStart: self.__serviceStarted, }) def __serviceStarted(self): + if self.is_closing: + return print "new service started! trying to download cuts!" self.downloadCuesheet() + + if self.ENABLE_RESUME_SUPPORT: + last = None + + for (pts, what) in self.cut_list: + if what == self.CUT_TYPE_LAST: + last = pts + + if last is not None: + self.resume_point = last + Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10) + + def playLastCB(self, answer): + if answer == True: + seekable = self.__getSeekable() + if seekable is not None: + seekable.seekTo(self.resume_point) def __getSeekable(self): service = self.session.nav.getCurrentService() @@ -1402,14 +1585,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): @@ -1428,10 +1615,57 @@ 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.evStart: self.__serviceStarted, + }) + + def __serviceStarted(self): + # reenable if it was enabled + r = self.__subtitles_enabled + self.__subtitles_enabled = False + self.__selected_subtitle = None + self.setSubtitlesEnable(r) + + def getCurrentServiceSubtitle(self): + service = self.session.nav.getCurrentService() + return service and service.subtitle() + + def setSubtitlesEnable(self, enable=True): + subtitle = self.getCurrentServiceSubtitle() + if enable and self.__selected_subtitle: + if subtitle and not self.__subtitles_enabled: + subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle) + self.subtitle_window.show() + self.__subtitles_enabled = True + else: + if subtitle: + subtitle.disableSubtitles(self.subtitle_window.instance) + + self.subtitle_window.hide() + self.__subtitles_enabled = False + + def setSelectedSubtitle(self, subtitle): + if self.__selected_subtitle != subtitle and self.subtitles_enabled: + # kick + self.__selected_subtitle = subtitle + self.__serviceStarted() + else: + self.__selected_subtitle = subtitle + + subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable) + selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)