X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/43cceefa29ad8854b32f041839fc65190b6b3ab7..efa41fe76ddfee368009a914bc9b4bff54dee8ce:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index da648d13..57194791 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -1,101 +1,57 @@ -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 - from Components.Pixmap import Pixmap, PixmapConditional -from Components.BlinkingPixmap import BlinkingPixmapConditional -from Components.ServiceName import ServiceName -from Components.EventInfo import EventInfo +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 Screens.Volume import Volume -from Screens.Mute import Mute +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 Components.Harddisk import harddiskmanager +from Screens.EventView import EventViewEPGSelect, EventViewSimple +from Screens.InputBox import InputBox +from Screens.MessageBox import MessageBox +from Screens.MinuteInput import MinuteInput +from Screens.TimerSelection import TimerSelection +from Screens.PictureInPicture import PictureInPicture +from Screens.SubtitleDisplay import SubtitleDisplay +from Screens.SleepTimerEdit import SleepTimerEdit +from ServiceReference import ServiceReference from Tools import Notifications +from Tools.Directories import SCOPE_HDD, resolveFilename -#from enigma import eTimer, eDVBVolumecontrol, quitMainloop -from enigma import * +from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \ + iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache -import time -import os +from time import time +from os import stat as os_stat +from bisect import insort # hack alert! from Menu import MainMenu, mdom -class InfoBarVolumeControl: - """Volume control, handles volUp, volDown, volMute actions and display - a corresponding dialog""" - def __init__(self): - config.audio = ConfigSubsection() - config.audio.volume = configElement("config.audio.volume", configSequence, [5], configsequencearg.get("INTEGER", (0, 100))) - - self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] , - { - "volumeUp": self.volUp, - "volumeDown": self.volDown, - "volumeMute": self.volMute, - }) - - self.volumeDialog = self.session.instantiateDialog(Volume) - self.muteDialog = self.session.instantiateDialog(Mute) - - self.hideVolTimer = eTimer() - self.hideVolTimer.timeout.get().append(self.volHide) - - vol = config.audio.volume.value[0] - self.volumeDialog.setValue(vol) - eDVBVolumecontrol.getInstance().setVolume(vol, vol) - - def volSave(self): - config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume() - config.audio.volume.save() - - def volUp(self): - if (eDVBVolumecontrol.getInstance().isMuted()): - self.volMute() - eDVBVolumecontrol.getInstance().volumeUp() - self.volumeDialog.instance.show() - self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume()) - self.volSave() - self.hideVolTimer.start(3000) - - def volDown(self): - if (eDVBVolumecontrol.getInstance().isMuted()): - self.volMute() - eDVBVolumecontrol.getInstance().volumeDown() - self.volumeDialog.instance.show() - self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume()) - self.volSave() - self.hideVolTimer.start(3000) - - def volHide(self): - self.volumeDialog.instance.hide() - - def volMute(self): - eDVBVolumecontrol.getInstance().volumeToggleMute() - self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume()) - - if (eDVBVolumecontrol.getInstance().isMuted()): - self.muteDialog.instance.show() - else: - self.muteDialog.instance.hide() - 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 @@ -112,50 +68,65 @@ class InfoBarShowHide: "hide": self.hide, }) - self.state = self.STATE_SHOWN + self.__state = self.STATE_SHOWN + self.__locked = 0 self.onExecBegin.append(self.show) - self.onClose.append(self.delHideTimer) self.hideTimer = eTimer() self.hideTimer.timeout.get().append(self.doTimerHide) - self.hideTimer.start(5000) + self.hideTimer.start(5000, True) + + self.onShow.append(self.__onShow) + self.onHide.append(self.__onHide) - def delHideTimer(self): - del self.hideTimer + 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 hide(self): - self.instance.hide() - - def show(self): - self.state = self.STATE_SHOWN - self.hideTimer.stop() - self.hideTimer.start(5000) + 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 startShow(self): - self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100) - self.state = self.STATE_SHOWN + + def lockShow(self): + self.__locked = self.__locked + 1 + if self.execing: + self.show() + self.hideTimer.stop() - def startHide(self): - self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100) - self.state = self.STATE_HIDDEN + 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): @@ -167,7 +138,7 @@ class NumberZap(Screen): self.close(int(self["number"].getText())) def keyNumberGlobal(self, number): - self.Timer.start(3000) #reset timer + self.Timer.start(3000, True) #reset timer self.field = self.field + str(number) self["number"].setText(self.field) if len(self.field) >= 4: @@ -199,47 +170,12 @@ class NumberZap(Screen): self.Timer = eTimer() self.Timer.timeout.get().append(self.keyOK) - self.Timer.start(3000) - -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) - - 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) + self.Timer.start(3000, True) 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, @@ -255,7 +191,12 @@ class InfoBarNumberZap: def keyNumberGlobal(self, number): # print "You pressed number " + str(number) - self.session.openWithCallback(self.numberEntered, NumberZap, number) + if number == 0: + self.servicelist.recallPrevService() + if config.usage.show_infobar_on_zap.value: + self.doShow() + else: + self.session.openWithCallback(self.numberEntered, NumberZap, number) def numberEntered(self, retval): # print self.servicelist @@ -269,9 +210,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 @@ -280,23 +221,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 = bouquetlist.getNext() + bouquet = self.servicelist.appendDVBTypes(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 @@ -304,179 +249,969 @@ class InfoBarChannelSelection: 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, - "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): - self.servicelist.moveUp() + + def showTvChannelList(self, zap=False): + self.servicelist.setModeTv() + if zap: + self.servicelist.zap() self.session.execDialog(self.servicelist) - def switchChannelDown(self): - self.servicelist.moveDown() + def showRadioChannelList(self, zap=False): + self.servicelist.setModeRadio() + if zap: + self.servicelist.zap() self.session.execDialog(self.servicelist) - def zapUp(self): + 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.servicelist.zap() - self.instance.show() - self.show() + self.session.execDialog(self.servicelist) - def zapDown(self): + def switchChannelDown(self): self.servicelist.moveDown() + self.session.execDialog(self.servicelist) + + 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() - + if config.usage.show_infobar_on_zap.value: + self.doShow() + + 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() + 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 """ + 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.showEPGList, _("show EPG...")), + "showEventInfo": (self.openEventView, _("show EPG...")), }) - def showEPGList(self): + 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: + while True: + service = servicelist.getNext() + if not service.valid(): #check if end of list + break + 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.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() - 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.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, val): #used for now/next displaying + 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]) -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(500) - - 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_Duration) - self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration) +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 InfoBarPVR: - """handles PVR specific actions like seeking, pause""" +class InfoBarSeek: + """handles actions like seeking, pause""" + + # 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") + def __init__(self): - self["PVRActions"] = HelpableActionMap(self, "InfobarPVRActions", + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { - "pauseService": (self.pauseService, "pause"), - "unPauseService": (self.unPauseService, "continue"), + iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged, + iPlayableService.evStart: self.__serviceStarted, - "seekFwd": (self.seekFwd, "skip forward"), - "seekBack": (self.seekBack, "skip backward"), + 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): + 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", + { + "playpauseService": (self.playpauseService, _("pause")), + "pauseService": (self.pauseService, _("pause")), + "unPauseService": (self.unPauseService, _("continue")), + + "seekFwd": (self.seekFwd, _("skip forward")), + "seekFwdDown": self.seekFwdDown, + "seekFwdUp": self.seekFwdUp, + "seekBack": (self.seekBack, _("skip backward")), + "seekBackDown": self.seekBackDown, + "seekBackUp": self.seekBackUp, + }, prio=-1) + # give them a little more priority to win over color buttons + + self.seekstate = self.SEEK_STATE_PLAY + self.onClose.append(self.delTimer) + + 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 + + def up(self): + pass + + def down(self): + pass + + def delTimer(self): + del self.fwdKeyTimer + del self.rwdKeyTimer + + 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) + else: + self["SeekActions"].setEnabled(True) + print "seekable" + + def __serviceStarted(self): + self.seekstate = self.SEEK_STATE_PLAY + + def setSeekState(self, state): + service = self.session.nav.getCurrentService() + + if service is None: + 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() + + 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)[i](self.seekstate[i]) + + for c in self.onPlayStateChanged: + c(self.seekstate) + + self.checkSkipShowHideLock() + + return True + + def playpauseService(self): + if self.seekstate != self.SEEK_STATE_PLAY: + self.unPauseService() + else: + self.pauseService() + def pauseService(self): - self.session.nav.pause(1) + 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.session.nav.pause(0) + print "unpause" + if self.seekstate == self.SEEK_STATE_PLAY: + return 0 + self.setSeekState(self.SEEK_STATE_PLAY) - def doSeek(self, dir, seektime): + 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.seekRelative(dir, 90 * seektime) + + seekable.seekTo(90 * seektime) + + def seekFwdDown(self): + print "start fwd timer" + self.fwdtimer = True + self.fwdKeyTimer.start(1000) + + def seekBackDown(self): + print "start rewind timer" + self.rwdtimer = True + self.rwdKeyTimer.start(1000) + + def seekFwdUp(self): + print "seekFwdUp" + if self.fwdtimer: + self.fwdKeyTimer.stop() + self.fwdtimer = False + self.seekFwd() def seekFwd(self): - self.doSeek(+1, 60000) + 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.setSeekState(lookup[self.seekstate]) + def seekBackUp(self): + print "seekBackUp" + if self.rwdtimer: + self.rwdKeyTimer.stop() + self.rwdtimer = False + self.seekBack() + def seekBack(self): - self.doSeek(-1, 60000) + 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.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" + self.fwdKeyTimer.stop() + self.fwdtimer = False + self.session.openWithCallback(self.fwdSeekTo, MinuteInput) + + def fwdSeekTo(self, minutes): + print "Seek", minutes, "minutes forward" + if minutes != 0: + seekable = self.getSeek() + if seekable is not None: + seekable.seekRelative(1, minutes * 60 * 90000) + + def rwdTimerFire(self): + print "rwdTimerFire" + self.rwdKeyTimer.stop() + self.rwdtimer = False + 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_PLAY: + self.setSeekState(self.SEEK_STATE_PAUSE) + # HACK + #self.getSeek().seekRelative(1, -90000) + self.setSeekState(self.SEEK_STATE_PLAY) + else: + self.setSeekState(self.SEEK_STATE_PAUSE) + + def __evSOF(self): + self.setSeekState(self.SEEK_STATE_PLAY) + self.doSeek(0) + + def seekRelative(self, diff): + seekable = self.getSeek() + if seekable is not None: + seekable.seekRelative(1, diff) + + def seekAbsolute(self, abs): + seekable = self.getSeek() + if seekable is not None: + seekable.seekTo(abs) + +from Screens.PVRState import PVRState, TimeshiftState + +class InfoBarPVRState: + def __init__(self, screen=PVRState, show_always=False): + self.show_always = show_always + 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.show_always or 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, show_always=True) + +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 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") + }) + +# 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. TUNER 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")), # the "yellow key" + "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV' + }, prio=1) + self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"], + { + "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key" + "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "backward key" + }, prio=-1) # priority over record + + self.timeshift_enabled = 0 + self.timeshift_state = 0 + self.ts_pause_timer = eTimer() + self.ts_pause_timer.timeout.get().append(self.pauseService) + + 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 and service.timeshift() + + def startTimeshift(self): + print "enable timeshift" + ts = self.getTimeshift() + if ts is None: + self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR) + print "no ts interface" + return 0; + + if self.timeshift_enabled: + print "hu, timeshift already enabled?" + else: + 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) + + # 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.timeshift_enabled = 0 + + # disable actions + self.__seekableStatusChanged() + + # activates timeshift, and seeks to (almost) the end + def activateTimeshiftEnd(self): + ts = self.getTimeshift() + + if ts is None: + return + + if ts.isTimeshiftActive(): + print "!! activate timeshift called - but shouldn't this be a normal pause?" + self.pauseService() + else: + self.setSeekState(self.SEEK_STATE_PLAY) + ts.activateTimeshift() + self.seekRelative(0) + + # same as activateTimeshiftEnd, but pauses afterwards. + def activateTimeshiftEndAndPause(self): + state = self.seekstate + self.activateTimeshiftEnd() + + # well, this is "andPause", but it could be pressed from pause, + # when pausing on the (fake-)"live" picture, so an un-pause + # is perfectly ok. + + print "now, pauseService" + if state == self.SEEK_STATE_PLAY: + print "is PLAYING, start pause timer" + self.ts_pause_timer.start(200, 1) + else: + print "unpause" + self.unPauseService() + + 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) + 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: """Instant Record - handles the instantRecord action in order to @@ -484,136 +1219,370 @@ 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 - epg = None + event = None try: service = self.session.nav.getCurrentService() - info = service.info() - ev = info.getEvent(0) - epg = 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: + curEvent = parseEvent(event) + name = curEvent[2] + description = curEvent[3] + eventid = curEvent[4] + if limitEvent: + end = curEvent[1] + else: + 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(time.time(), time.time() + 3600, serviceref, epg, "instant record") - 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() + 60 * int(value) + self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) def instantRecord(self): try: - stat = os.stat("/hdd/movies") + stat = os_stat(resolveFilename(SCOPE_HDD)) except: - self.session.open(MessageBox, "No HDD found!") + 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() + + 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 -from Screens.SubserviceSelection import SubserviceSelection + 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"] = PixmapConditional() - # TODO: get the info from c++ somehow - self["DolbyActive"].setConnect(lambda: False) - - self["CryptActive"] = PixmapConditional() - # TODO: get the info from c++ somehow - self["CryptActive"].setConnect(lambda: False) - - self["FormatActive"] = PixmapConditional() - # TODO: get the info from c++ somehow - self["FormatActive"].setConnect(lambda: False) - - 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"] = PixmapConditional() - self["ButtonGreen"].setConnect(lambda: self.session.nav.getCurrentService().subServices().getNumberOfSubservices() > 0) - self["ButtonGreenText"] = LabelConditional(text = _("Subservices")) - self["ButtonGreenText"].setConnect(lambda: self.session.nav.getCurrentService().subServices().getNumberOfSubservices() > 0) - - self["ButtonYellow"] = PixmapConditional() - self["ButtonYellow"].setConnect(lambda: False) - - self["ButtonBlue"] = PixmapConditional() - self["ButtonBlue"].setConnect(lambda: False) + self["NimA"] = Pixmap() + self["NimB"] = Pixmap() + self["NimA_Active"] = Pixmap() + self["NimB_Active"] = Pixmap() + + self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0) + self["TimeshiftPossible"] = self["RecordingPossible"] + self["ExtensionsAvailable"] = Boolean(fixed=1) + + 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 tunerUseMaskChanged(self, mask): + if mask&1: + self["NimA_Active"].show() + else: + self["NimA_Active"].hide() + if mask&2: + self["NimB_Active"].show() + else: + 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.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: @@ -622,10 +1591,314 @@ 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 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 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 addMark(self, point): + insort(self.cut_list, point) + self.uploadCuesheet() + + def removeMark(self, point): + self.cut_list.remove(point) + self.uploadCuesheet() + + 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 "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) + +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 + } + + if error not in errors: + error = None + + error = error is not None and errors[error] + + if error is not None: + Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError") + else: + Notifications.RemovePopup(id = "ZapError")