X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/de0875117ca72715893feb9183a498c2942d7da5..2b557e7ef4b0518736c5162a501cd9bc743930b3:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index d6a10012..ed8149e4 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -1,28 +1,39 @@ -from Screen import Screen +from ChannelSelection import ChannelSelection, BouquetSelector + from Components.ActionMap import ActionMap, HelpableActionMap from Components.ActionMap import NumberActionMap +from Components.BlinkingPixmap import BlinkingPixmapConditional +from Components.Harddisk import harddiskmanager +from Components.Input import Input from Components.Label import * -from Components.ProgressBar import * -from Components.config import configfile, configsequencearg -from Components.config import config, configElement, ConfigSubsection, configSequence -from ChannelSelection import ChannelSelection, BouquetSelector - from Components.Pixmap import Pixmap, PixmapConditional -from Components.BlinkingPixmap import BlinkingPixmapConditional -from Components.ServiceName import ServiceName -from Components.EventInfo import EventInfo, EventInfoProgress +from Components.PluginComponent import plugins +from Components.ProgressBar import * +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 Components.TimerList import TimerEntryComponent +from Components.config import config, ConfigBoolean -from ServiceReference import ServiceReference from EpgSelection import EPGSelection +from Plugins.Plugin import PluginDescriptor -from Screens.MessageBox import MessageBox +from Screen import Screen +from Screens.ChoiceBox import ChoiceBox from Screens.Dish import Dish -from Screens.Standby import Standby from Screens.EventView import EventViewEPGSelect, EventViewSimple +from Screens.InputBox import InputBox +from Screens.MessageBox import MessageBox from Screens.MinuteInput import MinuteInput -from Components.Harddisk import harddiskmanager - -from Components.ServiceEventTracker import ServiceEventTracker +from Screens.TimerSelection import TimerSelection +from Screens.PictureInPicture import PictureInPicture +from Screens.SubtitleDisplay import SubtitleDisplay +from Screens.SleepTimerEdit import SleepTimerEdit +from ServiceReference import ServiceReference from Tools import Notifications from Tools.Directories import * @@ -34,8 +45,6 @@ import time import os import bisect -from Components.config import config, currentConfigSelectionElement - # hack alert! from Menu import MainMenu, mdom @@ -77,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 @@ -161,41 +172,6 @@ class NumberZap(Screen): 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): @@ -217,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) @@ -244,7 +221,7 @@ class InfoBarNumberZap: bouquet = self.servicelist.bouquet_root service = None serviceHandler = eServiceCenter.getInstance() - if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK + if not config.usage.multibouquet.value: service, number = self.searchNumberHelper(serviceHandler, number, bouquet) else: bouquetlist = serviceHandler.list(bouquet) @@ -253,7 +230,7 @@ class InfoBarNumberZap: bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext()) if not bouquet.valid(): #check end of list break - if (bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory: + if not (bouquet.flags & eServiceReference.isDirectory): continue service, number = self.searchNumberHelper(serviceHandler, number, bouquet) if not service is None: @@ -265,23 +242,47 @@ class InfoBarNumberZap: self.servicelist.setCurrentSelection(service) #select the service in servicelist self.servicelist.zap() +config.misc.initialchannelselection = ConfigBoolean(default = True) + class InfoBarChannelSelection: """ ChannelSelection - handles the channelSelection dialog and the initial channelChange actions which open the channelSelection dialog """ def __init__(self): #instantiate forever self.servicelist = self.session.instantiateDialog(ChannelSelection) + + 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 = False + config.misc.initialchannelselection.save() + self.switchChannelDown() + def historyBack(self): self.servicelist.historyBack() @@ -295,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 """ @@ -358,6 +393,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...")), @@ -373,8 +417,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: @@ -382,19 +425,42 @@ class InfoBarEPG: service = servicelist.getNext() if not service.valid(): #check if end of list break - if service.flags: #ignore non playable services + if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #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() @@ -404,38 +470,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) @@ -447,67 +530,25 @@ class InfoBarEPG: 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() - 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.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(): - 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["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"] = 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) +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""" @@ -540,15 +581,29 @@ class InfoBarSeek: iPlayableService.evEOF: self.__evEOF, iPlayableService.evSOF: self.__evSOF, }) - self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions", + + class InfoBarSeekActionMap(HelpableActionMap): + def __init__(self, screen, *args, **kwargs): + HelpableActionMap.__init__(self, screen, *args, **kwargs) + self.screen = screen + + def action(self, contexts, action): + if action[:5] == "seek:": + time = int(action[5:]) + self.screen.seekRelative(time * 90000) + return 1 + else: + return HelpableActionMap.action(self, contexts, action) + + 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) @@ -582,7 +637,7 @@ class InfoBarSeek: def getSeek(self): service = self.session.nav.getCurrentService() if service is None: - return False + return None seek = service.seek() @@ -638,7 +693,7 @@ class InfoBarSeek: self.checkSkipShowHideLock() return True - + def pauseService(self): if self.seekstate == self.SEEK_STATE_PAUSE: print "pause, but in fact unpause" @@ -653,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 @@ -730,6 +787,11 @@ class InfoBarSeek: self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE } self.setSeekState(lookup[self.seekstate]) + + if self.seekstate == self.SEEK_STATE_PAUSE: + seekable = self.getSeek() + if seekable is not None: + seekable.seekRelative(-1, 3) def fwdTimerFire(self): print "Display seek fwd" @@ -757,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: @@ -781,19 +844,24 @@ class InfoBarSeek: def seekRelative(self, diff): seekable = self.getSeek() if seekable is not None: - seekable.seekRelative(0, diff) + seekable.seekRelative(1, diff) + + def seekAbsolute(self, abs): + seekable = self.getSeek() + if seekable is not None: + seekable.seekTo(abs) -from Screens.PVRState import PVRState +from Screens.PVRState import PVRState, TimeshiftState class InfoBarPVRState: - def __init__(self): + def __init__(self, screen=PVRState): self.onPlayStateChanged.append(self.__playStateChanged) - self.pvrStateDialog = self.session.instantiateDialog(PVRState) + self.pvrStateDialog = self.session.instantiateDialog(screen) self.onShow.append(self.__mayShow) 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): @@ -801,6 +869,10 @@ class InfoBarPVRState: self.pvrStateDialog["state"].setText(playstateString) self.__mayShow() +class InfoBarTimeshiftState(InfoBarPVRState): + def __init__(self): + InfoBarPVRState.__init__(self, screen=TimeshiftState) + class InfoBarShowMovies: # i don't really like this class. @@ -846,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"], { @@ -862,12 +934,13 @@ class InfoBarTimeshift: self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { + iPlayableService.evStart: self.__serviceStarted, iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged }) def getTimeshift(self): service = self.session.nav.getCurrentService() - return service.timeshift() + return service and service.timeshift() def startTimeshift(self): print "enable timeshift" @@ -875,14 +948,18 @@ 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?" else: if not ts.startTimeshift(): + import time self.timeshift_enabled = 1 - + + # we remove the "relative time" for now. + #self.pvrStateDialog["timeshift"].setRelative(time.time()) + # PAUSE. self.setSeekState(self.SEEK_STATE_PAUSE) @@ -894,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): @@ -962,6 +1039,172 @@ class InfoBarTimeshift: print "timeshift activate:", enabled self["TimeshiftActivateActions"].setEnabled(enabled) + def __serviceStarted(self): + self.timeshift_enabled = False + self.__seekableStatusChanged() + +from Screens.PiPSetup import PiPSetup + +class InfoBarExtensions: + EXTENSION_SINGLE = 0 + EXTENSION_LIST = 1 + + def __init__(self): + self.list = [] + + self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions", + { + "extensions": (self.showExtensionSelection, _("view extensions...")), + }) + + def addExtension(self, extension, key = None, type = EXTENSION_SINGLE): + self.list.append((type, extension, key)) + + def updateExtension(self, extension, key = None): + self.extensionsList.append(extension) + if key is not None: + if self.extensionKeys.has_key(key): + key = None + + if key is None: + for x in self.availableKeys: + if not self.extensionKeys.has_key(x): + key = x + break + + if key is not None: + self.extensionKeys[key] = len(self.extensionsList) - 1 + + def updateExtensions(self): + self.extensionsList = [] + self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ] + self.extensionKeys = {} + for x in self.list: + if x[0] == self.EXTENSION_SINGLE: + self.updateExtension(x[1], x[2]) + else: + for y in x[1](): + self.updateExtension(y[0], y[1]) + + + def showExtensionSelection(self): + self.updateExtensions() + extensionsList = self.extensionsList[:] + keys = [] + list = [] + 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: + 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 class InfoBarInstantRecord: @@ -970,18 +1213,19 @@ class InfoBarInstantRecord: def __init__(self): self["InstantRecordActions"] = HelpableActionMap(self, "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) - 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): + def startInstantRecording(self, limitEvent = False): serviceref = self.session.nav.getCurrentlyPlayingServiceReference() # try to get event info @@ -997,34 +1241,83 @@ class InfoBarInstantRecord: except: pass + begin = time.time() + end = time.time() + 3600 * 10 + name = "instant record" + description = "" + eventid = None + if event is not None: - data = parseEvent(event) - begin = time.time() - end = begin + 3600 * 10 - data = (begin, end, data[2], data[3], data[4]) + curEvent = parseEvent(event) + name = curEvent[2] + description = curEvent[3] + eventid = curEvent[4] + if limitEvent: + end = curEvent[1] else: - data = (time.time(), time.time() + 3600 * 10, "instant record", "", None) + if limitEvent: + self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO) + + data = (begin, end, name, description, eventid) - # fix me, description. - 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): - 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): - if answer == False: - return + print "pre:\n", self.recording - if self.isInstantRecordRunning(): - self.stopCurrentRecording() - else: - self.startInstantRecording() + if answer is None or answer[1] == "no": + return + 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: + 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": + 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: + 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." + self.recording[self.selectedEntry].end = time.time() + 60 * int(value) + self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) def instantRecord(self): try: @@ -1032,146 +1325,258 @@ 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, 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: - 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 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() + audio = service and service.audioTracks() + self.audioTracks = audio + n = audio and audio.getNumberOfTracks() or 0 + keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n + tlist = [] + print "tlist:", tlist if n > 0: - self.session.open(AudioSelection, audio) + 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 LanguageCodes.has_key(language): + language = LanguageCodes[language][0] + + if len(description): + description += " (" + language + ")" + else: + description = language + + tlist.append((description, x)) + + selectedAudio = tlist[0][1] + tlist.sort(lambda x,y : cmp(x[0], y[0])) + + 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 + + self.bsel = None + + def checkSubservicesAvail(self, ev): + if ev == iPlayableService.evUpdatedEventInfo: + service = self.session.nav.getCurrentService() + subservices = service and service.subServices() + if not subservices or subservices.getNumberOfSubservices() == 0: + self["SubserviceQuickzapAction"].setEnabled(False) + + def nextSubservice(self): + self.changeSubservice(+1) + + def prevSubservice(self): + self.changeSubservice(-1) + + def changeSubservice(self, direction): + service = self.session.nav.getCurrentService() + subservices = service and service.subServices() + n = subservices and subservices.getNumberOfSubservices() + if n and n > 0: + selection = -1 + ref = self.session.nav.getCurrentlyPlayingServiceReference() + for x in range(n): + if subservices.getSubservice(x).toString() == ref.toString(): + selection = x + if selection != -1: + selection += direction + if selection >= n: + selection=0 + elif selection < 0: + selection=n-1 + newservice = subservices.getSubservice(selection) + if newservice.valid(): + del subservices + del service + if config.usage.show_infobar_on_zap.value: + self.doShow() + self.session.nav.playService(newservice) + def subserviceSelection(self): service = self.session.nav.getCurrentService() - subservices = service.subServices() - n = subservices.getNumberOfSubservices() - if n > 0: - self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices) + subservices = service and service.subServices() + self.bouquets = self.servicelist.getBouquetList() + n = subservices and subservices.getNumberOfSubservices() + selection = 0 + if n and n > 0: + ref = self.session.nav.getCurrentlyPlayingServiceReference() + tlist = [] + for x in range(n): + i = subservices.getSubservice(x) + if i.toString() == ref.toString(): + selection = x + tlist.append((i.getName(), i)) + + if self.bouquets and len(self.bouquets): + keys = ["red", "green", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n + if config.usage.multibouquet.value: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist + else: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist + 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, keys = keys) def subserviceSelected(self, service): + del self.bouquets if not service is None: - self.session.nav.playService(service) + if isinstance(service[1], str): + if service[1] == "quickzap": + from Screens.SubservicesQuickzap import SubservicesQuickzap + self.session.open(SubservicesQuickzap, service[2]) + else: + self["SubserviceQuickzapAction"].setEnabled(True) + if config.usage.show_infobar_on_zap.value: + self.doShow() + self.session.nav.playService(service[1]) + + def addSubserviceToBouquetCallback(self, service): + if len(service) > 1 and isinstance(service[1], eServiceReference): + self.selectedSubservice = service + if self.bouquets is None: + cnt = 0 + else: + cnt = len(self.bouquets) + if cnt > 1: # show bouquet list + self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet) + elif cnt == 1: # add to only one existing bouquet + self.addSubserviceToBouquet(self.bouquets[0][1]) + 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): + self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1]) + if self.bsel: + self.bsel.close(True) + else: + del self.selectedSubservice class InfoBarAdditionalInfo: def __init__(self): - self["DolbyActive"] = Pixmap() - self["CryptActive"] = Pixmap() - self["FormatActive"] = Pixmap() - - self["ButtonRed"] = PixmapConditional(withTimer = False) - self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonRed"].update) - self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False) - self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonRedText"].update) - - self["ButtonGreen"] = Pixmap() - self["ButtonGreenText"] = Label(_("Subservices")) - - self["ButtonYellow"] = PixmapConditional(withTimer = False) - self["ButtonYellow"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self["ButtonYellowText"] = LabelConditional(text = _("Timeshifting"), withTimer = False) - self["ButtonYellowText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onLayoutFinish.append(self["ButtonYellow"].update) - self.onLayoutFinish.append(self["ButtonYellowText"].update) - - self["ButtonBlue"] = PixmapConditional(withTimer = False) - self["ButtonBlue"].setConnect(lambda: False) - self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False) - self["ButtonBlueText"].setConnect(lambda: False) - self.onLayoutFinish.append(self["ButtonBlue"].update) - self.onLayoutFinish.append(self["ButtonBlueText"].update) - - self.session.nav.event.append(self.gotServiceEvent) # we like to get service events + self["NimA"] = Pixmap() + self["NimB"] = Pixmap() + self["NimA_Active"] = Pixmap() + self["NimB_Active"] = Pixmap() - def hideSubServiceIndication(self): - self["ButtonGreen"].hide() - self["ButtonGreenText"].hide() + self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0) + self["TimeshiftPossible"] = self["RecordingPossible"] + self["ExtensionsAvailable"] = Boolean(fixed=1) - def showSubServiceIndication(self): - self["ButtonGreen"].show() - self["ButtonGreenText"].show() - - def checkFormat(self, service): - info = service.info() - if info is not None: - aspect = info.getInfo(iServiceInformation.sAspect) - if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]: - self["FormatActive"].show() - else: - self["FormatActive"].hide() + self.session.nav.event.append(self.gotServiceEvent) # we like to get service events + res_mgr = eDVBResourceManagerPtr() + if eDVBResourceManager.getInstance(res_mgr) == 0: + res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged) - def checkSubservices(self, service): - if service.subServices().getNumberOfSubservices() > 0: - self.showSubServiceIndication() + def tunerUseMaskChanged(self, mask): + if mask&1: + self["NimA_Active"].show() else: - 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: @@ -1181,12 +1586,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): @@ -1207,6 +1611,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", @@ -1217,14 +1624,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() @@ -1274,7 +1701,7 @@ class InfoBarCueSheetSupport: nearest = cp return nearest - def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000): + def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False): current_pos = self.cueGetCurrentPosition() if current_pos is None: print "not seekable" @@ -1283,10 +1710,15 @@ class InfoBarCueSheetSupport: nearest_cutpoint = self.getNearestCutPoint(current_pos) if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance: + if onlyreturn: + return nearest_cutpoint if not onlyadd: self.removeMark(nearest_cutpoint) - elif not onlyremove: + elif not onlyremove and not onlyreturn: self.addMark((current_pos, self.CUT_TYPE_MARK)) + + if onlyreturn: + return None def addMark(self, point): bisect.insort(self.cut_list, point) @@ -1317,3 +1749,96 @@ class InfoBarCueSheetSupport: print "upload failed, no cuesheet interface" return self.cut_list = cue.getCutList() + +class InfoBarSummary(Screen): + skin = """ + + + WithSeconds + + + Name + + """ + + def __init__(self, session, parent): + Screen.__init__(self, session) + self["CurrentService"] = CurrentService(self.session.nav) + self["CurrentTime"] = Clock() + +class InfoBarSummarySupport: + def __init__(self): + pass + + def createSummary(self): + return InfoBarSummary + +class InfoBarTeletextPlugin: + def __init__(self): + self.teletext_plugin = None + + for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT): + self.teletext_plugin = p + + if self.teletext_plugin is not None: + self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions", + { + "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)