1 from ChannelSelection import ChannelSelection, BouquetSelector
3 from Components.ActionMap import ActionMap, HelpableActionMap
4 from Components.ActionMap import NumberActionMap
5 from Components.Harddisk import harddiskmanager
6 from Components.Input import Input
7 from Components.Label import Label
8 from Components.PluginComponent import plugins
9 from Components.ServiceEventTracker import ServiceEventTracker
10 from Components.Sources.Boolean import Boolean
11 from Components.config import config, ConfigBoolean, ConfigClock
12 from Components.SystemInfo import SystemInfo
13 from Components.UsageConfig import preferredInstantRecordPath, defaultMoviePath
14 from EpgSelection import EPGSelection
15 from Plugins.Plugin import PluginDescriptor
17 from Screen import Screen
18 from Screens.ChoiceBox import ChoiceBox
19 from Screens.Dish import Dish
20 from Screens.EventView import EventViewEPGSelect, EventViewSimple
21 from Screens.InputBox import InputBox
22 from Screens.MessageBox import MessageBox
23 from Screens.MinuteInput import MinuteInput
24 from Screens.TimerSelection import TimerSelection
25 from Screens.PictureInPicture import PictureInPicture
26 from Screens.SubtitleDisplay import SubtitleDisplay
27 from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
28 from Screens.TimeDateInput import TimeDateInput
29 from ServiceReference import ServiceReference
31 from Tools import Notifications
32 from Tools.Directories import fileExists
34 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
35 iPlayableService, eServiceReference, eEPGCache
37 from time import time, localtime, strftime
38 from os import stat as os_stat
39 from bisect import insort
41 from RecordTimer import RecordTimerEntry, RecordTimer
44 from Menu import MainMenu, mdom
48 self.dishDialog = self.session.instantiateDialog(Dish)
50 class InfoBarShowHide:
51 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
59 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
61 "toggleShow": self.toggleShow,
63 }, 1) # lower prio to make it possible to override ok and cancel..
65 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
67 iPlayableService.evStart: self.serviceStarted,
70 self.__state = self.STATE_SHOWN
73 self.hideTimer = eTimer()
74 self.hideTimer.callback.append(self.doTimerHide)
75 self.hideTimer.start(5000, True)
77 self.onShow.append(self.__onShow)
78 self.onHide.append(self.__onHide)
80 def serviceStarted(self):
82 if config.usage.show_infobar_on_zap.value:
86 self.__state = self.STATE_SHOWN
89 def startHideTimer(self):
90 if self.__state == self.STATE_SHOWN and not self.__locked:
91 idx = config.usage.infobar_timeout.index
93 self.hideTimer.start(idx*1000, True)
96 self.__state = self.STATE_HIDDEN
100 self.startHideTimer()
102 def doTimerHide(self):
103 self.hideTimer.stop()
104 if self.__state == self.STATE_SHOWN:
107 def toggleShow(self):
108 if self.__state == self.STATE_SHOWN:
110 self.hideTimer.stop()
111 elif self.__state == self.STATE_HIDDEN:
115 self.__locked = self.__locked + 1
118 self.hideTimer.stop()
120 def unlockShow(self):
121 self.__locked = self.__locked - 1
123 self.startHideTimer()
125 # def startShow(self):
126 # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
127 # self.__state = self.STATE_SHOWN
129 # def startHide(self):
130 # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
131 # self.__state = self.STATE_HIDDEN
133 class NumberZap(Screen):
140 self.close(int(self["number"].getText()))
142 def keyNumberGlobal(self, number):
143 self.Timer.start(3000, True) #reset timer
144 self.field = self.field + str(number)
145 self["number"].setText(self.field)
146 if len(self.field) >= 4:
149 def __init__(self, session, number):
150 Screen.__init__(self, session)
151 self.field = str(number)
153 self["channel"] = Label(_("Channel:"))
155 self["number"] = Label(self.field)
157 self["actions"] = NumberActionMap( [ "SetupActions" ],
161 "1": self.keyNumberGlobal,
162 "2": self.keyNumberGlobal,
163 "3": self.keyNumberGlobal,
164 "4": self.keyNumberGlobal,
165 "5": self.keyNumberGlobal,
166 "6": self.keyNumberGlobal,
167 "7": self.keyNumberGlobal,
168 "8": self.keyNumberGlobal,
169 "9": self.keyNumberGlobal,
170 "0": self.keyNumberGlobal
173 self.Timer = eTimer()
174 self.Timer.callback.append(self.keyOK)
175 self.Timer.start(3000, True)
177 class InfoBarNumberZap:
178 """ Handles an initial number for NumberZapping """
180 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
182 "1": self.keyNumberGlobal,
183 "2": self.keyNumberGlobal,
184 "3": self.keyNumberGlobal,
185 "4": self.keyNumberGlobal,
186 "5": self.keyNumberGlobal,
187 "6": self.keyNumberGlobal,
188 "7": self.keyNumberGlobal,
189 "8": self.keyNumberGlobal,
190 "9": self.keyNumberGlobal,
191 "0": self.keyNumberGlobal,
194 def keyNumberGlobal(self, number):
195 # print "You pressed number " + str(number)
197 if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
198 self.pipDoHandle0Action()
200 self.servicelist.recallPrevService()
202 if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
203 self.session.openWithCallback(self.numberEntered, NumberZap, number)
205 def numberEntered(self, retval):
206 # print self.servicelist
208 self.zapToNumber(retval)
210 def searchNumberHelper(self, serviceHandler, num, bouquet):
211 servicelist = serviceHandler.list(bouquet)
212 if not servicelist is None:
214 serviceIterator = servicelist.getNext()
215 if not serviceIterator.valid(): #check end of list
217 playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
220 if not num: #found service with searched number ?
221 return serviceIterator, 0
224 def zapToNumber(self, number):
225 bouquet = self.servicelist.bouquet_root
227 serviceHandler = eServiceCenter.getInstance()
228 if not config.usage.multibouquet.value:
229 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
231 bouquetlist = serviceHandler.list(bouquet)
232 if not bouquetlist is None:
234 bouquet = bouquetlist.getNext()
235 if not bouquet.valid(): #check end of list
237 if bouquet.flags & eServiceReference.isDirectory:
238 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
239 if not service is None:
240 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
241 self.servicelist.clearPath()
242 if self.servicelist.bouquet_root != bouquet:
243 self.servicelist.enterPath(self.servicelist.bouquet_root)
244 self.servicelist.enterPath(bouquet)
245 self.servicelist.setCurrentSelection(service) #select the service in servicelist
246 self.servicelist.zap()
248 config.misc.initialchannelselection = ConfigBoolean(default = True)
250 class InfoBarChannelSelection:
251 """ ChannelSelection - handles the channelSelection dialog and the initial
252 channelChange actions which open the channelSelection dialog """
255 self.servicelist = self.session.instantiateDialog(ChannelSelection)
257 if config.misc.initialchannelselection.value:
258 self.onShown.append(self.firstRun)
260 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
262 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
263 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
264 "zapUp": (self.zapUp, _("previous channel")),
265 "zapDown": (self.zapDown, _("next channel")),
266 "historyBack": (self.historyBack, _("previous channel in history")),
267 "historyNext": (self.historyNext, _("next channel in history")),
268 "openServiceList": (self.openServiceList, _("open servicelist")),
271 def showTvChannelList(self, zap=False):
272 self.servicelist.setModeTv()
274 self.servicelist.zap()
275 self.session.execDialog(self.servicelist)
277 def showRadioChannelList(self, zap=False):
278 self.servicelist.setModeRadio()
280 self.servicelist.zap()
281 self.session.execDialog(self.servicelist)
284 self.onShown.remove(self.firstRun)
285 config.misc.initialchannelselection.value = False
286 config.misc.initialchannelselection.save()
287 self.switchChannelDown()
289 def historyBack(self):
290 self.servicelist.historyBack()
292 def historyNext(self):
293 self.servicelist.historyNext()
295 def switchChannelUp(self):
296 self.servicelist.moveUp()
297 self.session.execDialog(self.servicelist)
299 def switchChannelDown(self):
300 self.servicelist.moveDown()
301 self.session.execDialog(self.servicelist)
303 def openServiceList(self):
304 self.session.execDialog(self.servicelist)
307 if self.servicelist.inBouquet():
308 prev = self.servicelist.getCurrentSelection()
310 prev = prev.toString()
312 if config.usage.quickzap_bouquet_change.value:
313 if self.servicelist.atBegin():
314 self.servicelist.prevBouquet()
315 self.servicelist.moveUp()
316 cur = self.servicelist.getCurrentSelection()
317 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
320 self.servicelist.moveUp()
321 self.servicelist.zap()
324 if self.servicelist.inBouquet():
325 prev = self.servicelist.getCurrentSelection()
327 prev = prev.toString()
329 if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
330 self.servicelist.nextBouquet()
332 self.servicelist.moveDown()
333 cur = self.servicelist.getCurrentSelection()
334 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
337 self.servicelist.moveDown()
338 self.servicelist.zap()
341 """ Handles a menu action, to open the (main) menu """
343 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
345 "mainMenu": (self.mainMenu, _("Enter main menu...")),
347 self.session.infobar = None
350 print "loading mainmenu XML..."
351 menu = mdom.getroot()
352 assert menu.tag == "menu", "root element in menu must be 'menu'!"
354 self.session.infobar = self
355 # so we can access the currently active infobar from screens opened from within the mainmenu
356 # at the moment used from the SubserviceSelection
358 self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)
360 def mainMenuClosed(self, *val):
361 self.session.infobar = None
363 class InfoBarSimpleEventView:
364 """ Opens the Eventview for now/next """
366 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
368 "showEventInfo": (self.openEventView, _("show event details")),
369 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
372 def showEventInfoWhenNotVisible(self):
379 def openEventView(self):
381 self.epglist = epglist
382 service = self.session.nav.getCurrentService()
383 ref = self.session.nav.getCurrentlyPlayingServiceReference()
384 info = service.info()
392 self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
394 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
395 epglist = self.epglist
398 epglist[0] = epglist[1]
402 class SimpleServicelist:
403 def __init__(self, services):
404 self.services = services
405 self.length = len(services)
408 def selectService(self, service):
414 while self.services[self.current].ref != service:
416 if self.current >= self.length:
420 def nextService(self):
423 if self.current+1 < self.length:
428 def prevService(self):
431 if self.current-1 > -1:
434 self.current = self.length - 1
436 def currentService(self):
437 if not self.length or self.current >= self.length:
439 return self.services[self.current]
442 """ EPG - Opens an EPG list when the showEPGList action fires """
444 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
446 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
449 self.is_now_next = False
451 self.bouquetSel = None
452 self.eventView = None
453 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
455 "showEventInfo": (self.openEventView, _("show EPG...")),
456 "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
457 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
460 def showEventInfoWhenNotVisible(self):
467 def zapToService(self, service):
468 if not service is None:
469 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
470 self.servicelist.clearPath()
471 if self.servicelist.bouquet_root != self.epg_bouquet:
472 self.servicelist.enterPath(self.servicelist.bouquet_root)
473 self.servicelist.enterPath(self.epg_bouquet)
474 self.servicelist.setCurrentSelection(service) #select the service in servicelist
475 self.servicelist.zap()
477 def getBouquetServices(self, bouquet):
479 servicelist = eServiceCenter.getInstance().list(bouquet)
480 if not servicelist is None:
482 service = servicelist.getNext()
483 if not service.valid(): #check if end of list
485 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
487 services.append(ServiceReference(service))
490 def openBouquetEPG(self, bouquet, withCallback=True):
491 services = self.getBouquetServices(bouquet)
493 self.epg_bouquet = bouquet
495 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
497 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
499 def changeBouquetCB(self, direction, epg):
502 self.bouquetSel.down()
505 bouquet = self.bouquetSel.getCurrent()
506 services = self.getBouquetServices(bouquet)
508 self.epg_bouquet = bouquet
509 epg.setServices(services)
511 def closed(self, ret=False):
512 closedScreen = self.dlg_stack.pop()
513 if self.bouquetSel and closedScreen == self.bouquetSel:
514 self.bouquetSel = None
515 elif self.eventView and closedScreen == self.eventView:
516 self.eventView = None
518 dlgs=len(self.dlg_stack)
520 self.dlg_stack[dlgs-1].close(dlgs > 1)
522 def openMultiServiceEPG(self, withCallback=True):
523 bouquets = self.servicelist.getBouquetList()
528 if cnt > 1: # show bouquet list
530 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
531 self.dlg_stack.append(self.bouquetSel)
533 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
535 self.openBouquetEPG(bouquets[0][1], withCallback)
537 def changeServiceCB(self, direction, epg):
540 self.serviceSel.nextService()
542 self.serviceSel.prevService()
543 epg.setService(self.serviceSel.currentService())
545 def SingleServiceEPGClosed(self, ret=False):
546 self.serviceSel = None
548 def openSingleServiceEPG(self):
549 ref=self.session.nav.getCurrentlyPlayingServiceReference()
551 if self.servicelist.getMutableList() is not None: # bouquet in channellist
552 current_path = self.servicelist.getRoot()
553 services = self.getBouquetServices(current_path)
554 self.serviceSel = SimpleServicelist(services)
555 if self.serviceSel.selectService(ref):
556 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
558 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref)
560 self.session.open(EPGSelection, ref)
562 def showEventInfoPlugins(self):
563 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
566 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
567 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
569 self.openSingleServiceEPG()
571 def runPlugin(self, plugin):
572 plugin(session = self.session, servicelist = self.servicelist)
574 def EventInfoPluginChosen(self, answer):
575 if answer is not None:
578 def openSimilarList(self, eventid, refstr):
579 self.session.open(EPGSelection, refstr, None, eventid)
581 def getNowNext(self):
583 service = self.session.nav.getCurrentService()
584 info = service and service.info()
585 ptr = info and info.getEvent(0)
588 ptr = info and info.getEvent(1)
591 self.epglist = epglist
593 def __evEventInfoChanged(self):
594 if self.is_now_next and len(self.dlg_stack) == 1:
596 assert self.eventView
598 self.eventView.setEvent(self.epglist[0])
600 def openEventView(self):
601 ref = self.session.nav.getCurrentlyPlayingServiceReference()
603 epglist = self.epglist
605 self.is_now_next = False
606 epg = eEPGCache.getInstance()
607 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
610 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
614 self.is_now_next = True
616 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
617 self.dlg_stack.append(self.eventView)
619 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
620 self.openMultiServiceEPG(False)
622 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
623 epglist = self.epglist
626 epglist[0]=epglist[1]
630 class InfoBarRdsDecoder:
631 """provides RDS and Rass support/display"""
633 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
634 self.rass_interactive = None
636 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
638 iPlayableService.evEnd: self.__serviceStopped,
639 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
642 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
644 "startRassInteractive": self.startRassInteractive
647 self["RdsActions"].setEnabled(False)
649 self.onLayoutFinish.append(self.rds_display.show)
650 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
652 def RassInteractivePossibilityChanged(self, state):
653 self["RdsActions"].setEnabled(state)
655 def RassSlidePicChanged(self):
656 if not self.rass_interactive:
657 service = self.session.nav.getCurrentService()
658 decoder = service and service.rdsDecoder()
660 decoder.showRassSlidePicture()
662 def __serviceStopped(self):
663 if self.rass_interactive is not None:
664 rass_interactive = self.rass_interactive
665 self.rass_interactive = None
666 rass_interactive.close()
668 def startRassInteractive(self):
669 self.rds_display.hide()
670 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
672 def RassInteractiveClosed(self, *val):
673 if self.rass_interactive is not None:
674 self.rass_interactive = None
675 self.RassSlidePicChanged()
676 self.rds_display.show()
679 """handles actions like seeking, pause"""
681 SEEK_STATE_PLAY = (0, 0, 0, ">")
682 SEEK_STATE_PAUSE = (1, 0, 0, "||")
683 SEEK_STATE_EOF = (1, 0, 0, "END")
685 def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
686 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
688 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
689 iPlayableService.evStart: self.__serviceStarted,
691 iPlayableService.evEOF: self.__evEOF,
692 iPlayableService.evSOF: self.__evSOF,
695 class InfoBarSeekActionMap(HelpableActionMap):
696 def __init__(self, screen, *args, **kwargs):
697 HelpableActionMap.__init__(self, screen, *args, **kwargs)
700 def action(self, contexts, action):
701 print "action:", action
702 if action[:5] == "seek:":
703 time = int(action[5:])
704 self.screen.doSeekRelative(time * 90000)
706 elif action[:8] == "seekdef:":
707 key = int(action[8:])
708 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
709 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
710 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
711 self.screen.doSeekRelative(time * 90000)
714 return HelpableActionMap.action(self, contexts, action)
716 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
718 "playpauseService": self.playpauseService,
719 "pauseService": (self.pauseService, _("pause")),
720 "unPauseService": (self.unPauseService, _("continue")),
722 "seekFwd": (self.seekFwd, _("skip forward")),
723 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
724 "seekBack": (self.seekBack, _("skip backward")),
725 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
727 # give them a little more priority to win over color buttons
729 self["SeekActions"].setEnabled(False)
731 self.seekstate = self.SEEK_STATE_PLAY
732 self.lastseekstate = self.SEEK_STATE_PLAY
734 self.onPlayStateChanged = [ ]
736 self.lockedBecauseOfSkipping = False
738 self.__seekableStatusChanged()
740 def makeStateForward(self, n):
741 # minspeed = config.seek.stepwise_minspeed.value
742 # repeat = int(config.seek.stepwise_repeat.value)
743 # if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
744 # return (0, n * repeat, repeat, ">> %dx" % n)
746 return (0, n, 0, ">> %dx" % n)
748 def makeStateBackward(self, n):
749 # minspeed = config.seek.stepwise_minspeed.value
750 # repeat = int(config.seek.stepwise_repeat.value)
751 # if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
752 # return (0, -n * repeat, repeat, "<< %dx" % n)
754 return (0, -n, 0, "<< %dx" % n)
756 def makeStateSlowMotion(self, n):
757 return (0, 0, n, "/%d" % n)
759 def isStateForward(self, state):
762 def isStateBackward(self, state):
765 def isStateSlowMotion(self, state):
766 return state[1] == 0 and state[2] > 1
768 def getHigher(self, n, lst):
774 def getLower(self, n, lst):
782 def showAfterSeek(self):
783 if isinstance(self, InfoBarShowHide):
793 service = self.session.nav.getCurrentService()
797 seek = service.seek()
799 if seek is None or not seek.isCurrentlySeekable():
804 def isSeekable(self):
805 if self.getSeek() is None:
809 def __seekableStatusChanged(self):
810 # print "seekable status changed!"
811 if not self.isSeekable():
812 self["SeekActions"].setEnabled(False)
813 # print "not seekable, return to play"
814 self.setSeekState(self.SEEK_STATE_PLAY)
816 self["SeekActions"].setEnabled(True)
819 def __serviceStarted(self):
820 self.seekstate = self.SEEK_STATE_PLAY
821 self.__seekableStatusChanged()
823 def setSeekState(self, state):
824 service = self.session.nav.getCurrentService()
829 if not self.isSeekable():
830 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
831 state = self.SEEK_STATE_PLAY
833 pauseable = service.pause()
835 if pauseable is None:
836 print "not pauseable."
837 state = self.SEEK_STATE_PLAY
839 self.seekstate = state
841 if pauseable is not None:
842 if self.seekstate[0]:
843 print "resolved to PAUSE"
845 elif self.seekstate[1]:
846 print "resolved to FAST FORWARD"
847 pauseable.setFastForward(self.seekstate[1])
848 elif self.seekstate[2]:
849 print "resolved to SLOW MOTION"
850 pauseable.setSlowMotion(self.seekstate[2])
852 print "resolved to PLAY"
855 for c in self.onPlayStateChanged:
858 self.checkSkipShowHideLock()
862 def playpauseService(self):
863 if self.seekstate != self.SEEK_STATE_PLAY:
864 self.unPauseService()
868 def pauseService(self):
869 if self.seekstate == self.SEEK_STATE_PAUSE:
870 if config.seek.on_pause.value == "play":
871 self.unPauseService()
872 elif config.seek.on_pause.value == "step":
873 self.doSeekRelative(1)
874 elif config.seek.on_pause.value == "last":
875 self.setSeekState(self.lastseekstate)
876 self.lastseekstate = self.SEEK_STATE_PLAY
878 if self.seekstate != self.SEEK_STATE_EOF:
879 self.lastseekstate = self.seekstate
880 self.setSeekState(self.SEEK_STATE_PAUSE);
882 def unPauseService(self):
884 if self.seekstate == self.SEEK_STATE_PLAY:
886 self.setSeekState(self.SEEK_STATE_PLAY)
888 def doSeek(self, pts):
889 seekable = self.getSeek()
894 def doSeekRelative(self, pts):
895 seekable = self.getSeek()
898 prevstate = self.seekstate
900 if self.seekstate == self.SEEK_STATE_EOF:
901 if prevstate == self.SEEK_STATE_PAUSE:
902 self.setSeekState(self.SEEK_STATE_PAUSE)
904 self.setSeekState(self.SEEK_STATE_PLAY)
905 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
906 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
910 if self.seekstate == self.SEEK_STATE_PLAY:
911 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
912 elif self.seekstate == self.SEEK_STATE_PAUSE:
913 if len(config.seek.speeds_slowmotion.value):
914 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
916 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
917 elif self.seekstate == self.SEEK_STATE_EOF:
919 elif self.isStateForward(self.seekstate):
920 speed = self.seekstate[1]
921 if self.seekstate[2]:
922 speed /= self.seekstate[2]
923 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
924 self.setSeekState(self.makeStateForward(speed))
925 elif self.isStateBackward(self.seekstate):
926 speed = -self.seekstate[1]
927 if self.seekstate[2]:
928 speed /= self.seekstate[2]
929 speed = self.getLower(speed, config.seek.speeds_backward.value)
931 self.setSeekState(self.makeStateBackward(speed))
933 self.setSeekState(self.SEEK_STATE_PLAY)
934 elif self.isStateSlowMotion(self.seekstate):
935 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
936 self.setSeekState(self.makeStateSlowMotion(speed))
939 seekstate = self.seekstate
940 if seekstate == self.SEEK_STATE_PLAY:
941 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
942 elif seekstate == self.SEEK_STATE_EOF:
943 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
944 self.doSeekRelative(-6)
945 elif seekstate == self.SEEK_STATE_PAUSE:
946 self.doSeekRelative(-1)
947 elif self.isStateForward(seekstate):
950 speed /= seekstate[2]
951 speed = self.getLower(speed, config.seek.speeds_forward.value)
953 self.setSeekState(self.makeStateForward(speed))
955 self.setSeekState(self.SEEK_STATE_PLAY)
956 elif self.isStateBackward(seekstate):
957 speed = -seekstate[1]
959 speed /= seekstate[2]
960 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
961 self.setSeekState(self.makeStateBackward(speed))
962 elif self.isStateSlowMotion(seekstate):
963 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
965 self.setSeekState(self.makeStateSlowMotion(speed))
967 self.setSeekState(self.SEEK_STATE_PAUSE)
969 def seekFwdManual(self):
970 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
972 def fwdSeekTo(self, minutes):
973 print "Seek", minutes, "minutes forward"
974 self.doSeekRelative(minutes * 60 * 90000)
976 def seekBackManual(self):
977 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
979 def rwdSeekTo(self, minutes):
981 self.doSeekRelative(-minutes * 60 * 90000)
983 def checkSkipShowHideLock(self):
984 wantlock = self.seekstate != self.SEEK_STATE_PLAY
986 if config.usage.show_infobar_on_skip.value:
987 if self.lockedBecauseOfSkipping and not wantlock:
989 self.lockedBecauseOfSkipping = False
991 if wantlock and not self.lockedBecauseOfSkipping:
993 self.lockedBecauseOfSkipping = True
995 def calcRemainingTime(self):
996 seekable = self.getSeek()
997 if seekable is not None:
998 len = seekable.getLength()
1000 tmp = self.cueGetEndCutPosition()
1005 pos = seekable.getPlayPosition()
1006 speednom = self.seekstate[1] or 1
1007 speedden = self.seekstate[2] or 1
1008 if not len[0] and not pos[0]:
1009 if len[1] <= pos[1]:
1011 time = (len[1] - pos[1])*speedden/(90*speednom)
1016 if self.seekstate == self.SEEK_STATE_EOF:
1019 # if we are seeking forward, we try to end up ~1s before the end, and pause there.
1020 seekstate = self.seekstate
1021 if self.seekstate != self.SEEK_STATE_PAUSE:
1022 self.setSeekState(self.SEEK_STATE_EOF)
1024 if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
1025 seekable = self.getSeek()
1026 if seekable is not None:
1028 if seekstate == self.SEEK_STATE_PLAY: # regular EOF
1029 self.doEofInternal(True)
1031 self.doEofInternal(False)
1033 def doEofInternal(self, playing):
1034 pass # Defined in subclasses
1037 self.setSeekState(self.SEEK_STATE_PLAY)
1040 from Screens.PVRState import PVRState, TimeshiftState
1042 class InfoBarPVRState:
1043 def __init__(self, screen=PVRState, force_show = False):
1044 self.onPlayStateChanged.append(self.__playStateChanged)
1045 self.pvrStateDialog = self.session.instantiateDialog(screen)
1046 self.onShow.append(self._mayShow)
1047 self.onHide.append(self.pvrStateDialog.hide)
1048 self.force_show = force_show
1051 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1052 self.pvrStateDialog.show()
1054 def __playStateChanged(self, state):
1055 playstateString = state[3]
1056 self.pvrStateDialog["state"].setText(playstateString)
1058 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
1059 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
1060 self.pvrStateDialog.hide()
1065 class InfoBarTimeshiftState(InfoBarPVRState):
1067 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1070 if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
1071 self.pvrStateDialog.show()
1073 class InfoBarShowMovies:
1075 # i don't really like this class.
1076 # it calls a not further specified "movie list" on up/down/movieList,
1077 # so this is not more than an action map
1079 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1081 "movieList": (self.showMovies, _("movie list")),
1082 "up": (self.showMovies, _("movie list")),
1083 "down": (self.showMovies, _("movie list"))
1086 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1090 # Timeshift works the following way:
1091 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1092 # - normal playback TUNER unused PLAY enable disable disable
1093 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1094 # - user presess pause again FILE record PLAY enable disable enable
1095 # - user fast forwards FILE record FF enable disable enable
1096 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1097 # - user backwards FILE record BACK # !! enable disable enable
1101 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1102 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1103 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1104 # - the user can now PVR around
1105 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1106 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1108 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1109 # - if the user rewinds, or press pause, timeshift will be activated again
1111 # note that a timeshift can be enabled ("recording") and
1112 # activated (currently time-shifting).
1114 class InfoBarTimeshift:
1116 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1118 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1119 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1121 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1123 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1124 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1125 }, prio=-1) # priority over record
1127 self.timeshift_enabled = 0
1128 self.timeshift_state = 0
1129 self.ts_rewind_timer = eTimer()
1130 self.ts_rewind_timer.callback.append(self.rewindService)
1132 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1134 iPlayableService.evStart: self.__serviceStarted,
1135 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1138 def getTimeshift(self):
1139 service = self.session.nav.getCurrentService()
1140 return service and service.timeshift()
1142 def startTimeshift(self):
1143 print "enable timeshift"
1144 ts = self.getTimeshift()
1146 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1147 print "no ts interface"
1150 if self.timeshift_enabled:
1151 print "hu, timeshift already enabled?"
1153 if not ts.startTimeshift():
1154 self.timeshift_enabled = 1
1156 # we remove the "relative time" for now.
1157 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1160 #self.setSeekState(self.SEEK_STATE_PAUSE)
1161 self.activateTimeshiftEnd(False)
1163 # enable the "TimeshiftEnableActions", which will override
1164 # the startTimeshift actions
1165 self.__seekableStatusChanged()
1167 print "timeshift failed"
1169 def stopTimeshift(self):
1170 if not self.timeshift_enabled:
1172 print "disable timeshift"
1173 ts = self.getTimeshift()
1176 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1178 def stopTimeshiftConfirmed(self, confirmed):
1182 ts = self.getTimeshift()
1187 self.timeshift_enabled = 0
1190 self.__seekableStatusChanged()
1192 # activates timeshift, and seeks to (almost) the end
1193 def activateTimeshiftEnd(self, back = True):
1194 ts = self.getTimeshift()
1195 print "activateTimeshiftEnd"
1200 if ts.isTimeshiftActive():
1201 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1205 ts.activateTimeshift() # activate timeshift will automatically pause
1206 self.setSeekState(self.SEEK_STATE_PAUSE)
1209 self.doSeek(-5) # seek some gops before end
1210 self.ts_rewind_timer.start(200, 1)
1212 self.doSeek(-1) # seek 1 gop before end
1214 def rewindService(self):
1215 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1217 # same as activateTimeshiftEnd, but pauses afterwards.
1218 def activateTimeshiftEndAndPause(self):
1219 print "activateTimeshiftEndAndPause"
1220 #state = self.seekstate
1221 self.activateTimeshiftEnd(False)
1223 def __seekableStatusChanged(self):
1226 # print "self.isSeekable", self.isSeekable()
1227 # print "self.timeshift_enabled", self.timeshift_enabled
1229 # when this service is not seekable, but timeshift
1230 # is enabled, this means we can activate
1232 if not self.isSeekable() and self.timeshift_enabled:
1235 # print "timeshift activate:", enabled
1236 self["TimeshiftActivateActions"].setEnabled(enabled)
1238 def __serviceStarted(self):
1239 self.timeshift_enabled = False
1240 self.__seekableStatusChanged()
1242 from Screens.PiPSetup import PiPSetup
1244 class InfoBarExtensions:
1245 EXTENSION_SINGLE = 0
1251 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1253 "extensions": (self.showExtensionSelection, _("view extensions...")),
1254 }, 1) # lower priority
1256 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1257 self.list.append((type, extension, key))
1259 def updateExtension(self, extension, key = None):
1260 self.extensionsList.append(extension)
1262 if self.extensionKeys.has_key(key):
1266 for x in self.availableKeys:
1267 if not self.extensionKeys.has_key(x):
1272 self.extensionKeys[key] = len(self.extensionsList) - 1
1274 def updateExtensions(self):
1275 self.extensionsList = []
1276 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1277 self.extensionKeys = {}
1279 if x[0] == self.EXTENSION_SINGLE:
1280 self.updateExtension(x[1], x[2])
1283 self.updateExtension(y[0], y[1])
1286 def showExtensionSelection(self):
1287 self.updateExtensions()
1288 extensionsList = self.extensionsList[:]
1291 for x in self.availableKeys:
1292 if self.extensionKeys.has_key(x):
1293 entry = self.extensionKeys[x]
1294 extension = self.extensionsList[entry]
1296 name = str(extension[0]())
1297 list.append((extension[0](), extension))
1299 extensionsList.remove(extension)
1301 extensionsList.remove(extension)
1302 list.extend([(x[0](), x) for x in extensionsList])
1304 keys += [""] * len(extensionsList)
1305 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
1307 def extensionCallback(self, answer):
1308 if answer is not None:
1311 from Tools.BoundFunction import boundFunction
1313 # depends on InfoBarExtensions
1315 class InfoBarPlugins:
1317 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1319 def getPluginName(self, name):
1322 def getPluginList(self):
1323 list = [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
1324 list.sort(key = lambda e: e[2]) # sort by name
1327 def runPlugin(self, plugin):
1328 if isinstance(self, InfoBarChannelSelection):
1329 plugin(session = self.session, servicelist = self.servicelist)
1331 plugin(session = self.session)
1333 from Components.Task import job_manager
1334 class InfoBarJobman:
1336 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1338 def getJobList(self):
1339 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1341 def getJobName(self, job):
1342 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1344 def showJobView(self, job):
1345 from Screens.TaskView import JobView
1346 job_manager.in_background = False
1347 self.session.openWithCallback(self.JobViewCB, JobView, job)
1349 def JobViewCB(self, in_background):
1350 job_manager.in_background = in_background
1352 # depends on InfoBarExtensions
1356 self.session.pipshown
1358 self.session.pipshown = False
1359 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1361 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1362 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1363 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1365 self.addExtension((self.getShowHideName, self.showPiP, self.pipShown), "blue")
1366 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1369 return self.session.pipshown
1371 def pipHandles0Action(self):
1372 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1374 def getShowHideName(self):
1375 if self.session.pipshown:
1376 return _("Disable Picture in Picture")
1378 return _("Activate Picture in Picture")
1380 def getSwapName(self):
1381 return _("Swap Services")
1383 def getMoveName(self):
1384 return _("Move Picture in Picture")
1387 if self.session.pipshown:
1388 del self.session.pip
1389 self.session.pipshown = False
1391 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1392 self.session.pip.show()
1393 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1394 if self.session.pip.playService(newservice):
1395 self.session.pipshown = True
1396 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1398 self.session.pipshown = False
1399 del self.session.pip
1400 self.session.nav.playService(newservice)
1403 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1404 if self.session.pip.servicePath:
1405 servicepath = self.servicelist.getCurrentServicePath()
1406 ref=servicepath[len(servicepath)-1]
1407 pipref=self.session.pip.getCurrentService()
1408 self.session.pip.playService(swapservice)
1409 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1410 if pipref.toString() != ref.toString(): # is a subservice ?
1411 self.session.nav.stopService() # stop portal
1412 self.session.nav.playService(pipref) # start subservice
1413 self.session.pip.servicePath=servicepath
1416 self.session.open(PiPSetup, pip = self.session.pip)
1418 def pipDoHandle0Action(self):
1419 use = config.usage.pip_zero_button.value
1422 elif "swapstop" == use:
1428 from RecordTimer import parseEvent, RecordTimerEntry
1430 class InfoBarInstantRecord:
1431 """Instant Record - handles the instantRecord action in order to
1432 start/stop instant records"""
1434 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1436 "instantRecord": (self.instantRecord, _("Instant Record...")),
1440 def stopCurrentRecording(self, entry = -1):
1441 if entry is not None and entry != -1:
1442 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1443 self.recording.remove(self.recording[entry])
1445 def startInstantRecording(self, limitEvent = False):
1446 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1448 # try to get event info
1451 service = self.session.nav.getCurrentService()
1452 epg = eEPGCache.getInstance()
1453 event = epg.lookupEventTime(serviceref, -1, 0)
1455 info = service.info()
1456 ev = info.getEvent(0)
1462 end = begin + 3600 # dummy
1463 name = "instant record"
1467 if event is not None:
1468 curEvent = parseEvent(event)
1470 description = curEvent[3]
1471 eventid = curEvent[4]
1476 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1478 if isinstance(serviceref, eServiceReference):
1479 serviceref = ServiceReference(serviceref)
1481 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = preferredInstantRecordPath())
1482 recording.dontSave = True
1484 if event is None or limitEvent == False:
1485 recording.autoincrease = True
1486 if recording.setAutoincreaseEnd():
1487 self.session.nav.RecordTimer.record(recording)
1488 self.recording.append(recording)
1490 simulTimerList = self.session.nav.RecordTimer.record(recording)
1491 if simulTimerList is not None: # conflict with other recording
1492 name = simulTimerList[1].name
1493 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1494 print "[TIMER] conflicts with", name_date
1495 recording.autoincrease = True # start with max available length, then increment
1496 if recording.setAutoincreaseEnd():
1497 self.session.nav.RecordTimer.record(recording)
1498 self.recording.append(recording)
1499 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1501 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1502 recording.autoincrease = False
1504 self.recording.append(recording)
1506 def isInstantRecordRunning(self):
1507 print "self.recording:", self.recording
1509 for x in self.recording:
1514 def recordQuestionCallback(self, answer):
1515 print "pre:\n", self.recording
1517 if answer is None or answer[1] == "no":
1520 recording = self.recording[:]
1522 if not x in self.session.nav.RecordTimer.timer_list:
1523 self.recording.remove(x)
1524 elif x.dontSave and x.isRunning():
1525 list.append((x, False))
1527 if answer[1] == "changeduration":
1528 if len(self.recording) == 1:
1529 self.changeDuration(0)
1531 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1532 elif answer[1] == "changeendtime":
1533 if len(self.recording) == 1:
1536 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1537 elif answer[1] == "stop":
1538 if len(self.recording) == 1:
1539 self.stopCurrentRecording(0)
1541 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1542 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1543 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1544 if answer[1] == "manualduration":
1545 self.changeDuration(len(self.recording)-1)
1546 elif answer[1] == "manualendtime":
1547 self.setEndtime(len(self.recording)-1)
1548 print "after:\n", self.recording
1550 def setEndtime(self, entry):
1551 if entry is not None and entry >= 0:
1552 self.selectedEntry = entry
1553 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1554 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1555 dlg.setTitle(_("Please change recording endtime"))
1557 def TimeDateInputClosed(self, ret):
1560 localendtime = localtime(ret[1])
1561 print "stopping recording at", strftime("%c", localendtime)
1562 if self.recording[self.selectedEntry].end != ret[1]:
1563 self.recording[self.selectedEntry].autoincrease = False
1564 self.recording[self.selectedEntry].end = ret[1]
1565 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1567 def changeDuration(self, entry):
1568 if entry is not None and entry >= 0:
1569 self.selectedEntry = entry
1570 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1572 def inputCallback(self, value):
1573 if value is not None:
1574 print "stopping recording after", int(value), "minutes."
1575 entry = self.recording[self.selectedEntry]
1577 entry.autoincrease = False
1578 entry.end = int(time()) + 60 * int(value)
1579 self.session.nav.RecordTimer.timeChanged(entry)
1581 def instantRecord(self):
1582 dir = preferredInstantRecordPath()
1583 if not dir or not fileExists(dir, 'w'):
1584 dir = defaultMoviePath()
1588 # XXX: this message is a little odd as we might be recording to a remote device
1589 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1592 if self.isInstantRecordRunning():
1593 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1594 title=_("A recording is currently running.\nWhat do you want to do?"), \
1595 list=((_("stop recording"), "stop"), \
1596 (_("add recording (stop after current event)"), "event"), \
1597 (_("add recording (indefinitely)"), "indefinitely"), \
1598 (_("add recording (enter recording duration)"), "manualduration"), \
1599 (_("add recording (enter recording endtime)"), "manualendtime"), \
1600 (_("change recording (duration)"), "changeduration"), \
1601 (_("change recording (endtime)"), "changeendtime"), \
1602 (_("do nothing"), "no")))
1604 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1605 title=_("Start recording?"), \
1606 list=((_("add recording (stop after current event)"), "event"), \
1607 (_("add recording (indefinitely)"), "indefinitely"), \
1608 (_("add recording (enter recording duration)"), "manualduration"), \
1609 (_("add recording (enter recording endtime)"), "manualendtime"), \
1610 (_("don't record"), "no")))
1612 from Tools.ISO639 import LanguageCodes
1614 class InfoBarAudioSelection:
1616 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1618 "audioSelection": (self.audioSelection, _("Audio Options...")),
1621 def audioSelection(self):
1622 service = self.session.nav.getCurrentService()
1623 self.audioTracks = audio = service and service.audioTracks()
1624 n = audio and audio.getNumberOfTracks() or 0
1627 self.audioChannel = service.audioChannel()
1632 i = audio.getTrackInfo(idx)
1633 languages = i.getLanguage().split('/')
1634 description = i.getDescription()
1637 for lang in languages:
1640 if LanguageCodes.has_key(lang):
1641 language += LanguageCodes[lang][0]
1646 if len(description):
1647 description += " (" + language + ")"
1649 description = language
1651 tlist.append((description, idx))
1654 tlist.sort(key=lambda x: x[0])
1656 selectedAudio = self.audioTracks.getCurrentTrack()
1661 if x[1] != selectedAudio:
1669 if SystemInfo["CanDownmixAC3"]:
1670 flist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1671 ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
1672 usedKeys.extend(["red", "green"])
1673 availableKeys.extend(["yellow", "blue"])
1676 flist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
1677 usedKeys.extend(["red"])
1678 availableKeys.extend(["green", "yellow", "blue"])
1681 if hasattr(self, "runPlugin"):
1683 def __init__(self, fnc, *args):
1686 def __call__(self, *args, **kwargs):
1687 self.fnc(*self.args)
1689 Plugins = [ (p.name, PluginCaller(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_AUDIOMENU) ]
1693 flist.append((p[0], "CALLFUNC", p[1]))
1695 usedKeys.append(availableKeys[0])
1696 del availableKeys[0]
1700 flist.append(("--", ""))
1704 keys = usedKeys + [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0" ] + [""] * n
1705 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = flist + tlist, selection = selection, keys = keys, skin_name = "AudioTrackSelection")
1707 del self.audioTracks
1709 def changeAC3Downmix(self, arg):
1710 choicelist = self.session.current_dialog["list"]
1711 list = choicelist.list
1713 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1714 _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
1715 choicelist.setList(list)
1716 if config.av.downmix_ac3.value:
1717 config.av.downmix_ac3.value = False
1719 config.av.downmix_ac3.value = True
1720 config.av.downmix_ac3.save()
1722 def audioSelected(self, audio):
1723 if audio is not None:
1724 if isinstance(audio[1], str):
1725 if audio[1] == "mode":
1726 keys = ["red", "green", "yellow"]
1727 selection = self.audioChannel.getCurrentChannel()
1728 tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
1729 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys, skin_name ="AudioModeSelection")
1731 del self.audioChannel
1732 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1733 self.audioTracks.selectTrack(audio[1])
1735 del self.audioChannel
1736 del self.audioTracks
1738 def modeSelected(self, mode):
1739 if mode is not None:
1740 self.audioChannel.selectChannel(mode[1])
1741 del self.audioChannel
1743 class InfoBarSubserviceSelection:
1745 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1747 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1750 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1752 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1753 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1755 self["SubserviceQuickzapAction"].setEnabled(False)
1757 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1759 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1764 def checkSubservicesAvail(self):
1765 service = self.session.nav.getCurrentService()
1766 subservices = service and service.subServices()
1767 if not subservices or subservices.getNumberOfSubservices() == 0:
1768 self["SubserviceQuickzapAction"].setEnabled(False)
1770 def nextSubservice(self):
1771 self.changeSubservice(+1)
1773 def prevSubservice(self):
1774 self.changeSubservice(-1)
1776 def changeSubservice(self, direction):
1777 service = self.session.nav.getCurrentService()
1778 subservices = service and service.subServices()
1779 n = subservices and subservices.getNumberOfSubservices()
1782 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1785 if subservices.getSubservice(idx).toString() == ref.toString():
1790 selection += direction
1795 newservice = subservices.getSubservice(selection)
1796 if newservice.valid():
1799 self.session.nav.playService(newservice, False)
1801 def subserviceSelection(self):
1802 service = self.session.nav.getCurrentService()
1803 subservices = service and service.subServices()
1804 self.bouquets = self.servicelist.getBouquetList()
1805 n = subservices and subservices.getNumberOfSubservices()
1808 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1812 i = subservices.getSubservice(idx)
1813 if i.toString() == ref.toString():
1815 tlist.append((i.getName(), i))
1818 if self.bouquets and len(self.bouquets):
1819 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1820 if config.usage.multibouquet.value:
1821 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1823 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1826 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1827 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1830 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
1832 def subserviceSelected(self, service):
1834 if not service is None:
1835 if isinstance(service[1], str):
1836 if service[1] == "quickzap":
1837 from Screens.SubservicesQuickzap import SubservicesQuickzap
1838 self.session.open(SubservicesQuickzap, service[2])
1840 self["SubserviceQuickzapAction"].setEnabled(True)
1841 self.session.nav.playService(service[1], False)
1843 def addSubserviceToBouquetCallback(self, service):
1844 if len(service) > 1 and isinstance(service[1], eServiceReference):
1845 self.selectedSubservice = service
1846 if self.bouquets is None:
1849 cnt = len(self.bouquets)
1850 if cnt > 1: # show bouquet list
1851 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1852 elif cnt == 1: # add to only one existing bouquet
1853 self.addSubserviceToBouquet(self.bouquets[0][1])
1854 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1856 def bouquetSelClosed(self, confirmed):
1858 del self.selectedSubservice
1860 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1862 def addSubserviceToBouquet(self, dest):
1863 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1865 self.bsel.close(True)
1867 del self.selectedSubservice
1869 class InfoBarAdditionalInfo:
1872 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1873 self["TimeshiftPossible"] = self["RecordingPossible"]
1874 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1875 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1876 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1877 self["ExtensionsAvailable"] = Boolean(fixed=1)
1879 class InfoBarNotifications:
1881 self.onExecBegin.append(self.checkNotifications)
1882 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1883 self.onClose.append(self.__removeNotification)
1885 def __removeNotification(self):
1886 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1888 def checkNotificationsIfExecing(self):
1890 self.checkNotifications()
1892 def checkNotifications(self):
1893 notifications = Notifications.notifications
1895 n = notifications[0]
1897 del notifications[0]
1900 if n[3].has_key("onSessionOpenCallback"):
1901 n[3]["onSessionOpenCallback"]()
1902 del n[3]["onSessionOpenCallback"]
1905 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1907 dlg = self.session.open(n[1], *n[2], **n[3])
1909 # remember that this notification is currently active
1911 Notifications.current_notifications.append(d)
1912 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1914 def __notificationClosed(self, d):
1915 Notifications.current_notifications.remove(d)
1917 class InfoBarServiceNotifications:
1919 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1921 iPlayableService.evEnd: self.serviceHasEnded
1924 def serviceHasEnded(self):
1925 print "service end!"
1928 self.setSeekState(self.SEEK_STATE_PLAY)
1932 class InfoBarCueSheetSupport:
1938 ENABLE_RESUME_SUPPORT = False
1940 def __init__(self, actionmap = "InfobarCueSheetActions"):
1941 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1943 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1944 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1945 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1949 self.is_closing = False
1950 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1952 iPlayableService.evStart: self.__serviceStarted,
1955 def __serviceStarted(self):
1958 print "new service started! trying to download cuts!"
1959 self.downloadCuesheet()
1961 if self.ENABLE_RESUME_SUPPORT:
1964 for (pts, what) in self.cut_list:
1965 if what == self.CUT_TYPE_LAST:
1968 if last is not None:
1969 self.resume_point = last
1970 if config.usage.on_movie_start.value == "ask":
1971 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1972 elif config.usage.on_movie_start.value == "resume":
1973 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1974 # TRANSLATORS: at the start of a movie, when the user has selected
1975 # TRANSLATORS: "Resume from last position" as start behavior.
1976 # TRANSLATORS: The purpose is to notify the user that the movie starts
1977 # TRANSLATORS: in the middle somewhere and not from the beginning.
1978 # TRANSLATORS: (Some translators seem to have interpreted it as a
1979 # TRANSLATORS: question or a choice, but it is a statement.)
1980 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1982 def playLastCB(self, answer):
1984 self.doSeek(self.resume_point)
1985 self.hideAfterResume()
1987 def hideAfterResume(self):
1988 if isinstance(self, InfoBarShowHide):
1991 def __getSeekable(self):
1992 service = self.session.nav.getCurrentService()
1995 return service.seek()
1997 def cueGetCurrentPosition(self):
1998 seek = self.__getSeekable()
2001 r = seek.getPlayPosition()
2006 def cueGetEndCutPosition(self):
2009 for cp in self.cut_list:
2010 if cp[1] == self.CUT_TYPE_OUT:
2014 elif cp[1] == self.CUT_TYPE_IN:
2018 def jumpPreviousNextMark(self, cmp, start=False):
2019 current_pos = self.cueGetCurrentPosition()
2020 if current_pos is None:
2022 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
2023 if mark is not None:
2031 def jumpPreviousMark(self):
2032 # we add 2 seconds, so if the play position is <2s after
2033 # the mark, the mark before will be used
2034 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
2036 def jumpNextMark(self):
2037 if not self.jumpPreviousNextMark(lambda x: x):
2040 def getNearestCutPoint(self, pts, cmp=abs, start=False):
2046 bestdiff = cmp(0 - pts)
2048 nearest = [0, False]
2049 for cp in self.cut_list:
2050 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
2052 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
2053 diff = cmp(cp[0] - pts)
2059 if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
2060 diff = cmp(cp[0] - pts)
2061 if diff >= 0 and (nearest is None or bestdiff > diff):
2066 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
2067 current_pos = self.cueGetCurrentPosition()
2068 if current_pos is None:
2069 print "not seekable"
2072 nearest_cutpoint = self.getNearestCutPoint(current_pos)
2074 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
2076 return nearest_cutpoint
2078 self.removeMark(nearest_cutpoint)
2079 elif not onlyremove and not onlyreturn:
2080 self.addMark((current_pos, self.CUT_TYPE_MARK))
2085 def addMark(self, point):
2086 insort(self.cut_list, point)
2087 self.uploadCuesheet()
2088 self.showAfterCuesheetOperation()
2090 def removeMark(self, point):
2091 self.cut_list.remove(point)
2092 self.uploadCuesheet()
2093 self.showAfterCuesheetOperation()
2095 def showAfterCuesheetOperation(self):
2096 if isinstance(self, InfoBarShowHide):
2099 def __getCuesheet(self):
2100 service = self.session.nav.getCurrentService()
2103 return service.cueSheet()
2105 def uploadCuesheet(self):
2106 cue = self.__getCuesheet()
2109 print "upload failed, no cuesheet interface"
2111 cue.setCutList(self.cut_list)
2113 def downloadCuesheet(self):
2114 cue = self.__getCuesheet()
2117 print "download failed, no cuesheet interface"
2120 self.cut_list = cue.getCutList()
2122 class InfoBarSummary(Screen):
2124 <screen position="0,0" size="132,64">
2125 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2126 <convert type="ClockToText">WithSeconds</convert>
2128 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2129 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2130 <convert type="ConditionalShowHide">Blink</convert>
2132 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2133 <convert type="ServiceName">Name</convert>
2135 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2136 <convert type="EventTime">Progress</convert>
2140 # for picon: (path="piconlcd" will use LCD picons)
2141 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2142 # <convert type="ServiceName">Reference</convert>
2145 class InfoBarSummarySupport:
2149 def createSummary(self):
2150 return InfoBarSummary
2152 class InfoBarMoviePlayerSummary(Screen):
2154 <screen position="0,0" size="132,64">
2155 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2156 <convert type="ClockToText">WithSeconds</convert>
2158 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2159 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2160 <convert type="ConditionalShowHide">Blink</convert>
2162 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2163 <convert type="ServiceName">Name</convert>
2165 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2166 <convert type="ServicePosition">Position</convert>
2170 class InfoBarMoviePlayerSummarySupport:
2174 def createSummary(self):
2175 return InfoBarMoviePlayerSummary
2177 class InfoBarTeletextPlugin:
2179 self.teletext_plugin = None
2181 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2182 self.teletext_plugin = p
2184 if self.teletext_plugin is not None:
2185 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2187 "startTeletext": (self.startTeletext, _("View teletext..."))
2190 print "no teletext plugin found!"
2192 def startTeletext(self):
2193 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2195 class InfoBarSubtitleSupport(object):
2197 object.__init__(self)
2198 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2199 self.__subtitles_enabled = False
2201 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2203 iPlayableService.evEnd: self.__serviceStopped,
2204 iPlayableService.evUpdatedInfo: self.__updatedInfo
2206 self.cached_subtitle_checked = False
2207 self.__selected_subtitle = None
2209 def __serviceStopped(self):
2210 self.cached_subtitle_checked = False
2211 if self.__subtitles_enabled:
2212 self.subtitle_window.hide()
2213 self.__subtitles_enabled = False
2214 self.__selected_subtitle = None
2216 def __updatedInfo(self):
2217 if not self.cached_subtitle_checked:
2218 self.cached_subtitle_checked = True
2219 subtitle = self.getCurrentServiceSubtitle()
2220 self.setSelectedSubtitle(subtitle and subtitle.getCachedSubtitle())
2221 if self.__selected_subtitle:
2222 self.setSubtitlesEnable(True)
2224 def getCurrentServiceSubtitle(self):
2225 service = self.session.nav.getCurrentService()
2226 return service and service.subtitle()
2228 def setSubtitlesEnable(self, enable=True):
2229 subtitle = self.getCurrentServiceSubtitle()
2231 if self.__selected_subtitle:
2232 if subtitle and not self.__subtitles_enabled:
2233 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2234 self.subtitle_window.show()
2235 self.__subtitles_enabled = True
2238 subtitle.disableSubtitles(self.subtitle_window.instance)
2239 self.__selected_subtitle = False
2240 self.__subtitles_enabled = False
2241 self.subtitle_window.hide()
2243 def setSelectedSubtitle(self, subtitle):
2244 self.__selected_subtitle = subtitle
2246 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2247 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2249 class InfoBarServiceErrorPopupSupport:
2251 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2253 iPlayableService.evTuneFailed: self.__tuneFailed,
2254 iPlayableService.evStart: self.__serviceStarted
2256 self.__serviceStarted()
2258 def __serviceStarted(self):
2259 self.last_error = None
2260 Notifications.RemovePopup(id = "ZapError")
2262 def __tuneFailed(self):
2263 service = self.session.nav.getCurrentService()
2264 info = service and service.info()
2265 error = info and info.getInfo(iServiceInformation.sDVBState)
2267 if error == self.last_error:
2270 self.last_error = error
2273 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2274 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2275 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2276 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2277 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2278 eDVBServicePMTHandler.eventNewProgramInfo: None,
2279 eDVBServicePMTHandler.eventTuned: None,
2280 eDVBServicePMTHandler.eventSOF: None,
2281 eDVBServicePMTHandler.eventEOF: None,
2282 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2283 }.get(error) #this returns None when the key not exist in the dict
2285 if error is not None:
2286 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2288 Notifications.RemovePopup(id = "ZapError")