X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/33cc56eab2de8a10bda5db05870defe99c976be2..bf32c388285065d3e9024cc8181c737e621efadf:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index b729ef7e..f1141923 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -12,7 +12,6 @@ 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 @@ -32,17 +31,19 @@ from Screens.MinuteInput import MinuteInput 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 ServiceReference import ServiceReference from Tools import Notifications -from Tools.Directories import * +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 -import bisect +from time import time +from os import stat as os_stat +from bisect import insort # hack alert! from Menu import MainMenu, mdom @@ -65,19 +66,41 @@ class InfoBarShowHide: { "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, + iPlayableService.evUpdatedEventInfo: self.__eventInfoChanged }) self.__state = self.STATE_SHOWN self.__locked = 0 - self.onExecBegin.append(self.show) - self.hideTimer = eTimer() self.hideTimer.timeout.get().append(self.doTimerHide) self.hideTimer.start(5000, True) self.onShow.append(self.__onShow) self.onHide.append(self.__onHide) + self.current_begin_time=0 + + def __eventInfoChanged(self): + if self.execing: + service = self.session.nav.getCurrentService() + old_begin_time = self.current_begin_time + info = service and service.info() + ptr = info and info.getEvent(0) + self.current_begin_time = ptr and ptr.getBeginTime() or 0 + if config.usage.show_infobar_on_event_change.value: + if old_begin_time and old_begin_time != self.current_begin_time: + self.doShow() + + def __serviceStarted(self): + if self.execing: + self.current_begin_time=0 + if config.usage.show_infobar_on_zap.value: + self.doShow() def __onShow(self): self.__state = self.STATE_SHOWN @@ -192,8 +215,6 @@ class InfoBarNumberZap: # print "You pressed number " + str(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) @@ -209,9 +230,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 @@ -220,18 +241,17 @@ 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: if self.servicelist.getRoot() != bouquet: #already in correct bouquet? self.servicelist.clearPath() @@ -315,8 +335,6 @@ class InfoBarChannelSelection: else: self.servicelist.moveUp() self.servicelist.zap() - if config.usage.show_infobar_on_zap.value: - self.doShow() def zapDown(self): if self.servicelist.inBouquet(): @@ -334,8 +352,6 @@ class InfoBarChannelSelection: 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 """ @@ -344,12 +360,21 @@ class InfoBarMenu: { "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 """ @@ -415,7 +440,7 @@ 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 @@ -531,10 +556,53 @@ class InfoBarEvent: self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW) self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT) -class InfoBarRadioText: - """provides radio (RDS) text info display""" +class InfoBarRdsDecoder: + """provides RDS and Rass support/display""" def __init__(self): - self["RadioText"] = RadioText(self.session.nav) + 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"] = HelpableActionMap(self, "InfobarRdsActions", + { + "startRassInteractive": (self.startRassInteractive, _("View Rass interactive...")) + },-1) + + self["RdsActions"].setEnabled(False) + + self.onLayoutFinish.append(self.rds_display.show) + self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged) + + def RassInteractivePossibilityChanged(self, state): + self["RdsActions"].setEnabled(state) + + 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): @@ -587,6 +655,7 @@ class InfoBarSeek: self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", { + "playpauseService": (self.playpauseService, _("pause")), "pauseService": (self.pauseService, _("pause")), "unPauseService": (self.unPauseService, _("continue")), @@ -599,6 +668,8 @@ class InfoBarSeek: }, prio=-1) # give them a little more priority to win over color buttons + self["SeekActions"].setEnabled(False) + self.seekstate = self.SEEK_STATE_PLAY self.onClose.append(self.delTimer) @@ -683,6 +754,12 @@ class InfoBarSeek: self.checkSkipShowHideLock() return True + + def playpauseService(self): + if self.seekstate != self.SEEK_STATE_PLAY: + self.unPauseService() + else: + self.pauseService() def pauseService(self): if self.seekstate == self.SEEK_STATE_PAUSE: @@ -847,22 +924,26 @@ class InfoBarPVRState: def __init__(self, screen=PVRState): self.onPlayStateChanged.append(self.__playStateChanged) self.pvrStateDialog = self.session.instantiateDialog(screen) - self.onShow.append(self.__mayShow) + self.onShow.append(self._mayShow) self.onHide.append(self.pvrStateDialog.hide) - - def __mayShow(self): - if self.seekstate != self.SEEK_STATE_PLAY and self.execing: + + 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() + 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. @@ -944,7 +1025,6 @@ class InfoBarTimeshift: print "hu, timeshift already enabled?" else: if not ts.startTimeshift(): - import time self.timeshift_enabled = 1 # we remove the "relative time" for now. @@ -1111,7 +1191,6 @@ class InfoBarPlugins: def __init__(self): self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST) - def getPluginName(self, name): return name @@ -1124,44 +1203,26 @@ class InfoBarPlugins: def runPlugin(self, plugin): plugin(session = self.session) -# depends on InfoBarExtensions and InfoBarSubtitleSupport -class InfoBarSubtitles: +# depends on InfoBarExtensions +class InfoBarSleepTimer: def __init__(self): - self.addExtension((self.getDisableSubtitleName, self.disableSubtitles, self.subtitlesEnabled), "4") - self.addExtension(extension = self.getSubtitleList, type = InfoBarExtensions.EXTENSION_LIST) + self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1") - def getDisableSubtitleName(self): - return _("Disable subtitles") - - def getSubtitleList(self): - list = [] - s = self.getCurrentServiceSubtitle() - l = s and s.getSubtitleList() or [ ] + def available(self): + return True - for x in l: - list.append(((boundFunction(self.getSubtitleEntryName, x[0]), boundFunction(self.enableSubtitle, x[1]), lambda: True), None)) - return list - - def getSubtitleEntryName(self, name): - return "Enable Subtitles: " + name + def getSleepTimerName(self): + return _("Sleep Timer") - def enableSubtitle(self, subtitles): - print "enable subitles", subtitles - self.selected_subtitle = subtitles - self.subtitles_enabled = True - - def subtitlesEnabled(self): - return self.subtitles_enabled - - def disableSubtitles(self): - self.subtitles_enabled = False + 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), "red") + 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") @@ -1250,8 +1311,8 @@ class InfoBarInstantRecord: except: pass - begin = time.time() - end = time.time() + 3600 * 10 + begin = time() + end = time() + 3600 * 10 name = "instant record" description = "" eventid = None @@ -1325,20 +1386,32 @@ class InfoBarInstantRecord: def inputCallback(self, value): if value is not None: print "stopping recording after", int(value), "minutes." - self.recording[self.selectedEntry].end = time.time() + 60 * int(value) + self.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, 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")]) + self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \ + title=_("A recording is currently running.\nWhat do you want to do?"), \ + list=[(_("stop recording"), "stop"), \ + (_("change recording (duration)"), "changeduration"), \ + (_("add recording (indefinitely)"), "indefinitely"), \ + (_("add recording (stop after current event)"), "event"), \ + (_("add recording (enter recording duration)"), "manualduration"), \ + (_("do nothing"), "no")]) else: - self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")]) + 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 Tools.ISO639 import LanguageCodes @@ -1365,9 +1438,8 @@ class InfoBarAudioSelection: language = i.getLanguage() description = i.getDescription() - if len(language) == 3: - if language in LanguageCodes: - language = LanguageCodes[language][0] + if LanguageCodes.has_key(language): + language = LanguageCodes[language][0] if len(description): description += " (" + language + ")" @@ -1428,6 +1500,8 @@ class InfoBarSubserviceSelection: 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() @@ -1461,14 +1535,12 @@ class InfoBarSubserviceSelection: if newservice.valid(): del subservices del service - if config.usage.show_infobar_on_zap.value: - self.doShow() self.session.nav.playService(newservice) def subserviceSelection(self): service = self.session.nav.getCurrentService() subservices = service and service.subServices() - + self.bouquets = self.servicelist.getBouquetList() n = subservices and subservices.getNumberOfSubservices() selection = 0 if n and n > 0: @@ -1480,13 +1552,22 @@ class InfoBarSubserviceSelection: selection = x tlist.append((i.getName(), i)) - tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist - - keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n + 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 + 2, keys = keys) + 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: if isinstance(service[1], str): if service[1] == "quickzap": @@ -1494,10 +1575,34 @@ class InfoBarSubserviceSelection: 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["NimA"] = Pixmap() @@ -1510,8 +1615,8 @@ class InfoBarAdditionalInfo: self["ExtensionsAvailable"] = Boolean(fixed=1) self.session.nav.event.append(self.gotServiceEvent) # we like to get service events - res_mgr = eDVBResourceManagerPtr() - if eDVBResourceManager.getInstance(res_mgr) == 0: + res_mgr = eDVBResourceManager.getInstance() + if res_mgr: res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged) def tunerUseMaskChanged(self, mask): @@ -1525,7 +1630,7 @@ class InfoBarAdditionalInfo: self["NimB_Active"].hide() def checkTunerState(self, service): - info = service.frontendInfo() + info = service and service.frontendInfo() feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber) if feNumber is None: self["NimA"].hide() @@ -1539,7 +1644,7 @@ class InfoBarAdditionalInfo: def gotServiceEvent(self, ev): service = self.session.nav.getCurrentService() - if ev == iPlayableService.evStart: + if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd: self.checkTunerState(service) class InfoBarNotifications: @@ -1558,12 +1663,26 @@ class InfoBarNotifications: def checkNotifications(self): if len(Notifications.notifications): n = Notifications.notifications[0] + Notifications.notifications = Notifications.notifications[1:] 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], *n[2], **n[3]) + dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3]) else: - self.session.open(n[1], *n[2], **n[3]) + 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): @@ -1694,7 +1813,7 @@ class InfoBarCueSheetSupport: return None def addMark(self, point): - bisect.insort(self.cut_list, point) + insort(self.cut_list, point) self.uploadCuesheet() def removeMark(self, point): @@ -1772,15 +1891,26 @@ class InfoBarSubtitleSupport(object): self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { - iPlayableService.evStart: self.__serviceStarted, + iPlayableService.evEnd: self.__serviceStopped, + iPlayableService.evUpdatedInfo: self.__updatedInfo }) + self.cached_subtitle_checked = False - def __serviceStarted(self): - # reenable if it was enabled - r = self.__subtitles_enabled + def __serviceStopped(self): + self.subtitle_window.hide() self.__subtitles_enabled = False - self.__selected_subtitle = None - self.setSubtitlesEnable(r) + 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() @@ -1788,7 +1918,7 @@ class InfoBarSubtitleSupport(object): def setSubtitlesEnable(self, enable=True): subtitle = self.getCurrentServiceSubtitle() - if enable and self.__selected_subtitle: + 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() @@ -1796,17 +1926,53 @@ class InfoBarSubtitleSupport(object): else: if subtitle: subtitle.disableSubtitles(self.subtitle_window.instance) - - self.subtitle_window.hide() self.__subtitles_enabled = False + self.subtitle_window.hide() def setSelectedSubtitle(self, subtitle): - if self.__selected_subtitle != subtitle and self.subtitles_enabled: - # kick - self.__selected_subtitle = subtitle - self.__serviceStarted() - else: - self.__selected_subtitle = subtitle + 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")