X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/0a4de6bf0b9cc1072a98f68f737f153bba429978..8bfa53742165d0893dbd623d217bc855390a5663:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index c3b1a086..978e7319 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -1,37 +1,49 @@ -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 ServiceReference import ServiceReference +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.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, ConfigClock 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 EventView +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 Screens.TimerSelection import TimerSelection +from Screens.PictureInPicture import PictureInPicture +from Screens.SubtitleDisplay import SubtitleDisplay +from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive +from Screens.SleepTimerEdit import SleepTimerEdit +from Screens.TimeDateInput import TimeDateInput +from ServiceReference import ServiceReference from Tools import Notifications -from Tools.Directories import * - -#from enigma import eTimer, eDVBVolumecontrol, quitMainloop -from enigma import * +from Tools.Directories import SCOPE_HDD, resolveFilename -import time -import os +from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \ + iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache -from Components.config import config, currentConfigSelectionElement +from time import time, localtime, strftime +from os import stat as os_stat +from bisect import insort # hack alert! from Menu import MainMenu, mdom @@ -39,7 +51,7 @@ from Menu import MainMenu, mdom class InfoBarDish: def __init__(self): self.dishDialog = self.session.instantiateDialog(Dish) - self.onShown.append(self.dishDialog.instance.hide) + self.onLayoutFinish.append(self.dishDialog.show) class InfoBarShowHide: """ InfoBar show/hide control, accepts toggleShow and hide actions, might start @@ -48,57 +60,81 @@ class InfoBarShowHide: STATE_HIDING = 1 STATE_SHOWING = 2 STATE_SHOWN = 3 - + def __init__(self): self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] , { "toggleShow": self.toggleShow, "hide": self.hide, + }, 1) # lower prio to make it possible to override ok and cancel.. + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evStart: self.serviceStarted, }) - self.state = self.STATE_SHOWN - - self.onExecBegin.append(self.show) - self.onClose.append(self.delHideTimer) - + self.__state = self.STATE_SHOWN + self.__locked = 0 + self.hideTimer = eTimer() self.hideTimer.timeout.get().append(self.doTimerHide) self.hideTimer.start(5000, True) - def delHideTimer(self): - del self.hideTimer + self.onShow.append(self.__onShow) + self.onHide.append(self.__onHide) - def hide(self): - self.instance.hide() - - def show(self): - self.state = self.STATE_SHOWN - self.hideTimer.start(5000, True) + def serviceStarted(self): + if self.execing: + if config.usage.show_infobar_on_zap.value: + self.doShow() + + def __onShow(self): + self.__state = self.STATE_SHOWN + self.startHideTimer() + + def startHideTimer(self): + if self.__state == self.STATE_SHOWN and not self.__locked: + idx = config.usage.infobar_timeout.index + if idx: + self.hideTimer.start(idx*1000, True) + + def __onHide(self): + self.__state = self.STATE_HIDDEN + + def doShow(self): + self.show() + self.startHideTimer() def doTimerHide(self): self.hideTimer.stop() - if self.state == self.STATE_SHOWN: - self.instance.hide() - self.state = self.STATE_HIDDEN + if self.__state == self.STATE_SHOWN: + self.hide() def toggleShow(self): - if self.state == self.STATE_SHOWN: - self.instance.hide() - #pls check animation support, sorry -# self.startHide() + if self.__state == self.STATE_SHOWN: + self.hide() self.hideTimer.stop() - self.state = self.STATE_HIDDEN - elif self.state == self.STATE_HIDDEN: - self.instance.show() + elif self.__state == self.STATE_HIDDEN: + self.show() + + def lockShow(self): + self.__locked = self.__locked + 1 + if self.execing: self.show() - - def startShow(self): - self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100) - self.state = self.STATE_SHOWN - - def startHide(self): - self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100) - self.state = self.STATE_HIDDEN + self.hideTimer.stop() + + def unlockShow(self): + self.__locked = self.__locked - 1 + if self.execing: + self.startHideTimer() + +# def startShow(self): +# self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100) +# self.__state = self.STATE_SHOWN +# +# def startHide(self): +# self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100) +# self.__state = self.STATE_HIDDEN class NumberZap(Screen): def quit(self): @@ -144,45 +180,10 @@ 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): - self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"], + self["NumberActions"] = NumberActionMap( [ "NumberActions"], { "1": self.keyNumberGlobal, "2": self.keyNumberGlobal, @@ -199,9 +200,7 @@ class InfoBarNumberZap: def keyNumberGlobal(self, number): # print "You pressed number " + str(number) if number == 0: - self.session.nav.zapLast() - self.instance.show() - self.show() + self.servicelist.recallPrevService() else: self.session.openWithCallback(self.numberEntered, NumberZap, number) @@ -217,9 +216,9 @@ class InfoBarNumberZap: serviceIterator = servicelist.getNext() if not serviceIterator.valid(): #check end of list break - if serviceIterator.flags: #assume normal dvb service have no flags set - continue - num -= 1; + playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory)) + if playable: + num -= 1; if not num: #found service with searched number ? return serviceIterator, 0 return None, num @@ -228,23 +227,27 @@ 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) if not bouquetlist is None: while number: - bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext()) + bouquet = bouquetlist.getNext() if not bouquet.valid(): #check end of list break - if ((bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory): - continue - service, number = self.searchNumberHelper(serviceHandler, number, bouquet) + if bouquet.flags & eServiceReference.isDirectory: + service, number = self.searchNumberHelper(serviceHandler, number, bouquet) if not service is None: - self.session.nav.playService(service) #play service if self.servicelist.getRoot() != bouquet: #already in correct bouquet? - self.servicelist.setRoot(bouquet) + self.servicelist.clearPath() + if self.servicelist.bouquet_root != bouquet: + self.servicelist.enterPath(self.servicelist.bouquet_root) + self.servicelist.enterPath(bouquet) 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 @@ -253,110 +256,177 @@ class InfoBarChannelSelection: #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, - "zapUp": (self.zapUp, _("next channel")), - "zapDown": (self.zapDown, _("previous channel")), + "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")), + "openServiceList": (self.openServiceList, _("open servicelist")), }) - - def switchChannelUp(self): + + 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() + + def historyNext(self): + self.servicelist.historyNext() + + def switchChannelUp(self): self.servicelist.moveUp() self.session.execDialog(self.servicelist) - def switchChannelDown(self): + def switchChannelDown(self): self.servicelist.moveDown() self.session.execDialog(self.servicelist) - def zapUp(self): - self.servicelist.moveUp() + def openServiceList(self): + self.session.execDialog(self.servicelist) + + def zapUp(self): + 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.instance.show() - self.show() - def zapDown(self): - self.servicelist.moveDown() + def zapDown(self): + 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.instance.show() - self.show() - + 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 """ + def __init__(self): + self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", + { + "showEventInfo": (self.openEventView, _("show event details")), + }) + + def openEventView(self): + self.epglist = [ ] + service = self.session.nav.getCurrentService() + ref = self.session.nav.getCurrentlyPlayingServiceReference() + info = service.info() + ptr=info.getEvent(0) + if ptr: + self.epglist.append(ptr) + ptr=info.getEvent(1) + if ptr: + self.epglist.append(ptr) + if len(self.epglist) > 0: + self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback) + + def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying + if len(self.epglist) > 1: + tmp = self.epglist[0] + self.epglist[0]=self.epglist[1] + self.epglist[1]=tmp + setEvent(self.epglist[0]) 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", { - "showEPGList": (self.showEPG, _("show EPG...")), + "showEventInfo": (self.openEventView, _("show EPG...")), + "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible, }) - def showEPG(self): - if currentConfigSelectionElement(config.usage.epgtoggle) == "yes": - self.openSingleServiceEPG() + def showEventInfoWhenNotVisible(self): + if self.shown: + self.openEventView() else: - self.showEPGList() + self.toggleShow() + return 1 - def showEPGList(self): - bouquets = self.servicelist.getBouquetList() - if bouquets is None: - cnt = 0 - else: - cnt = len(bouquets) - if cnt > 1: # show bouquet list - self.session.open(BouquetSelector, bouquets, self.openBouquetEPG) - elif cnt == 1: # add to only one existing bouquet - self.openBouquetEPG(bouquets[0][1]) - else: #no bouquets so we open single epg - self.openSingleEPGSelector(self.session.nav.getCurrentlyPlayingServiceReference()) - - def bouquetEPGCallback(self, info): - if info: - self.openSingleServiceEPG() - - def singleEPGCallback(self, info): - if info: - self.showEPGList() - - def openEventView(self): - try: - self.epglist = [ ] - service = self.session.nav.getCurrentService() - info = service.info() - ptr=info.getEvent(0) - if ptr: - self.epglist.append(ptr) - ptr=info.getEvent(1) - if ptr: - self.epglist.append(ptr) - if len(self.epglist) > 0: - self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback) - except: - pass - - def openSingleServiceEPG(self): - ref=self.session.nav.getCurrentlyPlayingServiceReference() - ptr=eEPGCache.getInstance() - if ptr.startTimeQuery(ref) != -1: - self.session.openWithCallback(self.singleEPGCallback, EPGSelection, ref) - else: # try to show now/next - print 'no epg for service', ref.toString() - - - def openBouquetEPG(self, bouquet): - ptr=eEPGCache.getInstance() + def zapToService(self, service): + if not service is None: + if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet? + self.servicelist.clearPath() + if self.servicelist.bouquet_root != self.epg_bouquet: + self.servicelist.enterPath(self.servicelist.bouquet_root) + self.servicelist.enterPath(self.epg_bouquet) + self.servicelist.setCurrentSelection(service) #select the service in servicelist + self.servicelist.zap() + + def getBouquetServices(self, bouquet): services = [ ] servicelist = eServiceCenter.getInstance().list(bouquet) if not servicelist is None: @@ -364,32 +434,103 @@ 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.session.openWithCallback(self.bouquetEPGCallback, EPGSelection, services) - - def openSingleEPGSelector(self, ref): - ptr=eEPGCache.getInstance() - if ptr.startTimeQuery(ref) != -1: - self.session.open(EPGSelection, ref) - else: # try to show now/next - print 'no epg for service', ref.toString() - try: - self.epglist = [ ] - service = self.session.nav.getCurrentService() - info = service.info() - ptr=info.getEvent(0) - if ptr: - self.epglist.append(ptr) - ptr=info.getEvent(1) + self.epg_bouquet = bouquet + if withCallback: + self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB)) + else: + self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB) + + 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: + 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() + if bouquets is None: + cnt = 0 + else: + cnt = len(bouquets) + if cnt > 1: # show bouquet list + if withCallback: + self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True) + self.dlg_stack.append(self.bouquetSel) + else: + 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() + self.session.open(EPGSelection, ref) + + def openSimilarList(self, eventid, refstr): + self.session.open(EPGSelection, refstr, None, eventid) + + def getNowNext(self): + self.epglist = [ ] + service = self.session.nav.getCurrentService() + info = service and service.info() + ptr = info and info.getEvent(0) + if ptr: + self.epglist.append(ptr) + 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 = 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) - if len(self.epglist) > 0: - self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback) - except: - pass + else: + self.is_now_next = True + if len(self.epglist) > 0: + 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) def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying if len(self.epglist) > 1: @@ -398,325 +539,721 @@ 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) + +class InfoBarRdsDecoder: + """provides RDS and Rass support/display""" + def __init__(self): + self.rds_display = self.session.instantiateDialog(RdsInfoDisplay) + self.rass_interactive = None + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evEnd: self.__serviceStopped, + iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged + }) + + self["RdsActions"] = ActionMap(["InfobarRdsActions"], + { + "startRassInteractive": self.startRassInteractive + },-1) + + self["RdsActions"].setEnabled(False) + + self.onLayoutFinish.append(self.rds_display.show) + self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged) - self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration) - self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration) + def RassInteractivePossibilityChanged(self, state): + self["RdsActions"].setEnabled(state) - self["Now_ProgressBar"] = EventInfoProgress(self.session.nav, EventInfo.Now) + def RassSlidePicChanged(self): + if not self.rass_interactive: + service = self.session.nav.getCurrentService() + decoder = service and service.rdsDecoder() + if decoder: + decoder.showRassSlidePicture() + + def __serviceStopped(self): + if self.rass_interactive is not None: + rass_interactive = self.rass_interactive + self.rass_interactive = None + rass_interactive.close() + + def startRassInteractive(self): + self.rds_display.hide() + self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive) + + def RassInteractiveClosed(self, *val): + if self.rass_interactive is not None: + self.rass_interactive = None + self.RassSlidePicChanged() + self.rds_display.show() class InfoBarServiceName: def __init__(self): - self["ServiceName"] = ServiceName(self.session.nav) + self["CurrentService"] = CurrentService(self.session.nav) class InfoBarSeek: """handles actions like seeking, pause""" - - # ispause, isff, issm, skip - SEEK_STATE_PLAY = (0, 0, 0, 0) - SEEK_STATE_PAUSE = (1, 0, 0, 0) - SEEK_STATE_FF_2X = (0, 2, 0, 0) - SEEK_STATE_FF_4X = (0, 4, 0, 0) - SEEK_STATE_FF_8X = (0, 8, 0, 0) - SEEK_STATE_FF_32X = (0, 4, 0, 32) - SEEK_STATE_FF_64X = (0, 4, 0, 64) - SEEK_STATE_FF_128X = (0, 4, 0, 128) - - SEEK_STATE_BACK_4X = (0, 0, 0, -4) - SEEK_STATE_BACK_32X = (0, 0, 0, -32) - SEEK_STATE_BACK_64X = (0, 0, 0, -64) - SEEK_STATE_BACK_128X = (0, 0, 0, -128) - - SEEK_STATE_SM_HALF = (0, 0, 2, 0) - SEEK_STATE_SM_QUARTER = (0, 0, 4, 0) - SEEK_STATE_SM_EIGHTH = (0, 0, 8, 0) - - def __init__(self): - self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions", + + # ispause, isff, issm + SEEK_STATE_PLAY = (0, 0, 0, ">") + SEEK_STATE_PAUSE = (1, 0, 0, "||") + SEEK_STATE_FF_2X = (0, 2, 0, ">> 2x") + SEEK_STATE_FF_4X = (0, 4, 0, ">> 4x") + SEEK_STATE_FF_8X = (0, 8, 0, ">> 8x") + SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x") + SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x") + SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x") + + SEEK_STATE_BACK_16X = (0, -16, 0, "<< 16x") + SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x") + SEEK_STATE_BACK_64X = (0, -64, 0, "<< 64x") + SEEK_STATE_BACK_128X = (0, -128, 0, "<< 128x") + + SEEK_STATE_SM_HALF = (0, 0, 2, "/2") + SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4") + SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8") + + SEEK_STATE_EOF = (1, 0, 0, "END") + + def __init__(self, actionmap = "InfobarSeekActions"): + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { - "pauseService": (self.pauseService, "pause"), - "unPauseService": (self.unPauseService, "continue"), - - "seekFwd": (self.seekFwd, "skip forward"), - "seekFwdUp": (self.seekFwdUp, "skip forward"), - "seekBack": (self.seekBack, "skip backward"), - "seekBackUp": (self.seekBackUp, "skip backward"), + iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged, + iPlayableService.evStart: self.__serviceStarted, + + iPlayableService.evEOF: self.__evEOF, + iPlayableService.evSOF: self.__evSOF, }) + class InfoBarSeekActionMap(HelpableActionMap): + def __init__(self, screen, *args, **kwargs): + HelpableActionMap.__init__(self, screen, *args, **kwargs) + self.screen = screen + + def action(self, contexts, action): + print "action:", action + if action[:5] == "seek:": + time = int(action[5:]) + self.screen.seekRelative(time * 90000) + self.screen.showAfterSeek() + return 1 + else: + return HelpableActionMap.action(self, contexts, action) + + self["SeekActions"] = InfoBarSeekActionMap(self, actionmap, + { + "playpauseService": (self.playpauseService, _("pause")), + "pauseService": (self.pauseService, _("pause")), + "unPauseService": (self.unPauseService, _("continue")), + + "seekFwd": (self.seekFwd, _("skip forward")), + "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")), + "seekBack": (self.seekBack, _("skip backward")), + "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")), + }, prio=-1) + # give them a little more priority to win over color buttons + + self["SeekActions"].setEnabled(False) + self.seekstate = self.SEEK_STATE_PLAY - self.seekTimer = eTimer() - self.seekTimer.timeout.get().append(self.seekTimerFired) - self.skipinterval = 500 # 500ms skip interval - self.onClose.append(self.delSeekTimer) - - self.fwdtimer = False - self.fwdKeyTimer = eTimer() - self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire) - - self.rwdtimer = False - self.rwdKeyTimer = eTimer() - self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire) - + + self.onPlayStateChanged = [ ] + + self.lockedBecauseOfSkipping = False + + self.__seekableStatusChanged() + + def showAfterSeek(self): + if isinstance(self, InfoBarShowHide): + self.doShow() + def up(self): pass - + def down(self): pass - - def delSeekTimer(self): - del self.seekTimer - - def seekTimerFired(self): - self.seekbase += self.skipmode * self.skipinterval - - # check if we bounced against the beginning of the file - if self.seekbase < 0: - self.seekbase = 0; + + def getSeek(self): + service = self.session.nav.getCurrentService() + if service is None: + return None + + seek = service.seek() + + if seek is None or not seek.isCurrentlySeekable(): + return None + + return seek + + def isSeekable(self): + if self.getSeek() is None: + return False + return True + + def __seekableStatusChanged(self): + print "seekable status changed!" + if not self.isSeekable(): + self["SeekActions"].setEnabled(False) + print "not seekable, return to play" self.setSeekState(self.SEEK_STATE_PLAY) - - self.doSeek(self.seekbase) + else: + self["SeekActions"].setEnabled(True) + print "seekable" - def setSeekState(self, state): - oldstate = self.seekstate - - self.seekstate = state + def __serviceStarted(self): + self.seekstate = self.SEEK_STATE_PLAY + self.__seekableStatusChanged() + def setSeekState(self, state): service = self.session.nav.getCurrentService() + if service is None: - return - + return False + + if not self.isSeekable(): + if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]: + state = self.SEEK_STATE_PLAY + pauseable = service.pause() - - for i in range(4): + + if pauseable is None: + print "not pauseable." + state = self.SEEK_STATE_PLAY + + oldstate = self.seekstate + self.seekstate = state + + for i in range(3): if oldstate[i] != self.seekstate[i]: - (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion, self.setSkipMode)[i](self.seekstate[i]) - - def setSkipMode(self, skipmode): - self.skipmode = skipmode - if skipmode == 0: - self.seekTimer.stop() - else: - self.seekTimer.start(500) - - service = self.session.nav.getCurrentService() - if service is None: - return - - seekable = service.seek() - if seekable is None: - return + (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i]) + + for c in self.onPlayStateChanged: + c(self.seekstate) + + self.checkSkipShowHideLock() + + return True - if skipmode: - seekable.setTrickmode(1) + def playpauseService(self): + if self.seekstate != self.SEEK_STATE_PLAY: + self.unPauseService() else: - seekable.setTrickmode(0) - - self.seekbase = seekable.getPlayPosition()[1] / 90 - + self.pauseService() + def pauseService(self): - if (self.seekstate == self.SEEK_STATE_PAUSE): + if self.seekstate == self.SEEK_STATE_PAUSE: + print "pause, but in fact unpause" self.unPauseService() else: + if self.seekstate == self.SEEK_STATE_PLAY: + print "yes, playing." + else: + print "no", self.seekstate + print "pause" self.setSeekState(self.SEEK_STATE_PAUSE); - + def unPauseService(self): - self.setSeekState(self.SEEK_STATE_PLAY); - + print "unpause" + if self.seekstate == self.SEEK_STATE_PLAY: + return 0 + self.setSeekState(self.SEEK_STATE_PLAY) + def doSeek(self, seektime): + print "doseek", seektime service = self.session.nav.getCurrentService() if service is None: return - - seekable = service.seek() + + seekable = self.getSeek() if seekable is None: return + seekable.seekTo(90 * seektime) def seekFwd(self): - print "start fwd timer" - self.fwdtimer = True - self.fwdKeyTimer.start(500) + lookup = { + self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X, + self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH, + self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X, + self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X, + self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X, + self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X, + self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X, + self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X, + self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY, + self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X, + self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X, + self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X, + self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF, + self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF, + self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER, + self.SEEK_STATE_EOF: self.SEEK_STATE_EOF, + } + self.setSeekState(lookup[self.seekstate]) def seekBack(self): - print "start rewind timer" - self.rwdtimer = True - self.rwdKeyTimer.start(500) - - def seekFwdUp(self): - if self.fwdtimer: - self.fwdKeyTimer.stop() - self.fwdtimer = False - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH, - self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X, - self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X, - self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X, - self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X, - self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X, - self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X, - self.SEEK_STATE_BACK_4X: self.SEEK_STATE_PLAY, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_4X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X, - self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X, - self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF, - self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF, - self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER - } - self.setSeekState(lookup[self.seekstate]); - - def seekBackUp(self): - if self.rwdtimer: - self.rwdKeyTimer.stop() - self.rwdtimer = False - - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_4X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE, - self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY, - self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X, - self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X, - self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X, - self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X, - self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X, - self.SEEK_STATE_BACK_4X: self.SEEK_STATE_BACK_32X, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X, - self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X, - self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER, - self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH, - self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE - } - self.setSeekState(lookup[self.seekstate]); - - def fwdTimerFire(self): - print "Display seek fwd" - self.fwdKeyTimer.stop() - self.fwdtimer = False + lookup = { + self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X, + self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE, + self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY, + self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X, + self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X, + self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X, + self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X, + self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X, + self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X, + self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X, + self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X, + self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X, + self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER, + self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH, + self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE, + self.SEEK_STATE_EOF: self.SEEK_STATE_BACK_16X, + } + 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 seekFwdManual(self): self.session.openWithCallback(self.fwdSeekTo, MinuteInput) - + def fwdSeekTo(self, minutes): print "Seek", minutes, "minutes forward" if minutes != 0: - service = self.session.nav.getCurrentService() - if service is None: - return - seekable = service.seek() - if seekable is None: - return - seekable.seekRelative(1, minutes * 60 * 90000) - - def rwdTimerFire(self): - self.rwdKeyTimer.stop() - self.rwdtimer = False + seekable = self.getSeek() + if seekable is not None: + seekable.seekRelative(1, minutes * 60 * 90000) + + def seekBackManual(self): self.session.openWithCallback(self.rwdSeekTo, MinuteInput) - + def rwdSeekTo(self, minutes): + print "rwdSeekTo" self.fwdSeekTo(0 - minutes) + def checkSkipShowHideLock(self): + wantlock = self.seekstate != self.SEEK_STATE_PLAY + + 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 + + def __evEOF(self): + if self.seekstate == self.SEEK_STATE_EOF: + return + if self.seekstate[1] < 0: # SEEK_STATE_BACK_*X + print "end of stream while seeking back, ignoring." + return + + # if we are seeking, we try to end up ~1s before the end, and pause there. + if not self.seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]: + self.setSeekState(self.SEEK_STATE_EOF) + self.seekRelativeToEnd(-90000) + else: + self.setSeekState(self.SEEK_STATE_EOF) + + def __evSOF(self): + self.setSeekState(self.SEEK_STATE_PLAY) + self.doSeek(0) + + def seekRelative(self, diff): + seekable = self.getSeek() + if seekable is not None: + print "seekRelative: res:", seekable.seekRelative(1, diff) + else: + print "seek failed!" + + def seekRelativeToEnd(self, diff): + assert diff <= 0, "diff is expected to be negative!" + + # might sound like an evil hack, but: + # if we seekRelativeToEnd(0), we expect to be at the end, which is what we want, + # and we don't get that by passing 0 here (it would seek to begin). + if diff == 0: + diff = -1 + + # relative-to-end seeking is implemented as absolutes seeks with negative time + self.seekAbsolute(diff) + + def seekAbsolute(self, abs): + seekable = self.getSeek() + if seekable is not None: + seekable.seekTo(abs) + +from Screens.PVRState import PVRState, TimeshiftState + +class InfoBarPVRState: + def __init__(self, screen=PVRState): + self.onPlayStateChanged.append(self.__playStateChanged) + self.pvrStateDialog = self.session.instantiateDialog(screen) + self.onShow.append(self._mayShow) + self.onHide.append(self.pvrStateDialog.hide) + + def _mayShow(self): + if self.execing and self.seekstate != self.SEEK_STATE_PLAY: + self.pvrStateDialog.show() + + def __playStateChanged(self, state): + playstateString = state[3] + self.pvrStateDialog["state"].setText(playstateString) + self._mayShow() + +class InfoBarTimeshiftState(InfoBarPVRState): + def __init__(self): + InfoBarPVRState.__init__(self, screen=TimeshiftState) + + def _mayShow(self): + if self.execing and self.timeshift_enabled: + self.pvrStateDialog.show() + class InfoBarShowMovies: # i don't really like this class. # it calls a not further specified "movie list" on up/down/movieList, - # so this is not moe than an action map + # so this is not more than an action map def __init__(self): self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", { - "movieList": (self.showMovies, "movie list"), - "up": (self.showMovies, "movie list"), - "down": (self.showMovies, "movie list") + "movieList": (self.showMovies, _("movie list")), + "up": (self.showMovies, _("movie list")), + "down": (self.showMovies, _("movie list")) }) +# InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE! + +# Hrmf. +# +# Timeshift works the following way: +# demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions" +# - normal playback TUNER unused PLAY enable disable disable +# - user presses "yellow" button. FILE record PAUSE enable disable enable +# - user presess pause again FILE record PLAY enable disable enable +# - user fast forwards FILE record FF enable disable enable +# - end of timeshift buffer reached TUNER record PLAY enable enable disable +# - user backwards FILE record BACK # !! enable disable enable +# + +# in other words: +# - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"), +# freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift") +# now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled. +# - the user can now PVR around +# - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled") +# the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right +# after! +# the seek actions will be disabled, but the timeshiftActivateActions will be enabled +# - if the user rewinds, or press pause, timeshift will be activated again + +# note that a timeshift can be enabled ("recording") and +# activated (currently time-shifting). + class InfoBarTimeshift: def __init__(self): self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions", { - "timeshiftStart": (self.startTimeshift, "start timeshift "), - "timeshiftStop": (self.stopTimeshift, "stop timeshift") + "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key" + "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV' + }, prio=1) + self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"], + { + "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key" + "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key" + }, prio=-1) # priority over record + + self.timeshift_enabled = 0 + self.timeshift_state = 0 + self.ts_rewind_timer = eTimer() + self.ts_rewind_timer.timeout.get().append(self.rewindService) + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evStart: self.__serviceStarted, + iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged }) - self.tshack = 0 - + def getTimeshift(self): service = self.session.nav.getCurrentService() - return service.timeshift() + return service and service.timeshift() def startTimeshift(self): - # TODO: check for harddisk! (or do this in the interface? would make - # more sense... for example radio could be timeshifted in memory, - # and the decision can't be made here) 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 - print "ok, timeshift enabled" - if self.tshack == 0: - ts.startTimeshift() - self.tshack = 1 + return 0 + + if self.timeshift_enabled: + print "hu, timeshift already enabled?" else: - pauseable = self.session.nav.getCurrentService().pause() - pauseable.pause() # switch to record + if not ts.startTimeshift(): + self.timeshift_enabled = 1 + + # we remove the "relative time" for now. + #self.pvrStateDialog["timeshift"].setRelative(time.time()) + + # PAUSE. + #self.setSeekState(self.SEEK_STATE_PAUSE) + self.activateTimeshiftEnd(False) + + # enable the "TimeshiftEnableActions", which will override + # the startTimeshift actions + self.__seekableStatusChanged() + else: + print "timeshift failed" def stopTimeshift(self): + if not self.timeshift_enabled: + return 0 print "disable timeshift" + ts = self.getTimeshift() + if ts is None: + return 0 + self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO) + + def stopTimeshiftConfirmed(self, confirmed): + if not confirmed: + return + ts = self.getTimeshift() if ts is None: return + ts.stopTimeshift() - self.tshack = 0 - + self.timeshift_enabled = 0 + + # disable actions + self.__seekableStatusChanged() + + # activates timeshift, and seeks to (almost) the end + def activateTimeshiftEnd(self, back = True): + ts = self.getTimeshift() + print "activateTimeshiftEnd" + + if ts is None: + return + + if ts.isTimeshiftActive(): + print "!! activate timeshift called - but shouldn't this be a normal pause?" + self.pauseService() + else: + print "play, ..." + ts.activateTimeshift() # activate timeshift will automatically pause + self.setSeekState(self.SEEK_STATE_PAUSE) + self.seekRelativeToEnd(-90000) # seek approx. 1 sec before end + + if back: + self.ts_rewind_timer.start(200, 1) + + def rewindService(self): + self.setSeekState(self.SEEK_STATE_BACK_16X) + + # same as activateTimeshiftEnd, but pauses afterwards. + def activateTimeshiftEndAndPause(self): + print "activateTimeshiftEndAndPause" + #state = self.seekstate + self.activateTimeshiftEnd(False) + + def __seekableStatusChanged(self): + enabled = False + + print "self.isSeekable", self.isSeekable() + print "self.timeshift_enabled", self.timeshift_enabled + + # when this service is not seekable, but timeshift + # is enabled, this means we can activate + # the timeshift + if not self.isSeekable() and self.timeshift_enabled: + enabled = True + + 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) + self.session.pip.show() + 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 @@ -726,207 +1263,399 @@ 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.onShown.append(self["BlinkingPoint"].hideWidget) + 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 startInstantRecording(self): + + def stopCurrentRecording(self, entry = -1): + if entry is not None and entry != -1: + self.session.nav.RecordTimer.removeEntry(self.recording[entry]) + self.recording.remove(self.recording[entry]) + + def startInstantRecording(self, limitEvent = False): serviceref = self.session.nav.getCurrentlyPlayingServiceReference() - + # try to get event info event = None try: service = self.session.nav.getCurrentService() - info = service.info() - ev = info.getEvent(0) - event = ev + epg = eEPGCache.getInstance() + event = epg.lookupEventTime(serviceref, -1, 0) + if event is None: + info = service.info() + ev = info.getEvent(0) + event = ev except: pass - + + begin = time() + end = time() + 3600 * 10 + name = "instant record" + description = "" + eventid = None + if event is not None: - data = parseEvent(event) - begin = data[0] - if begin < time.time(): - begin = time.time() - - end = data[1] - if end < begin: - end = begin - - end += 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) - - # fix me, description. - self.recording = self.session.nav.recordWithTimer(serviceref, *data) - self.recording.dontSave = True - + if limitEvent: + self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO) + + data = (begin, end, name, description, eventid) + + 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: + print "pre:\n", self.recording + + if answer is None or answer[1] == "no": return - - if self.isInstantRecordRunning(): - self.stopCurrentRecording() - else: - self.startInstantRecording() + 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] == "changeendtime": + if len(self.recording) == 1: + self.setEndtime(0) + else: + self.session.openWithCallback(self.setEndTime, TimerSelection, list) + elif answer[1] == "stop": + if len(self.recording) == 1: + self.stopCurrentRecording(0) + else: + self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list) + elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"): + self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False) + if answer[1] == "manualduration": + self.changeDuration(len(self.recording)-1) + elif answer[1] == "manualendtime": + self.setEndtime(len(self.recording)-1) + print "after:\n", self.recording + + def setEndtime(self, entry): + if entry is not None: + self.selectedEntry = entry + self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end) + dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime) + dlg.setTitle(_("Please change recording endtime")) + + def TimeDateInputClosed(self, ret): + if len(ret) > 1: + if ret[0]: + localendtime = localtime(ret[1]) + print "stopping recording at", strftime("%c", localendtime) + self.recording[self.selectedEntry].end = ret[1] + self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) + + 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() + 60 * int(value) + self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) def instantRecord(self): try: - stat = os.stat(resolveFilename(SCOPE_HDD)) + stat = os_stat(resolveFilename(SCOPE_HDD)) 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"), \ + (_("change recording (endtime)"), "changeendtime"), \ + (_("add recording (indefinitely)"), "indefinitely"), \ + (_("add recording (stop after current event)"), "event"), \ + (_("add recording (enter recording duration)"), "manualduration"), \ + (_("add recording (enter recording endtime)"), "manualendtime"), \ + (_("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"), \ + (_("add recording (enter recording endtime)"), "manualendtime"), \ + (_("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() + + 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 -from Screens.SubserviceSelection import SubserviceSelection + 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 + 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) + 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.onShown.append(self["ButtonRed"].update) - self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False) - self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) - self.onShown.append(self["ButtonRedText"].update) - - self["ButtonGreen"] = Pixmap() - self["ButtonGreenText"] = Label(_("Subservices")) - - self["ButtonYellow"] = PixmapConditional(withTimer = False) - self["ButtonYellow"].setConnect(lambda: False) - - self["ButtonBlue"] = PixmapConditional(withTimer = False) - self["ButtonBlue"].setConnect(lambda: False) + self["NimA"] = Pixmap() + self["NimB"] = Pixmap() + self["NimA_Active"] = Pixmap() + self["NimB_Active"] = Pixmap() - self.session.nav.event.append(self.gotServiceEvent) # we like to get service events - - def hideSubServiceIndication(self): - self["ButtonGreen"].hideWidget() - self["ButtonGreenText"].hide() + self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0) + self["TimeshiftPossible"] = self["RecordingPossible"] + self["ExtensionsAvailable"] = Boolean(fixed=1) - def showSubServiceIndication(self): - self["ButtonGreen"].showWidget() - 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"].showWidget() - else: - self["FormatActive"].hideWidget() + self.session.nav.event.append(self.gotServiceEvent) # we like to get service events + res_mgr = eDVBResourceManager.getInstance() + if res_mgr: + 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"].showWidget() + self["NimA_Active"].hide() + if mask&2: + self["NimB_Active"].show() else: - self["DolbyActive"].hideWidget() - - def checkCrypted(self, service): - info = service.info() - if info is not None: - if info.getInfo(iServiceInformation.sIsCrypted) > 0: - self["CryptActive"].showWidget() - else: - self["CryptActive"].hideWidget() + self["NimB_Active"].hide() + + def checkTunerState(self, service): + info = service and 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 == pNavigation.evUpdatedEventInfo: - self.checkSubservices(service) - self.checkFormat(service) - elif ev == pNavigation.evUpdatedInfo: - self.checkCrypted(service) - self.checkDolby(service) - elif ev == pNavigation.evStopService: - self.hideSubServiceIndication() - self["CryptActive"].hideWidget() - self["DolbyActive"].hideWidget() - self["FormatActive"].hideWidget() + if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd: + 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: self.checkNotifications() @@ -934,10 +1663,327 @@ class InfoBarNotifications: def checkNotifications(self): if len(Notifications.notifications): n = Notifications.notifications[0] + Notifications.notifications = Notifications.notifications[1:] - print "open",n cb = n[0] + + if n[3].has_key("onSessionOpenCallback"): + n[3]["onSessionOpenCallback"]() + del n[3]["onSessionOpenCallback"] + if cb is not None: - self.session.openWithCallback(cb, *n[1:]) + dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3]) else: - self.session.open(*n[1:]) + dlg = self.session.open(n[1], *n[2], **n[3]) + + # remember that this notification is currently active + d = (n[4], dlg) + Notifications.current_notifications.append(d) + dlg.onClose.append(boundFunction(self.__notificationClosed, d)) + + def __notificationClosed(self, d): + Notifications.current_notifications.remove(d) + +class InfoBarServiceNotifications: + def __init__(self): + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evEnd: self.serviceHasEnded + }) + + def serviceHasEnded(self): + print "service end!" + + try: + self.setSeekState(self.SEEK_STATE_PLAY) + except: + pass + +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", + { + "jumpPreviousMark": (self.jumpPreviousMark, _("jump to next marked position")), + "jumpNextMark": (self.jumpNextMark, _("jump to previous marked position")), + "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position")) + }, 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() + if service is None: + return None + return service.seek() + + def cueGetCurrentPosition(self): + seek = self.__getSeekable() + if seek is None: + return None + r = seek.getPlayPosition() + if r[0]: + return None + return long(r[1]) + + def jumpPreviousNextMark(self, cmp, alternative=None): + current_pos = self.cueGetCurrentPosition() + if current_pos is None: + return + mark = self.getNearestCutPoint(current_pos, cmp=cmp) + if mark is not None: + pts = mark[0] + elif alternative is not None: + pts = alternative + else: + return + + seekable = self.__getSeekable() + if seekable is not None: + seekable.seekTo(pts) + + def jumpPreviousMark(self): + # we add 2 seconds, so if the play position is <2s after + # the mark, the mark before will be used + self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0) + + def jumpNextMark(self): + self.jumpPreviousNextMark(lambda x: x) + + def getNearestCutPoint(self, pts, cmp=abs): + # can be optimized + nearest = None + for cp in self.cut_list: + diff = cmp(cp[0] - pts) + if cp[1] == self.CUT_TYPE_MARK and diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff): + nearest = cp + return nearest + + def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False): + current_pos = self.cueGetCurrentPosition() + if current_pos is None: + print "not seekable" + return + + 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 and not onlyreturn: + self.addMark((current_pos, self.CUT_TYPE_MARK)) + + if onlyreturn: + return None + + def showAfterCuesheetOperation(self): + if isinstance(self, InfoBarShowHide): + self.doShow() + + def addMark(self, point): + insort(self.cut_list, point) + self.uploadCuesheet() + self.showAfterCuesheetOperation() + + def removeMark(self, point): + self.cut_list.remove(point) + self.uploadCuesheet() + self.showAfterCuesheetOperation() + + def showAfterCuesheetOperation(self): + if isinstance(self, InfoBarShowHide): + self.doShow() + + def __getCuesheet(self): + service = self.session.nav.getCurrentService() + if service is None: + return None + return service.cueSheet() + + def uploadCuesheet(self): + cue = self.__getCuesheet() + + if cue is None: + print "upload failed, no cuesheet interface" + return + cue.setCutList(self.cut_list) + + def downloadCuesheet(self): + cue = self.__getCuesheet() + + if cue is None: + print "download failed, no cuesheet interface" + self.cut_list = [ ] + else: + 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 + self.__selected_subtitle = None + + 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 + self.__selected_subtitle = subtitle and 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) + +class InfoBarServiceErrorPopupSupport: + def __init__(self): + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evTuneFailed: self.__tuneFailed, + iPlayableService.evStart: self.__serviceStarted + }) + self.__serviceStarted() + + def __serviceStarted(self): + self.last_error = None + Notifications.RemovePopup(id = "ZapError") + + def __tuneFailed(self): + service = self.session.nav.getCurrentService() + info = service and service.info() + error = info and info.getInfo(iServiceInformation.sDVBState) + + if error == self.last_error: + error = None + else: + self.last_error = error + + errors = { + eDVBServicePMTHandler.eventNoResources: _("No free tuner!"), + eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"), + eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"), + eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"), + eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"), + eDVBServicePMTHandler.eventNewProgramInfo: None, + eDVBServicePMTHandler.eventTuned: None, + eDVBServicePMTHandler.eventSOF: None, + eDVBServicePMTHandler.eventEOF: None + } + + error = errors.get(error) #this returns None when the key not exist in the dict + + if error is not None: + Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError") + else: + Notifications.RemovePopup(id = "ZapError")