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 EpgSelection import EPGSelection
14 from Plugins.Plugin import PluginDescriptor
16 from Screen import Screen
17 from Screens.ChoiceBox import ChoiceBox
18 from Screens.Dish import Dish
19 from Screens.EventView import EventViewEPGSelect, EventViewSimple
20 from Screens.InputBox import InputBox
21 from Screens.MessageBox import MessageBox
22 from Screens.MinuteInput import MinuteInput
23 from Screens.TimerSelection import TimerSelection
24 from Screens.PictureInPicture import PictureInPicture
25 from Screens.SubtitleDisplay import SubtitleDisplay
26 from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
27 from Screens.SleepTimerEdit import SleepTimerEdit
28 from Screens.TimeDateInput import TimeDateInput
29 from ServiceReference import ServiceReference
31 from Tools import Notifications
32 from Tools.Directories import SCOPE_HDD, resolveFilename, 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")),
371 def openEventView(self):
373 self.epglist = epglist
374 service = self.session.nav.getCurrentService()
375 ref = self.session.nav.getCurrentlyPlayingServiceReference()
376 info = service.info()
384 self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
386 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
387 epglist = self.epglist
390 epglist[0] = epglist[1]
394 class SimpleServicelist:
395 def __init__(self, services):
396 self.services = services
397 self.length = len(services)
400 def selectService(self, service):
406 while self.services[self.current].ref != service:
408 if self.current >= self.length:
412 def nextService(self):
415 if self.current+1 < self.length:
420 def prevService(self):
423 if self.current-1 > -1:
426 self.current = self.length - 1
428 def currentService(self):
429 if not self.length or self.current >= self.length:
431 return self.services[self.current]
434 """ EPG - Opens an EPG list when the showEPGList action fires """
436 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
438 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
441 self.is_now_next = False
443 self.bouquetSel = None
444 self.eventView = None
445 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
447 "showEventInfo": (self.openEventView, _("show EPG...")),
448 "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
449 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
452 def showEventInfoWhenNotVisible(self):
459 def zapToService(self, service):
460 if not service is None:
461 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
462 self.servicelist.clearPath()
463 if self.servicelist.bouquet_root != self.epg_bouquet:
464 self.servicelist.enterPath(self.servicelist.bouquet_root)
465 self.servicelist.enterPath(self.epg_bouquet)
466 self.servicelist.setCurrentSelection(service) #select the service in servicelist
467 self.servicelist.zap()
469 def getBouquetServices(self, bouquet):
471 servicelist = eServiceCenter.getInstance().list(bouquet)
472 if not servicelist is None:
474 service = servicelist.getNext()
475 if not service.valid(): #check if end of list
477 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
479 services.append(ServiceReference(service))
482 def openBouquetEPG(self, bouquet, withCallback=True):
483 services = self.getBouquetServices(bouquet)
485 self.epg_bouquet = bouquet
487 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
489 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
491 def changeBouquetCB(self, direction, epg):
494 self.bouquetSel.down()
497 bouquet = self.bouquetSel.getCurrent()
498 services = self.getBouquetServices(bouquet)
500 self.epg_bouquet = bouquet
501 epg.setServices(services)
503 def closed(self, ret=False):
504 closedScreen = self.dlg_stack.pop()
505 if self.bouquetSel and closedScreen == self.bouquetSel:
506 self.bouquetSel = None
507 elif self.eventView and closedScreen == self.eventView:
508 self.eventView = None
510 dlgs=len(self.dlg_stack)
512 self.dlg_stack[dlgs-1].close(dlgs > 1)
514 def openMultiServiceEPG(self, withCallback=True):
515 bouquets = self.servicelist.getBouquetList()
520 if cnt > 1: # show bouquet list
522 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
523 self.dlg_stack.append(self.bouquetSel)
525 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
527 self.openBouquetEPG(bouquets[0][1], withCallback)
529 def changeServiceCB(self, direction, epg):
532 self.serviceSel.nextService()
534 self.serviceSel.prevService()
535 epg.setService(self.serviceSel.currentService())
537 def SingleServiceEPGClosed(self, ret=False):
538 self.serviceSel = None
540 def openSingleServiceEPG(self):
541 ref=self.session.nav.getCurrentlyPlayingServiceReference()
543 if self.servicelist.getMutableList() is not None: # bouquet in channellist
544 current_path = self.servicelist.getRoot()
545 services = self.getBouquetServices(current_path)
546 self.serviceSel = SimpleServicelist(services)
547 if self.serviceSel.selectService(ref):
548 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
550 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref)
552 self.session.open(EPGSelection, ref)
554 def showEventInfoPlugins(self):
555 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
558 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
559 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
561 self.openSingleServiceEPG()
563 def runPlugin(self, plugin):
564 plugin(session = self.session, servicelist = self.servicelist)
566 def EventInfoPluginChosen(self, answer):
567 if answer is not None:
570 def openSimilarList(self, eventid, refstr):
571 self.session.open(EPGSelection, refstr, None, eventid)
573 def getNowNext(self):
575 service = self.session.nav.getCurrentService()
576 info = service and service.info()
577 ptr = info and info.getEvent(0)
580 ptr = info and info.getEvent(1)
583 self.epglist = epglist
585 def __evEventInfoChanged(self):
586 if self.is_now_next and len(self.dlg_stack) == 1:
588 assert self.eventView
590 self.eventView.setEvent(self.epglist[0])
592 def openEventView(self):
593 ref = self.session.nav.getCurrentlyPlayingServiceReference()
595 epglist = self.epglist
597 self.is_now_next = False
598 epg = eEPGCache.getInstance()
599 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
602 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
606 self.is_now_next = True
608 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
609 self.dlg_stack.append(self.eventView)
611 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
612 self.openMultiServiceEPG(False)
614 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
615 epglist = self.epglist
618 epglist[0]=epglist[1]
622 class InfoBarRdsDecoder:
623 """provides RDS and Rass support/display"""
625 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
626 self.rass_interactive = None
628 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
630 iPlayableService.evEnd: self.__serviceStopped,
631 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
634 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
636 "startRassInteractive": self.startRassInteractive
639 self["RdsActions"].setEnabled(False)
641 self.onLayoutFinish.append(self.rds_display.show)
642 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
644 def RassInteractivePossibilityChanged(self, state):
645 self["RdsActions"].setEnabled(state)
647 def RassSlidePicChanged(self):
648 if not self.rass_interactive:
649 service = self.session.nav.getCurrentService()
650 decoder = service and service.rdsDecoder()
652 decoder.showRassSlidePicture()
654 def __serviceStopped(self):
655 if self.rass_interactive is not None:
656 rass_interactive = self.rass_interactive
657 self.rass_interactive = None
658 rass_interactive.close()
660 def startRassInteractive(self):
661 self.rds_display.hide()
662 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
664 def RassInteractiveClosed(self, *val):
665 if self.rass_interactive is not None:
666 self.rass_interactive = None
667 self.RassSlidePicChanged()
668 self.rds_display.show()
671 """handles actions like seeking, pause"""
673 SEEK_STATE_PLAY = (0, 0, 0, ">")
674 SEEK_STATE_PAUSE = (1, 0, 0, "||")
675 SEEK_STATE_EOF = (1, 0, 0, "END")
677 def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
678 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
680 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
681 iPlayableService.evStart: self.__serviceStarted,
683 iPlayableService.evEOF: self.__evEOF,
684 iPlayableService.evSOF: self.__evSOF,
687 self.minSpeedBackward = useSeekBackHack and 16 or 0
689 class InfoBarSeekActionMap(HelpableActionMap):
690 def __init__(self, screen, *args, **kwargs):
691 HelpableActionMap.__init__(self, screen, *args, **kwargs)
694 def action(self, contexts, action):
695 print "action:", action
696 if action[:5] == "seek:":
697 time = int(action[5:])
698 self.screen.doSeekRelative(time * 90000)
700 elif action[:8] == "seekdef:":
701 key = int(action[8:])
702 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
703 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
704 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
705 self.screen.doSeekRelative(time * 90000)
708 return HelpableActionMap.action(self, contexts, action)
710 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
712 "playpauseService": self.playpauseService,
713 "pauseService": (self.pauseService, _("pause")),
714 "unPauseService": (self.unPauseService, _("continue")),
716 "seekFwd": (self.seekFwd, _("skip forward")),
717 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
718 "seekBack": (self.seekBack, _("skip backward")),
719 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
721 # give them a little more priority to win over color buttons
723 self["SeekActions"].setEnabled(False)
725 self.seekstate = self.SEEK_STATE_PLAY
726 self.lastseekstate = self.SEEK_STATE_PLAY
728 self.onPlayStateChanged = [ ]
730 self.lockedBecauseOfSkipping = False
732 self.__seekableStatusChanged()
734 def makeStateForward(self, n):
735 minspeed = config.seek.stepwise_minspeed.value
736 repeat = int(config.seek.stepwise_repeat.value)
737 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
738 return (0, n * repeat, repeat, ">> %dx" % n)
740 return (0, n, 0, ">> %dx" % n)
742 def makeStateBackward(self, n):
743 minspeed = config.seek.stepwise_minspeed.value
744 repeat = int(config.seek.stepwise_repeat.value)
745 if self.minSpeedBackward and n < self.minSpeedBackward:
746 r = (self.minSpeedBackward - 1)/ n + 1
747 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
749 return (0, -n * r, r, "<< %dx" % n)
750 elif minspeed != "Never" and n >= int(minspeed) and repeat > 1:
751 return (0, -n * repeat, repeat, "<< %dx" % n)
753 return (0, -n, 0, "<< %dx" % n)
755 def makeStateSlowMotion(self, n):
756 return (0, 0, n, "/%d" % n)
758 def isStateForward(self, state):
761 def isStateBackward(self, state):
764 def isStateSlowMotion(self, state):
765 return state[1] == 0 and state[2] > 1
767 def getHigher(self, n, lst):
773 def getLower(self, n, lst):
781 def showAfterSeek(self):
782 if isinstance(self, InfoBarShowHide):
792 service = self.session.nav.getCurrentService()
796 seek = service.seek()
798 if seek is None or not seek.isCurrentlySeekable():
803 def isSeekable(self):
804 if self.getSeek() is None:
808 def __seekableStatusChanged(self):
809 # print "seekable status changed!"
810 if not self.isSeekable():
811 self["SeekActions"].setEnabled(False)
812 # print "not seekable, return to play"
813 self.setSeekState(self.SEEK_STATE_PLAY)
815 self["SeekActions"].setEnabled(True)
818 def __serviceStarted(self):
819 self.seekstate = self.SEEK_STATE_PLAY
820 self.__seekableStatusChanged()
822 def setSeekState(self, state):
823 service = self.session.nav.getCurrentService()
828 if not self.isSeekable():
829 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
830 state = self.SEEK_STATE_PLAY
832 pauseable = service.pause()
834 if pauseable is None:
835 print "not pauseable."
836 state = self.SEEK_STATE_PLAY
838 self.seekstate = state
840 if pauseable is not None:
841 if self.seekstate[0]:
842 print "resolved to PAUSE"
844 elif self.seekstate[1]:
845 print "resolved to FAST FORWARD"
846 pauseable.setFastForward(self.seekstate[1])
847 elif self.seekstate[2]:
848 print "resolved to SLOW MOTION"
849 pauseable.setSlowMotion(self.seekstate[2])
851 print "resolved to PLAY"
854 for c in self.onPlayStateChanged:
857 self.checkSkipShowHideLock()
861 def playpauseService(self):
862 if self.seekstate != self.SEEK_STATE_PLAY:
863 self.unPauseService()
867 def pauseService(self):
868 if self.seekstate == self.SEEK_STATE_PAUSE:
869 if config.seek.on_pause.value == "play":
870 self.unPauseService()
871 elif config.seek.on_pause.value == "step":
872 self.doSeekRelative(0)
873 elif config.seek.on_pause.value == "last":
874 self.setSeekState(self.lastseekstate)
875 self.lastseekstate = self.SEEK_STATE_PLAY
877 if self.seekstate != self.SEEK_STATE_EOF:
878 self.lastseekstate = self.seekstate
879 self.setSeekState(self.SEEK_STATE_PAUSE);
881 def unPauseService(self):
883 if self.seekstate == self.SEEK_STATE_PLAY:
885 self.setSeekState(self.SEEK_STATE_PLAY)
887 def doSeek(self, pts):
888 seekable = self.getSeek()
893 def doSeekRelative(self, pts):
894 seekable = self.getSeek()
897 prevstate = self.seekstate
899 if self.seekstate == self.SEEK_STATE_EOF:
900 if prevstate == self.SEEK_STATE_PAUSE:
901 self.setSeekState(self.SEEK_STATE_PAUSE)
903 self.setSeekState(self.SEEK_STATE_PLAY)
904 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
905 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
909 if self.seekstate == self.SEEK_STATE_PLAY:
910 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
911 elif self.seekstate == self.SEEK_STATE_PAUSE:
912 if len(config.seek.speeds_slowmotion.value):
913 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
915 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
916 elif self.seekstate == self.SEEK_STATE_EOF:
918 elif self.isStateForward(self.seekstate):
919 speed = self.seekstate[1]
920 if self.seekstate[2]:
921 speed /= self.seekstate[2]
922 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
923 self.setSeekState(self.makeStateForward(speed))
924 elif self.isStateBackward(self.seekstate):
925 speed = -self.seekstate[1]
926 if self.seekstate[2]:
927 speed /= self.seekstate[2]
928 speed = self.getLower(speed, config.seek.speeds_backward.value)
930 self.setSeekState(self.makeStateBackward(speed))
932 self.setSeekState(self.SEEK_STATE_PLAY)
933 elif self.isStateSlowMotion(self.seekstate):
934 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
935 self.setSeekState(self.makeStateSlowMotion(speed))
938 seekstate = self.seekstate
939 if seekstate == self.SEEK_STATE_PLAY:
940 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
941 elif seekstate == self.SEEK_STATE_EOF:
942 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
943 self.doSeekRelative(-6)
944 elif seekstate == self.SEEK_STATE_PAUSE:
945 self.doSeekRelative(-3)
946 elif self.isStateForward(seekstate):
949 speed /= seekstate[2]
950 speed = self.getLower(speed, config.seek.speeds_forward.value)
952 self.setSeekState(self.makeStateForward(speed))
954 self.setSeekState(self.SEEK_STATE_PLAY)
955 elif self.isStateBackward(seekstate):
956 speed = -seekstate[1]
958 speed /= seekstate[2]
959 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
960 self.setSeekState(self.makeStateBackward(speed))
961 elif self.isStateSlowMotion(seekstate):
962 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
964 self.setSeekState(self.makeStateSlowMotion(speed))
966 self.setSeekState(self.SEEK_STATE_PAUSE)
968 def seekFwdManual(self):
969 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
971 def fwdSeekTo(self, minutes):
972 print "Seek", minutes, "minutes forward"
973 self.doSeekRelative(minutes * 60 * 90000)
975 def seekBackManual(self):
976 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
978 def rwdSeekTo(self, minutes):
980 self.doSeekRelative(-minutes * 60 * 90000)
982 def checkSkipShowHideLock(self):
983 wantlock = self.seekstate != self.SEEK_STATE_PLAY
985 if config.usage.show_infobar_on_skip.value:
986 if self.lockedBecauseOfSkipping and not wantlock:
988 self.lockedBecauseOfSkipping = False
990 if wantlock and not self.lockedBecauseOfSkipping:
992 self.lockedBecauseOfSkipping = True
994 def calcRemainingTime(self):
995 seekable = self.getSeek()
996 if seekable is not None:
997 len = seekable.getLength()
999 tmp = self.cueGetEndCutPosition()
1004 pos = seekable.getPlayPosition()
1005 speednom = self.seekstate[1] or 1
1006 speedden = self.seekstate[2] or 1
1007 if not len[0] and not pos[0]:
1008 if len[1] <= pos[1]:
1010 time = (len[1] - pos[1])*speedden/(90*speednom)
1015 if self.seekstate == self.SEEK_STATE_EOF:
1018 # if we are seeking forward, we try to end up ~1s before the end, and pause there.
1019 seekstate = self.seekstate
1020 if self.seekstate != self.SEEK_STATE_PAUSE:
1021 self.setSeekState(self.SEEK_STATE_EOF)
1023 if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
1024 seekable = self.getSeek()
1025 if seekable is not None:
1027 if seekstate == self.SEEK_STATE_PLAY: # regular EOF
1028 self.doEofInternal(True)
1030 self.doEofInternal(False)
1032 def doEofInternal(self, playing):
1033 pass # Defined in subclasses
1036 self.setSeekState(self.SEEK_STATE_PLAY)
1039 from Screens.PVRState import PVRState, TimeshiftState
1041 class InfoBarPVRState:
1042 def __init__(self, screen=PVRState, force_show = False):
1043 self.onPlayStateChanged.append(self.__playStateChanged)
1044 self.pvrStateDialog = self.session.instantiateDialog(screen)
1045 self.onShow.append(self._mayShow)
1046 self.onHide.append(self.pvrStateDialog.hide)
1047 self.force_show = force_show
1050 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1051 self.pvrStateDialog.show()
1053 def __playStateChanged(self, state):
1054 playstateString = state[3]
1055 self.pvrStateDialog["state"].setText(playstateString)
1057 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
1058 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
1059 self.pvrStateDialog.hide()
1064 class InfoBarTimeshiftState(InfoBarPVRState):
1066 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1069 if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
1070 self.pvrStateDialog.show()
1072 class InfoBarShowMovies:
1074 # i don't really like this class.
1075 # it calls a not further specified "movie list" on up/down/movieList,
1076 # so this is not more than an action map
1078 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1080 "movieList": (self.showMovies, _("movie list")),
1081 "up": (self.showMovies, _("movie list")),
1082 "down": (self.showMovies, _("movie list"))
1085 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1089 # Timeshift works the following way:
1090 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1091 # - normal playback TUNER unused PLAY enable disable disable
1092 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1093 # - user presess pause again FILE record PLAY enable disable enable
1094 # - user fast forwards FILE record FF enable disable enable
1095 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1096 # - user backwards FILE record BACK # !! enable disable enable
1100 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1101 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1102 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1103 # - the user can now PVR around
1104 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1105 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1107 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1108 # - if the user rewinds, or press pause, timeshift will be activated again
1110 # note that a timeshift can be enabled ("recording") and
1111 # activated (currently time-shifting).
1113 class InfoBarTimeshift:
1115 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1117 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1118 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1120 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1122 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1123 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1124 }, prio=-1) # priority over record
1126 self.timeshift_enabled = 0
1127 self.timeshift_state = 0
1128 self.ts_rewind_timer = eTimer()
1129 self.ts_rewind_timer.callback.append(self.rewindService)
1131 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1133 iPlayableService.evStart: self.__serviceStarted,
1134 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1137 def getTimeshift(self):
1138 service = self.session.nav.getCurrentService()
1139 return service and service.timeshift()
1141 def startTimeshift(self):
1142 print "enable timeshift"
1143 ts = self.getTimeshift()
1145 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1146 print "no ts interface"
1149 if self.timeshift_enabled:
1150 print "hu, timeshift already enabled?"
1152 if not ts.startTimeshift():
1153 self.timeshift_enabled = 1
1155 # we remove the "relative time" for now.
1156 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1159 #self.setSeekState(self.SEEK_STATE_PAUSE)
1160 self.activateTimeshiftEnd(False)
1162 # enable the "TimeshiftEnableActions", which will override
1163 # the startTimeshift actions
1164 self.__seekableStatusChanged()
1166 print "timeshift failed"
1168 def stopTimeshift(self):
1169 if not self.timeshift_enabled:
1171 print "disable timeshift"
1172 ts = self.getTimeshift()
1175 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1177 def stopTimeshiftConfirmed(self, confirmed):
1181 ts = self.getTimeshift()
1186 self.timeshift_enabled = 0
1189 self.__seekableStatusChanged()
1191 # activates timeshift, and seeks to (almost) the end
1192 def activateTimeshiftEnd(self, back = True):
1193 ts = self.getTimeshift()
1194 print "activateTimeshiftEnd"
1199 if ts.isTimeshiftActive():
1200 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1204 ts.activateTimeshift() # activate timeshift will automatically pause
1205 self.setSeekState(self.SEEK_STATE_PAUSE)
1208 self.doSeek(-5) # seek some gops before end
1209 self.ts_rewind_timer.start(200, 1)
1211 self.doSeek(-1) # seek 1 gop before end
1213 def rewindService(self):
1214 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1216 # same as activateTimeshiftEnd, but pauses afterwards.
1217 def activateTimeshiftEndAndPause(self):
1218 print "activateTimeshiftEndAndPause"
1219 #state = self.seekstate
1220 self.activateTimeshiftEnd(False)
1222 def __seekableStatusChanged(self):
1225 # print "self.isSeekable", self.isSeekable()
1226 # print "self.timeshift_enabled", self.timeshift_enabled
1228 # when this service is not seekable, but timeshift
1229 # is enabled, this means we can activate
1231 if not self.isSeekable() and self.timeshift_enabled:
1234 # print "timeshift activate:", enabled
1235 self["TimeshiftActivateActions"].setEnabled(enabled)
1237 def __serviceStarted(self):
1238 self.timeshift_enabled = False
1239 self.__seekableStatusChanged()
1241 from Screens.PiPSetup import PiPSetup
1243 class InfoBarExtensions:
1244 EXTENSION_SINGLE = 0
1250 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1252 "extensions": (self.showExtensionSelection, _("view extensions...")),
1253 }, 1) # lower priority
1255 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1256 self.list.append((type, extension, key))
1258 def updateExtension(self, extension, key = None):
1259 self.extensionsList.append(extension)
1261 if self.extensionKeys.has_key(key):
1265 for x in self.availableKeys:
1266 if not self.extensionKeys.has_key(x):
1271 self.extensionKeys[key] = len(self.extensionsList) - 1
1273 def updateExtensions(self):
1274 self.extensionsList = []
1275 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1276 self.extensionKeys = {}
1278 if x[0] == self.EXTENSION_SINGLE:
1279 self.updateExtension(x[1], x[2])
1282 self.updateExtension(y[0], y[1])
1285 def showExtensionSelection(self):
1286 self.updateExtensions()
1287 extensionsList = self.extensionsList[:]
1290 for x in self.availableKeys:
1291 if self.extensionKeys.has_key(x):
1292 entry = self.extensionKeys[x]
1293 extension = self.extensionsList[entry]
1295 name = str(extension[0]())
1296 list.append((extension[0](), extension))
1298 extensionsList.remove(extension)
1300 extensionsList.remove(extension)
1301 list.extend([(x[0](), x) for x in extensionsList])
1303 keys += [""] * len(extensionsList)
1304 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
1306 def extensionCallback(self, answer):
1307 if answer is not None:
1310 from Tools.BoundFunction import boundFunction
1312 # depends on InfoBarExtensions
1314 class InfoBarPlugins:
1316 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1318 def getPluginName(self, name):
1321 def getPluginList(self):
1322 list = [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
1323 list.sort(key = lambda e: e[2]) # sort by name
1326 def runPlugin(self, plugin):
1327 if isinstance(self, InfoBarChannelSelection):
1328 plugin(session = self.session, servicelist = self.servicelist)
1330 plugin(session = self.session)
1332 from Components.Task import job_manager
1333 class InfoBarJobman:
1335 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1337 def getJobList(self):
1338 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1340 def getJobName(self, job):
1341 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1343 def showJobView(self, job):
1344 from Screens.TaskView import JobView
1345 job_manager.in_background = False
1346 self.session.openWithCallback(self.JobViewCB, JobView, job)
1348 def JobViewCB(self, in_background):
1349 job_manager.in_background = in_background
1351 # depends on InfoBarExtensions
1352 class InfoBarSleepTimer:
1354 self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, lambda: True), "1")
1356 def getSleepTimerName(self):
1357 return _("Sleep Timer")
1359 def showSleepTimerSetup(self):
1360 self.session.open(SleepTimerEdit)
1362 # depends on InfoBarExtensions
1365 self.session.pipshown = False
1366 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1367 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1368 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1369 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1372 return self.session.pipshown
1374 def pipHandles0Action(self):
1375 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1377 def getShowHideName(self):
1378 if self.session.pipshown:
1379 return _("Disable Picture in Picture")
1381 return _("Activate Picture in Picture")
1383 def getSwapName(self):
1384 return _("Swap Services")
1386 def getMoveName(self):
1387 return _("Move Picture in Picture")
1390 if self.session.pipshown:
1391 del self.session.pip
1392 self.session.pipshown = False
1394 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1395 self.session.pip.show()
1396 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1397 if self.session.pip.playService(newservice):
1398 self.session.pipshown = True
1399 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1401 self.session.pipshown = False
1402 del self.session.pip
1403 self.session.nav.playService(newservice)
1406 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1407 if self.session.pip.servicePath:
1408 servicepath = self.servicelist.getCurrentServicePath()
1409 ref=servicepath[len(servicepath)-1]
1410 pipref=self.session.pip.getCurrentService()
1411 self.session.pip.playService(swapservice)
1412 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1413 if pipref.toString() != ref.toString(): # is a subservice ?
1414 self.session.nav.stopService() # stop portal
1415 self.session.nav.playService(pipref) # start subservice
1416 self.session.pip.servicePath=servicepath
1419 self.session.open(PiPSetup, pip = self.session.pip)
1421 def pipDoHandle0Action(self):
1422 use = config.usage.pip_zero_button.value
1425 elif "swapstop" == use:
1431 from RecordTimer import parseEvent, RecordTimerEntry
1433 class InfoBarInstantRecord:
1434 """Instant Record - handles the instantRecord action in order to
1435 start/stop instant records"""
1437 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1439 "instantRecord": (self.instantRecord, _("Instant Record...")),
1443 def stopCurrentRecording(self, entry = -1):
1444 if entry is not None and entry != -1:
1445 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1446 self.recording.remove(self.recording[entry])
1448 def startInstantRecording(self, limitEvent = False):
1449 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1451 # try to get event info
1454 service = self.session.nav.getCurrentService()
1455 epg = eEPGCache.getInstance()
1456 event = epg.lookupEventTime(serviceref, -1, 0)
1458 info = service.info()
1459 ev = info.getEvent(0)
1465 end = begin + 3600 # dummy
1466 name = "instant record"
1470 if event is not None:
1471 curEvent = parseEvent(event)
1473 description = curEvent[3]
1474 eventid = curEvent[4]
1479 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1481 if isinstance(serviceref, eServiceReference):
1482 serviceref = ServiceReference(serviceref)
1484 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
1485 recording.dontSave = True
1487 if event is None or limitEvent == False:
1488 recording.autoincrease = True
1489 if recording.setAutoincreaseEnd():
1490 self.session.nav.RecordTimer.record(recording)
1491 self.recording.append(recording)
1493 simulTimerList = self.session.nav.RecordTimer.record(recording)
1494 if simulTimerList is not None: # conflict with other recording
1495 name = simulTimerList[1].name
1496 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1497 print "[TIMER] conflicts with", name_date
1498 recording.autoincrease = True # start with max available length, then increment
1499 if recording.setAutoincreaseEnd():
1500 self.session.nav.RecordTimer.record(recording)
1501 self.recording.append(recording)
1502 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1504 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1505 recording.autoincrease = False
1507 self.recording.append(recording)
1509 def isInstantRecordRunning(self):
1510 print "self.recording:", self.recording
1512 for x in self.recording:
1517 def recordQuestionCallback(self, answer):
1518 print "pre:\n", self.recording
1520 if answer is None or answer[1] == "no":
1523 recording = self.recording[:]
1525 if not x in self.session.nav.RecordTimer.timer_list:
1526 self.recording.remove(x)
1527 elif x.dontSave and x.isRunning():
1528 list.append((x, False))
1530 if answer[1] == "changeduration":
1531 if len(self.recording) == 1:
1532 self.changeDuration(0)
1534 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1535 elif answer[1] == "changeendtime":
1536 if len(self.recording) == 1:
1539 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1540 elif answer[1] == "stop":
1541 if len(self.recording) == 1:
1542 self.stopCurrentRecording(0)
1544 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1545 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1546 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1547 if answer[1] == "manualduration":
1548 self.changeDuration(len(self.recording)-1)
1549 elif answer[1] == "manualendtime":
1550 self.setEndtime(len(self.recording)-1)
1551 print "after:\n", self.recording
1553 def setEndtime(self, entry):
1554 if entry is not None and entry >= 0:
1555 self.selectedEntry = entry
1556 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1557 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1558 dlg.setTitle(_("Please change recording endtime"))
1560 def TimeDateInputClosed(self, ret):
1563 localendtime = localtime(ret[1])
1564 print "stopping recording at", strftime("%c", localendtime)
1565 if self.recording[self.selectedEntry].end != ret[1]:
1566 self.recording[self.selectedEntry].autoincrease = False
1567 self.recording[self.selectedEntry].end = ret[1]
1568 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1570 def changeDuration(self, entry):
1571 if entry is not None and entry >= 0:
1572 self.selectedEntry = entry
1573 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1575 def inputCallback(self, value):
1576 if value is not None:
1577 print "stopping recording after", int(value), "minutes."
1578 entry = self.recording[self.selectedEntry]
1580 entry.autoincrease = False
1581 entry.end = int(time()) + 60 * int(value)
1582 self.session.nav.RecordTimer.timeChanged(entry)
1584 def instantRecord(self):
1585 dir = config.movielist.last_videodir.value
1586 if not fileExists(dir, 'w'):
1587 dir = resolveFilename(SCOPE_HDD)
1591 # XXX: this message is a little odd as we might be recording to a remote device
1592 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1595 if self.isInstantRecordRunning():
1596 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1597 title=_("A recording is currently running.\nWhat do you want to do?"), \
1598 list=((_("add recording (stop after current event)"), "event"), \
1599 (_("add recording (enter recording duration)"), "manualduration"), \
1600 (_("add recording (enter recording endtime)"), "manualendtime"), \
1601 (_("add recording (indefinitely)"), "indefinitely"), \
1602 (_("change recording (duration)"), "changeduration"), \
1603 (_("change recording (endtime)"), "changeendtime"), \
1604 (_("stop recording"), "stop"), \
1605 (_("do nothing"), "no")))
1607 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1608 title=_("Start recording?"), \
1609 list=((_("add recording (stop after current event)"), "event"), \
1610 (_("add recording (enter recording duration)"), "manualduration"), \
1611 (_("add recording (enter recording endtime)"), "manualendtime"), \
1612 (_("add recording (indefinitely)"), "indefinitely"), \
1613 (_("don't record"), "no")))
1615 from Tools.ISO639 import LanguageCodes
1617 class InfoBarAudioSelection:
1619 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1621 "audioSelection": (self.audioSelection, _("Audio Options...")),
1624 def audioSelection(self):
1625 service = self.session.nav.getCurrentService()
1626 self.audioTracks = audio = service and service.audioTracks()
1627 n = audio and audio.getNumberOfTracks() or 0
1630 self.audioChannel = service.audioChannel()
1635 i = audio.getTrackInfo(idx)
1636 languages = i.getLanguage().split('/')
1637 description = i.getDescription()
1640 for lang in languages:
1643 if LanguageCodes.has_key(lang):
1644 language += LanguageCodes[lang][0]
1649 if len(description):
1650 description += " (" + language + ")"
1652 description = language
1654 tlist.append((description, idx))
1657 tlist.sort(key=lambda x: x[0])
1659 selectedAudio = self.audioTracks.getCurrentTrack()
1664 if x[1] != selectedAudio:
1669 if SystemInfo["CanDownmixAC3"]:
1670 tlist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1671 ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"),
1673 keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1676 tlist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
1677 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1679 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys, skin_name = "AudioTrackSelection")
1681 del self.audioTracks
1683 def changeAC3Downmix(self, arg):
1684 choicelist = self.session.current_dialog["list"]
1685 list = choicelist.list
1687 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1688 _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
1689 choicelist.setList(list)
1690 if config.av.downmix_ac3.value:
1691 config.av.downmix_ac3.value = False
1693 config.av.downmix_ac3.value = True
1694 config.av.downmix_ac3.save()
1696 def audioSelected(self, audio):
1697 if audio is not None:
1698 if isinstance(audio[1], str):
1699 if audio[1] == "mode":
1700 keys = ["red", "green", "yellow"]
1701 selection = self.audioChannel.getCurrentChannel()
1702 tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
1703 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys, skin_name ="AudioModeSelection")
1705 del self.audioChannel
1706 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1707 self.audioTracks.selectTrack(audio[1])
1709 del self.audioChannel
1710 del self.audioTracks
1712 def modeSelected(self, mode):
1713 if mode is not None:
1714 self.audioChannel.selectChannel(mode[1])
1715 del self.audioChannel
1717 class InfoBarSubserviceSelection:
1719 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1721 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1724 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1726 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1727 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1729 self["SubserviceQuickzapAction"].setEnabled(False)
1731 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1733 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1738 def checkSubservicesAvail(self):
1739 service = self.session.nav.getCurrentService()
1740 subservices = service and service.subServices()
1741 if not subservices or subservices.getNumberOfSubservices() == 0:
1742 self["SubserviceQuickzapAction"].setEnabled(False)
1744 def nextSubservice(self):
1745 self.changeSubservice(+1)
1747 def prevSubservice(self):
1748 self.changeSubservice(-1)
1750 def changeSubservice(self, direction):
1751 service = self.session.nav.getCurrentService()
1752 subservices = service and service.subServices()
1753 n = subservices and subservices.getNumberOfSubservices()
1756 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1759 if subservices.getSubservice(idx).toString() == ref.toString():
1764 selection += direction
1769 newservice = subservices.getSubservice(selection)
1770 if newservice.valid():
1773 self.session.nav.playService(newservice, False)
1775 def subserviceSelection(self):
1776 service = self.session.nav.getCurrentService()
1777 subservices = service and service.subServices()
1778 self.bouquets = self.servicelist.getBouquetList()
1779 n = subservices and subservices.getNumberOfSubservices()
1782 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1786 i = subservices.getSubservice(idx)
1787 if i.toString() == ref.toString():
1789 tlist.append((i.getName(), i))
1792 if self.bouquets and len(self.bouquets):
1793 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1794 if config.usage.multibouquet.value:
1795 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1797 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1800 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1801 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1804 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
1806 def subserviceSelected(self, service):
1808 if not service is None:
1809 if isinstance(service[1], str):
1810 if service[1] == "quickzap":
1811 from Screens.SubservicesQuickzap import SubservicesQuickzap
1812 self.session.open(SubservicesQuickzap, service[2])
1814 self["SubserviceQuickzapAction"].setEnabled(True)
1815 self.session.nav.playService(service[1], False)
1817 def addSubserviceToBouquetCallback(self, service):
1818 if len(service) > 1 and isinstance(service[1], eServiceReference):
1819 self.selectedSubservice = service
1820 if self.bouquets is None:
1823 cnt = len(self.bouquets)
1824 if cnt > 1: # show bouquet list
1825 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1826 elif cnt == 1: # add to only one existing bouquet
1827 self.addSubserviceToBouquet(self.bouquets[0][1])
1828 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1830 def bouquetSelClosed(self, confirmed):
1832 del self.selectedSubservice
1834 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1836 def addSubserviceToBouquet(self, dest):
1837 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1839 self.bsel.close(True)
1841 del self.selectedSubservice
1843 class InfoBarAdditionalInfo:
1846 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1847 self["TimeshiftPossible"] = self["RecordingPossible"]
1848 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1849 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1850 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1851 self["ExtensionsAvailable"] = Boolean(fixed=1)
1853 class InfoBarNotifications:
1855 self.onExecBegin.append(self.checkNotifications)
1856 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1857 self.onClose.append(self.__removeNotification)
1859 def __removeNotification(self):
1860 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1862 def checkNotificationsIfExecing(self):
1864 self.checkNotifications()
1866 def checkNotifications(self):
1867 notifications = Notifications.notifications
1869 n = notifications[0]
1871 del notifications[0]
1874 if n[3].has_key("onSessionOpenCallback"):
1875 n[3]["onSessionOpenCallback"]()
1876 del n[3]["onSessionOpenCallback"]
1879 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1881 dlg = self.session.open(n[1], *n[2], **n[3])
1883 # remember that this notification is currently active
1885 Notifications.current_notifications.append(d)
1886 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1888 def __notificationClosed(self, d):
1889 Notifications.current_notifications.remove(d)
1891 class InfoBarServiceNotifications:
1893 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1895 iPlayableService.evEnd: self.serviceHasEnded
1898 def serviceHasEnded(self):
1899 print "service end!"
1902 self.setSeekState(self.SEEK_STATE_PLAY)
1906 class InfoBarCueSheetSupport:
1912 ENABLE_RESUME_SUPPORT = False
1914 def __init__(self, actionmap = "InfobarCueSheetActions"):
1915 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1917 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1918 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1919 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1923 self.is_closing = False
1924 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1926 iPlayableService.evStart: self.__serviceStarted,
1929 def __serviceStarted(self):
1932 print "new service started! trying to download cuts!"
1933 self.downloadCuesheet()
1935 if self.ENABLE_RESUME_SUPPORT:
1938 for (pts, what) in self.cut_list:
1939 if what == self.CUT_TYPE_LAST:
1942 if last is not None:
1943 self.resume_point = last
1944 if config.usage.on_movie_start.value == "ask":
1945 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1946 elif config.usage.on_movie_start.value == "resume":
1947 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1948 # TRANSLATORS: at the start of a movie, when the user has selected
1949 # TRANSLATORS: "Resume from last position" as start behavior.
1950 # TRANSLATORS: The purpose is to notify the user that the movie starts
1951 # TRANSLATORS: in the middle somewhere and not from the beginning.
1952 # TRANSLATORS: (Some translators seem to have interpreted it as a
1953 # TRANSLATORS: question or a choice, but it is a statement.)
1954 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1956 def playLastCB(self, answer):
1958 self.doSeek(self.resume_point)
1959 self.hideAfterResume()
1961 def hideAfterResume(self):
1962 if isinstance(self, InfoBarShowHide):
1965 def __getSeekable(self):
1966 service = self.session.nav.getCurrentService()
1969 return service.seek()
1971 def cueGetCurrentPosition(self):
1972 seek = self.__getSeekable()
1975 r = seek.getPlayPosition()
1980 def cueGetEndCutPosition(self):
1983 for cp in self.cut_list:
1984 if cp[1] == self.CUT_TYPE_OUT:
1988 elif cp[1] == self.CUT_TYPE_IN:
1992 def jumpPreviousNextMark(self, cmp, start=False):
1993 current_pos = self.cueGetCurrentPosition()
1994 if current_pos is None:
1996 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
1997 if mark is not None:
2005 def jumpPreviousMark(self):
2006 # we add 2 seconds, so if the play position is <2s after
2007 # the mark, the mark before will be used
2008 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
2010 def jumpNextMark(self):
2011 if not self.jumpPreviousNextMark(lambda x: x):
2014 def getNearestCutPoint(self, pts, cmp=abs, start=False):
2020 bestdiff = cmp(0 - pts)
2022 nearest = [0, False]
2023 for cp in self.cut_list:
2024 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
2026 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
2027 diff = cmp(cp[0] - pts)
2033 if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
2034 diff = cmp(cp[0] - pts)
2035 if diff >= 0 and (nearest is None or bestdiff > diff):
2040 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
2041 current_pos = self.cueGetCurrentPosition()
2042 if current_pos is None:
2043 print "not seekable"
2046 nearest_cutpoint = self.getNearestCutPoint(current_pos)
2048 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
2050 return nearest_cutpoint
2052 self.removeMark(nearest_cutpoint)
2053 elif not onlyremove and not onlyreturn:
2054 self.addMark((current_pos, self.CUT_TYPE_MARK))
2059 def addMark(self, point):
2060 insort(self.cut_list, point)
2061 self.uploadCuesheet()
2062 self.showAfterCuesheetOperation()
2064 def removeMark(self, point):
2065 self.cut_list.remove(point)
2066 self.uploadCuesheet()
2067 self.showAfterCuesheetOperation()
2069 def showAfterCuesheetOperation(self):
2070 if isinstance(self, InfoBarShowHide):
2073 def __getCuesheet(self):
2074 service = self.session.nav.getCurrentService()
2077 return service.cueSheet()
2079 def uploadCuesheet(self):
2080 cue = self.__getCuesheet()
2083 print "upload failed, no cuesheet interface"
2085 cue.setCutList(self.cut_list)
2087 def downloadCuesheet(self):
2088 cue = self.__getCuesheet()
2091 print "download failed, no cuesheet interface"
2094 self.cut_list = cue.getCutList()
2096 class InfoBarSummary(Screen):
2098 <screen position="0,0" size="132,64">
2099 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2100 <convert type="ClockToText">WithSeconds</convert>
2102 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2103 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2104 <convert type="ConditionalShowHide">Blink</convert>
2106 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2107 <convert type="ServiceName">Name</convert>
2109 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2110 <convert type="EventTime">Progress</convert>
2114 # for picon: (path="piconlcd" will use LCD picons)
2115 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2116 # <convert type="ServiceName">Reference</convert>
2119 class InfoBarSummarySupport:
2123 def createSummary(self):
2124 return InfoBarSummary
2126 class InfoBarMoviePlayerSummary(Screen):
2128 <screen position="0,0" size="132,64">
2129 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2130 <convert type="ClockToText">WithSeconds</convert>
2132 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2133 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2134 <convert type="ConditionalShowHide">Blink</convert>
2136 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2137 <convert type="ServiceName">Name</convert>
2139 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2140 <convert type="ServicePosition">Position</convert>
2144 class InfoBarMoviePlayerSummarySupport:
2148 def createSummary(self):
2149 return InfoBarMoviePlayerSummary
2151 class InfoBarTeletextPlugin:
2153 self.teletext_plugin = None
2155 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2156 self.teletext_plugin = p
2158 if self.teletext_plugin is not None:
2159 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2161 "startTeletext": (self.startTeletext, _("View teletext..."))
2164 print "no teletext plugin found!"
2166 def startTeletext(self):
2167 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2169 class InfoBarSubtitleSupport(object):
2171 object.__init__(self)
2172 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2173 self.__subtitles_enabled = False
2175 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2177 iPlayableService.evEnd: self.__serviceStopped,
2178 iPlayableService.evUpdatedInfo: self.__updatedInfo
2180 self.cached_subtitle_checked = False
2181 self.__selected_subtitle = None
2183 def __serviceStopped(self):
2184 self.cached_subtitle_checked = False
2185 if self.__subtitles_enabled:
2186 self.subtitle_window.hide()
2187 self.__subtitles_enabled = False
2188 self.__selected_subtitle = None
2190 def __updatedInfo(self):
2191 if not self.cached_subtitle_checked:
2192 self.cached_subtitle_checked = True
2193 subtitle = self.getCurrentServiceSubtitle()
2194 self.setSelectedSubtitle(subtitle and subtitle.getCachedSubtitle())
2195 if self.__selected_subtitle:
2196 self.setSubtitlesEnable(True)
2198 def getCurrentServiceSubtitle(self):
2199 service = self.session.nav.getCurrentService()
2200 return service and service.subtitle()
2202 def setSubtitlesEnable(self, enable=True):
2203 subtitle = self.getCurrentServiceSubtitle()
2205 if self.__selected_subtitle:
2206 if subtitle and not self.__subtitles_enabled:
2207 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2208 self.subtitle_window.show()
2209 self.__subtitles_enabled = True
2212 subtitle.disableSubtitles(self.subtitle_window.instance)
2213 self.__selected_subtitle = False
2214 self.__subtitles_enabled = False
2215 self.subtitle_window.hide()
2217 def setSelectedSubtitle(self, subtitle):
2218 self.__selected_subtitle = subtitle
2220 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2221 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2223 class InfoBarServiceErrorPopupSupport:
2225 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2227 iPlayableService.evTuneFailed: self.__tuneFailed,
2228 iPlayableService.evStart: self.__serviceStarted
2230 self.__serviceStarted()
2232 def __serviceStarted(self):
2233 self.last_error = None
2234 Notifications.RemovePopup(id = "ZapError")
2236 def __tuneFailed(self):
2237 service = self.session.nav.getCurrentService()
2238 info = service and service.info()
2239 error = info and info.getInfo(iServiceInformation.sDVBState)
2241 if error == self.last_error:
2244 self.last_error = error
2247 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2248 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2249 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2250 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2251 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2252 eDVBServicePMTHandler.eventNewProgramInfo: None,
2253 eDVBServicePMTHandler.eventTuned: None,
2254 eDVBServicePMTHandler.eventSOF: None,
2255 eDVBServicePMTHandler.eventEOF: None,
2256 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2257 }.get(error) #this returns None when the key not exist in the dict
2259 if error is not None:
2260 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2262 Notifications.RemovePopup(id = "ZapError")