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]
395 """ EPG - Opens an EPG list when the showEPGList action fires """
397 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
399 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
402 self.is_now_next = False
404 self.bouquetSel = None
405 self.eventView = None
406 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
408 "showEventInfo": (self.openEventView, _("show EPG...")),
409 "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
410 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
413 def showEventInfoWhenNotVisible(self):
420 def zapToService(self, service):
421 if not service is None:
422 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
423 self.servicelist.clearPath()
424 if self.servicelist.bouquet_root != self.epg_bouquet:
425 self.servicelist.enterPath(self.servicelist.bouquet_root)
426 self.servicelist.enterPath(self.epg_bouquet)
427 self.servicelist.setCurrentSelection(service) #select the service in servicelist
428 self.servicelist.zap()
430 def getBouquetServices(self, bouquet):
432 servicelist = eServiceCenter.getInstance().list(bouquet)
433 if not servicelist is None:
435 service = servicelist.getNext()
436 if not service.valid(): #check if end of list
438 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
440 services.append(ServiceReference(service))
443 def openBouquetEPG(self, bouquet, withCallback=True):
444 services = self.getBouquetServices(bouquet)
446 self.epg_bouquet = bouquet
448 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
450 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
452 def changeBouquetCB(self, direction, epg):
455 self.bouquetSel.down()
458 bouquet = self.bouquetSel.getCurrent()
459 services = self.getBouquetServices(bouquet)
461 self.epg_bouquet = bouquet
462 epg.setServices(services)
464 def closed(self, ret=False):
465 closedScreen = self.dlg_stack.pop()
466 if self.bouquetSel and closedScreen == self.bouquetSel:
467 self.bouquetSel = None
468 elif self.eventView and closedScreen == self.eventView:
469 self.eventView = None
471 dlgs=len(self.dlg_stack)
473 self.dlg_stack[dlgs-1].close(dlgs > 1)
475 def openMultiServiceEPG(self, withCallback=True):
476 bouquets = self.servicelist.getBouquetList()
481 if cnt > 1: # show bouquet list
483 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
484 self.dlg_stack.append(self.bouquetSel)
486 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
488 self.openBouquetEPG(bouquets[0][1], withCallback)
490 def openSingleServiceEPG(self):
491 ref=self.session.nav.getCurrentlyPlayingServiceReference()
492 self.session.open(EPGSelection, ref)
494 def showEventInfoPlugins(self):
495 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
498 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
499 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list)
501 self.openSingleServiceEPG()
503 def runPlugin(self, plugin):
504 plugin(session = self.session, servicelist = self.servicelist)
506 def EventInfoPluginChosen(self, answer):
507 if answer is not None:
510 def openSimilarList(self, eventid, refstr):
511 self.session.open(EPGSelection, refstr, None, eventid)
513 def getNowNext(self):
515 service = self.session.nav.getCurrentService()
516 info = service and service.info()
517 ptr = info and info.getEvent(0)
520 ptr = info and info.getEvent(1)
523 self.epglist = epglist
525 def __evEventInfoChanged(self):
526 if self.is_now_next and len(self.dlg_stack) == 1:
528 assert self.eventView
530 self.eventView.setEvent(self.epglist[0])
532 def openEventView(self):
533 ref = self.session.nav.getCurrentlyPlayingServiceReference()
535 epglist = self.epglist
537 self.is_now_next = False
538 epg = eEPGCache.getInstance()
539 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
542 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
546 self.is_now_next = True
548 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
549 self.dlg_stack.append(self.eventView)
551 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
552 self.openMultiServiceEPG(False)
554 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
555 epglist = self.epglist
558 epglist[0]=epglist[1]
562 class InfoBarRdsDecoder:
563 """provides RDS and Rass support/display"""
565 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
566 self.rass_interactive = None
568 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
570 iPlayableService.evEnd: self.__serviceStopped,
571 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
574 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
576 "startRassInteractive": self.startRassInteractive
579 self["RdsActions"].setEnabled(False)
581 self.onLayoutFinish.append(self.rds_display.show)
582 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
584 def RassInteractivePossibilityChanged(self, state):
585 self["RdsActions"].setEnabled(state)
587 def RassSlidePicChanged(self):
588 if not self.rass_interactive:
589 service = self.session.nav.getCurrentService()
590 decoder = service and service.rdsDecoder()
592 decoder.showRassSlidePicture()
594 def __serviceStopped(self):
595 if self.rass_interactive is not None:
596 rass_interactive = self.rass_interactive
597 self.rass_interactive = None
598 rass_interactive.close()
600 def startRassInteractive(self):
601 self.rds_display.hide()
602 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
604 def RassInteractiveClosed(self, *val):
605 if self.rass_interactive is not None:
606 self.rass_interactive = None
607 self.RassSlidePicChanged()
608 self.rds_display.show()
611 """handles actions like seeking, pause"""
613 SEEK_STATE_PLAY = (0, 0, 0, ">")
614 SEEK_STATE_PAUSE = (1, 0, 0, "||")
615 SEEK_STATE_EOF = (1, 0, 0, "END")
617 def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
618 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
620 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
621 iPlayableService.evStart: self.__serviceStarted,
623 iPlayableService.evEOF: self.__evEOF,
624 iPlayableService.evSOF: self.__evSOF,
627 self.minSpeedBackward = useSeekBackHack and 16 or 0
629 class InfoBarSeekActionMap(HelpableActionMap):
630 def __init__(self, screen, *args, **kwargs):
631 HelpableActionMap.__init__(self, screen, *args, **kwargs)
634 def action(self, contexts, action):
635 print "action:", action
636 if action[:5] == "seek:":
637 time = int(action[5:])
638 self.screen.doSeekRelative(time * 90000)
640 elif action[:8] == "seekdef:":
641 key = int(action[8:])
642 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
643 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
644 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
645 self.screen.doSeekRelative(time * 90000)
648 return HelpableActionMap.action(self, contexts, action)
650 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
652 "playpauseService": self.playpauseService,
653 "pauseService": (self.pauseService, _("pause")),
654 "unPauseService": (self.unPauseService, _("continue")),
656 "seekFwd": (self.seekFwd, _("skip forward")),
657 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
658 "seekBack": (self.seekBack, _("skip backward")),
659 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
661 # give them a little more priority to win over color buttons
663 self["SeekActions"].setEnabled(False)
665 self.seekstate = self.SEEK_STATE_PLAY
666 self.lastseekstate = self.SEEK_STATE_PLAY
668 self.onPlayStateChanged = [ ]
670 self.lockedBecauseOfSkipping = False
672 self.__seekableStatusChanged()
674 def makeStateForward(self, n):
675 minspeed = config.seek.stepwise_minspeed.value
676 repeat = int(config.seek.stepwise_repeat.value)
677 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
678 return (0, n * repeat, repeat, ">> %dx" % n)
680 return (0, n, 0, ">> %dx" % n)
682 def makeStateBackward(self, n):
683 minspeed = config.seek.stepwise_minspeed.value
684 repeat = int(config.seek.stepwise_repeat.value)
685 if self.minSpeedBackward and n < self.minSpeedBackward:
686 r = (self.minSpeedBackward - 1)/ n + 1
687 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
689 return (0, -n * r, r, "<< %dx" % n)
690 elif minspeed != "Never" and n >= int(minspeed) and repeat > 1:
691 return (0, -n * repeat, repeat, "<< %dx" % n)
693 return (0, -n, 0, "<< %dx" % n)
695 def makeStateSlowMotion(self, n):
696 return (0, 0, n, "/%d" % n)
698 def isStateForward(self, state):
701 def isStateBackward(self, state):
704 def isStateSlowMotion(self, state):
705 return state[1] == 0 and state[2] > 1
707 def getHigher(self, n, lst):
713 def getLower(self, n, lst):
721 def showAfterSeek(self):
722 if isinstance(self, InfoBarShowHide):
732 service = self.session.nav.getCurrentService()
736 seek = service.seek()
738 if seek is None or not seek.isCurrentlySeekable():
743 def isSeekable(self):
744 if self.getSeek() is None:
748 def __seekableStatusChanged(self):
749 # print "seekable status changed!"
750 if not self.isSeekable():
751 self["SeekActions"].setEnabled(False)
752 # print "not seekable, return to play"
753 self.setSeekState(self.SEEK_STATE_PLAY)
755 self["SeekActions"].setEnabled(True)
758 def __serviceStarted(self):
759 self.seekstate = self.SEEK_STATE_PLAY
760 self.__seekableStatusChanged()
762 def setSeekState(self, state):
763 service = self.session.nav.getCurrentService()
768 if not self.isSeekable():
769 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
770 state = self.SEEK_STATE_PLAY
772 pauseable = service.pause()
774 if pauseable is None:
775 print "not pauseable."
776 state = self.SEEK_STATE_PLAY
778 oldstate = self.seekstate
779 self.seekstate = state
782 if oldstate[i] != self.seekstate[i]:
783 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
785 for c in self.onPlayStateChanged:
788 self.checkSkipShowHideLock()
792 def playpauseService(self):
793 if self.seekstate != self.SEEK_STATE_PLAY:
794 self.unPauseService()
798 def pauseService(self):
799 if self.seekstate == self.SEEK_STATE_PAUSE:
800 if config.seek.on_pause.value == "play":
801 self.unPauseService()
802 elif config.seek.on_pause.value == "step":
803 self.doSeekRelative(0)
804 elif config.seek.on_pause.value == "last":
805 self.setSeekState(self.lastseekstate)
806 self.lastseekstate = self.SEEK_STATE_PLAY
808 if self.seekstate != self.SEEK_STATE_EOF:
809 self.lastseekstate = self.seekstate
810 self.setSeekState(self.SEEK_STATE_PAUSE);
812 def unPauseService(self):
814 if self.seekstate == self.SEEK_STATE_PLAY:
816 self.setSeekState(self.SEEK_STATE_PLAY)
818 def doSeek(self, pts):
819 seekable = self.getSeek()
824 def doSeekRelative(self, pts):
825 seekable = self.getSeek()
828 prevstate = self.seekstate
830 if self.seekstate == self.SEEK_STATE_EOF:
831 if prevstate == self.SEEK_STATE_PAUSE:
832 self.setSeekState(self.SEEK_STATE_PAUSE)
834 self.setSeekState(self.SEEK_STATE_PLAY)
835 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
836 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
840 if self.seekstate == self.SEEK_STATE_PLAY:
841 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
842 elif self.seekstate == self.SEEK_STATE_PAUSE:
843 if len(config.seek.speeds_slowmotion.value):
844 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
846 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
847 elif self.seekstate == self.SEEK_STATE_EOF:
849 elif self.isStateForward(self.seekstate):
850 speed = self.seekstate[1]
851 if self.seekstate[2]:
852 speed /= self.seekstate[2]
853 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
854 self.setSeekState(self.makeStateForward(speed))
855 elif self.isStateBackward(self.seekstate):
856 speed = -self.seekstate[1]
857 if self.seekstate[2]:
858 speed /= self.seekstate[2]
859 speed = self.getLower(speed, config.seek.speeds_backward.value)
861 self.setSeekState(self.makeStateBackward(speed))
863 self.setSeekState(self.SEEK_STATE_PLAY)
864 elif self.isStateSlowMotion(self.seekstate):
865 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
866 self.setSeekState(self.makeStateSlowMotion(speed))
869 seekstate = self.seekstate
870 if seekstate == self.SEEK_STATE_PLAY:
871 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
872 elif seekstate == self.SEEK_STATE_EOF:
873 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
874 self.doSeekRelative(-6)
875 elif seekstate == self.SEEK_STATE_PAUSE:
876 self.doSeekRelative(-3)
877 elif self.isStateForward(seekstate):
880 speed /= seekstate[2]
881 speed = self.getLower(speed, config.seek.speeds_forward.value)
883 self.setSeekState(self.makeStateForward(speed))
885 self.setSeekState(self.SEEK_STATE_PLAY)
886 elif self.isStateBackward(seekstate):
887 speed = -seekstate[1]
889 speed /= seekstate[2]
890 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
891 self.setSeekState(self.makeStateBackward(speed))
892 elif self.isStateSlowMotion(seekstate):
893 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
895 self.setSeekState(self.makeStateSlowMotion(speed))
897 self.setSeekState(self.SEEK_STATE_PAUSE)
899 def seekFwdManual(self):
900 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
902 def fwdSeekTo(self, minutes):
903 print "Seek", minutes, "minutes forward"
904 self.doSeekRelative(minutes * 60 * 90000)
906 def seekBackManual(self):
907 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
909 def rwdSeekTo(self, minutes):
911 self.doSeekRelative(-minutes * 60 * 90000)
913 def checkSkipShowHideLock(self):
914 wantlock = self.seekstate != self.SEEK_STATE_PLAY
916 if config.usage.show_infobar_on_skip.value:
917 if self.lockedBecauseOfSkipping and not wantlock:
919 self.lockedBecauseOfSkipping = False
921 if wantlock and not self.lockedBecauseOfSkipping:
923 self.lockedBecauseOfSkipping = True
925 def calcRemainingTime(self):
926 seekable = self.getSeek()
927 if seekable is not None:
928 len = seekable.getLength()
930 tmp = self.cueGetEndCutPosition()
935 pos = seekable.getPlayPosition()
936 speednom = self.seekstate[1] or 1
937 speedden = self.seekstate[2] or 1
938 if not len[0] and not pos[0]:
941 time = (len[1] - pos[1])*speedden/(90*speednom)
946 if self.seekstate == self.SEEK_STATE_EOF:
949 # if we are seeking forward, we try to end up ~1s before the end, and pause there.
950 seekstate = self.seekstate
951 if self.seekstate != self.SEEK_STATE_PAUSE:
952 self.setSeekState(self.SEEK_STATE_EOF)
954 if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
955 seekable = self.getSeek()
956 if seekable is not None:
958 if seekstate == self.SEEK_STATE_PLAY: # regular EOF
959 self.doEofInternal(True)
961 self.doEofInternal(False)
963 def doEofInternal(self, playing):
964 pass # Defined in subclasses
967 self.setSeekState(self.SEEK_STATE_PLAY)
970 from Screens.PVRState import PVRState, TimeshiftState
972 class InfoBarPVRState:
973 def __init__(self, screen=PVRState, force_show = False):
974 self.onPlayStateChanged.append(self.__playStateChanged)
975 self.pvrStateDialog = self.session.instantiateDialog(screen)
976 self.onShow.append(self._mayShow)
977 self.onHide.append(self.pvrStateDialog.hide)
978 self.force_show = force_show
981 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
982 self.pvrStateDialog.show()
984 def __playStateChanged(self, state):
985 playstateString = state[3]
986 self.pvrStateDialog["state"].setText(playstateString)
988 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
989 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
990 self.pvrStateDialog.hide()
995 class InfoBarTimeshiftState(InfoBarPVRState):
997 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1000 if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
1001 self.pvrStateDialog.show()
1003 class InfoBarShowMovies:
1005 # i don't really like this class.
1006 # it calls a not further specified "movie list" on up/down/movieList,
1007 # so this is not more than an action map
1009 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1011 "movieList": (self.showMovies, _("movie list")),
1012 "up": (self.showMovies, _("movie list")),
1013 "down": (self.showMovies, _("movie list"))
1016 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1020 # Timeshift works the following way:
1021 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1022 # - normal playback TUNER unused PLAY enable disable disable
1023 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1024 # - user presess pause again FILE record PLAY enable disable enable
1025 # - user fast forwards FILE record FF enable disable enable
1026 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1027 # - user backwards FILE record BACK # !! enable disable enable
1031 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1032 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1033 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1034 # - the user can now PVR around
1035 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1036 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1038 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1039 # - if the user rewinds, or press pause, timeshift will be activated again
1041 # note that a timeshift can be enabled ("recording") and
1042 # activated (currently time-shifting).
1044 class InfoBarTimeshift:
1046 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1048 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1049 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1051 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1053 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1054 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1055 }, prio=-1) # priority over record
1057 self.timeshift_enabled = 0
1058 self.timeshift_state = 0
1059 self.ts_rewind_timer = eTimer()
1060 self.ts_rewind_timer.callback.append(self.rewindService)
1062 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1064 iPlayableService.evStart: self.__serviceStarted,
1065 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1068 def getTimeshift(self):
1069 service = self.session.nav.getCurrentService()
1070 return service and service.timeshift()
1072 def startTimeshift(self):
1073 print "enable timeshift"
1074 ts = self.getTimeshift()
1076 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1077 print "no ts interface"
1080 if self.timeshift_enabled:
1081 print "hu, timeshift already enabled?"
1083 if not ts.startTimeshift():
1084 self.timeshift_enabled = 1
1086 # we remove the "relative time" for now.
1087 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1090 #self.setSeekState(self.SEEK_STATE_PAUSE)
1091 self.activateTimeshiftEnd(False)
1093 # enable the "TimeshiftEnableActions", which will override
1094 # the startTimeshift actions
1095 self.__seekableStatusChanged()
1097 print "timeshift failed"
1099 def stopTimeshift(self):
1100 if not self.timeshift_enabled:
1102 print "disable timeshift"
1103 ts = self.getTimeshift()
1106 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1108 def stopTimeshiftConfirmed(self, confirmed):
1112 ts = self.getTimeshift()
1117 self.timeshift_enabled = 0
1120 self.__seekableStatusChanged()
1122 # activates timeshift, and seeks to (almost) the end
1123 def activateTimeshiftEnd(self, back = True):
1124 ts = self.getTimeshift()
1125 print "activateTimeshiftEnd"
1130 if ts.isTimeshiftActive():
1131 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1135 ts.activateTimeshift() # activate timeshift will automatically pause
1136 self.setSeekState(self.SEEK_STATE_PAUSE)
1139 self.doSeek(-5) # seek some gops before end
1140 self.ts_rewind_timer.start(200, 1)
1142 self.doSeek(-1) # seek 1 gop before end
1144 def rewindService(self):
1145 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1147 # same as activateTimeshiftEnd, but pauses afterwards.
1148 def activateTimeshiftEndAndPause(self):
1149 print "activateTimeshiftEndAndPause"
1150 #state = self.seekstate
1151 self.activateTimeshiftEnd(False)
1153 def __seekableStatusChanged(self):
1156 # print "self.isSeekable", self.isSeekable()
1157 # print "self.timeshift_enabled", self.timeshift_enabled
1159 # when this service is not seekable, but timeshift
1160 # is enabled, this means we can activate
1162 if not self.isSeekable() and self.timeshift_enabled:
1165 # print "timeshift activate:", enabled
1166 self["TimeshiftActivateActions"].setEnabled(enabled)
1168 def __serviceStarted(self):
1169 self.timeshift_enabled = False
1170 self.__seekableStatusChanged()
1172 from Screens.PiPSetup import PiPSetup
1174 class InfoBarExtensions:
1175 EXTENSION_SINGLE = 0
1181 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1183 "extensions": (self.showExtensionSelection, _("view extensions...")),
1184 }, 1) # lower priority
1186 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1187 self.list.append((type, extension, key))
1189 def updateExtension(self, extension, key = None):
1190 self.extensionsList.append(extension)
1192 if self.extensionKeys.has_key(key):
1196 for x in self.availableKeys:
1197 if not self.extensionKeys.has_key(x):
1202 self.extensionKeys[key] = len(self.extensionsList) - 1
1204 def updateExtensions(self):
1205 self.extensionsList = []
1206 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1207 self.extensionKeys = {}
1209 if x[0] == self.EXTENSION_SINGLE:
1210 self.updateExtension(x[1], x[2])
1213 self.updateExtension(y[0], y[1])
1216 def showExtensionSelection(self):
1217 self.updateExtensions()
1218 extensionsList = self.extensionsList[:]
1221 for x in self.availableKeys:
1222 if self.extensionKeys.has_key(x):
1223 entry = self.extensionKeys[x]
1224 extension = self.extensionsList[entry]
1226 name = str(extension[0]())
1227 list.append((extension[0](), extension))
1229 extensionsList.remove(extension)
1231 extensionsList.remove(extension)
1232 list.extend([(x[0](), x) for x in extensionsList])
1234 keys += [""] * len(extensionsList)
1235 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
1237 def extensionCallback(self, answer):
1238 if answer is not None:
1241 from Tools.BoundFunction import boundFunction
1243 # depends on InfoBarExtensions
1245 class InfoBarPlugins:
1247 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1249 def getPluginName(self, name):
1252 def getPluginList(self):
1253 return [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
1255 def runPlugin(self, plugin):
1256 if isinstance(self, InfoBarChannelSelection):
1257 plugin(session = self.session, servicelist = self.servicelist)
1259 plugin(session = self.session)
1261 from Components.Task import job_manager
1262 class InfoBarJobman:
1264 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1266 def getJobList(self):
1267 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1269 def getJobName(self, job):
1270 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1272 def showJobView(self, job):
1273 from Screens.TaskView import JobView
1274 job_manager.in_background = False
1275 self.session.openWithCallback(self.JobViewCB, JobView, job)
1277 def JobViewCB(self, in_background):
1278 job_manager.in_background = in_background
1280 # depends on InfoBarExtensions
1281 class InfoBarSleepTimer:
1283 self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, lambda: True), "1")
1285 def getSleepTimerName(self):
1286 return _("Sleep Timer")
1288 def showSleepTimerSetup(self):
1289 self.session.open(SleepTimerEdit)
1291 # depends on InfoBarExtensions
1294 self.session.pipshown = False
1295 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1296 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1297 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1298 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1301 return self.session.pipshown
1303 def pipHandles0Action(self):
1304 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1306 def getShowHideName(self):
1307 if self.session.pipshown:
1308 return _("Disable Picture in Picture")
1310 return _("Activate Picture in Picture")
1312 def getSwapName(self):
1313 return _("Swap Services")
1315 def getMoveName(self):
1316 return _("Move Picture in Picture")
1319 if self.session.pipshown:
1320 del self.session.pip
1321 self.session.pipshown = False
1323 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1324 self.session.pip.show()
1325 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1326 if self.session.pip.playService(newservice):
1327 self.session.pipshown = True
1328 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1330 self.session.pipshown = False
1331 del self.session.pip
1332 self.session.nav.playService(newservice)
1335 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1336 if self.session.pip.servicePath:
1337 servicepath = self.servicelist.getCurrentServicePath()
1338 ref=servicepath[len(servicepath)-1]
1339 pipref=self.session.pip.getCurrentService()
1340 self.session.pip.playService(swapservice)
1341 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1342 if pipref.toString() != ref.toString(): # is a subservice ?
1343 self.session.nav.stopService() # stop portal
1344 self.session.nav.playService(pipref) # start subservice
1345 self.session.pip.servicePath=servicepath
1348 self.session.open(PiPSetup, pip = self.session.pip)
1350 def pipDoHandle0Action(self):
1351 use = config.usage.pip_zero_button.value
1354 elif "swapstop" == use:
1360 from RecordTimer import parseEvent, RecordTimerEntry
1362 class InfoBarInstantRecord:
1363 """Instant Record - handles the instantRecord action in order to
1364 start/stop instant records"""
1366 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1368 "instantRecord": (self.instantRecord, _("Instant Record...")),
1372 def stopCurrentRecording(self, entry = -1):
1373 if entry is not None and entry != -1:
1374 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1375 self.recording.remove(self.recording[entry])
1377 def startInstantRecording(self, limitEvent = False):
1378 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1380 # try to get event info
1383 service = self.session.nav.getCurrentService()
1384 epg = eEPGCache.getInstance()
1385 event = epg.lookupEventTime(serviceref, -1, 0)
1387 info = service.info()
1388 ev = info.getEvent(0)
1394 end = begin + 3600 # dummy
1395 name = "instant record"
1399 if event is not None:
1400 curEvent = parseEvent(event)
1402 description = curEvent[3]
1403 eventid = curEvent[4]
1408 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1410 if isinstance(serviceref, eServiceReference):
1411 serviceref = ServiceReference(serviceref)
1413 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
1414 recording.dontSave = True
1416 if event is None or limitEvent == False:
1417 recording.autoincrease = True
1418 if recording.setAutoincreaseEnd():
1419 self.session.nav.RecordTimer.record(recording)
1420 self.recording.append(recording)
1422 simulTimerList = self.session.nav.RecordTimer.record(recording)
1423 if simulTimerList is not None: # conflict with other recording
1424 name = simulTimerList[1].name
1425 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1426 print "[TIMER] conflicts with", name_date
1427 recording.autoincrease = True # start with max available length, then increment
1428 if recording.setAutoincreaseEnd():
1429 self.session.nav.RecordTimer.record(recording)
1430 self.recording.append(recording)
1431 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1433 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1434 recording.autoincrease = False
1436 self.recording.append(recording)
1438 def isInstantRecordRunning(self):
1439 print "self.recording:", self.recording
1441 for x in self.recording:
1446 def recordQuestionCallback(self, answer):
1447 print "pre:\n", self.recording
1449 if answer is None or answer[1] == "no":
1452 recording = self.recording[:]
1454 if not x in self.session.nav.RecordTimer.timer_list:
1455 self.recording.remove(x)
1456 elif x.dontSave and x.isRunning():
1457 list.append((x, False))
1459 if answer[1] == "changeduration":
1460 if len(self.recording) == 1:
1461 self.changeDuration(0)
1463 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1464 elif answer[1] == "changeendtime":
1465 if len(self.recording) == 1:
1468 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1469 elif answer[1] == "stop":
1470 if len(self.recording) == 1:
1471 self.stopCurrentRecording(0)
1473 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1474 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1475 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1476 if answer[1] == "manualduration":
1477 self.changeDuration(len(self.recording)-1)
1478 elif answer[1] == "manualendtime":
1479 self.setEndtime(len(self.recording)-1)
1480 print "after:\n", self.recording
1482 def setEndtime(self, entry):
1483 if entry is not None:
1484 self.selectedEntry = entry
1485 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1486 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1487 dlg.setTitle(_("Please change recording endtime"))
1489 def TimeDateInputClosed(self, ret):
1492 localendtime = localtime(ret[1])
1493 print "stopping recording at", strftime("%c", localendtime)
1494 if self.recording[self.selectedEntry].end != ret[1]:
1495 self.recording[self.selectedEntry].autoincrease = False
1496 self.recording[self.selectedEntry].end = ret[1]
1497 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1499 def changeDuration(self, entry):
1500 if entry is not None:
1501 self.selectedEntry = entry
1502 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1504 def inputCallback(self, value):
1505 if value is not None:
1506 print "stopping recording after", int(value), "minutes."
1507 entry = self.recording[self.selectedEntry]
1509 entry.autoincrease = False
1510 entry.end = int(time()) + 60 * int(value)
1511 self.session.nav.RecordTimer.timeChanged(entry)
1513 def instantRecord(self):
1514 dir = config.movielist.last_videodir.value
1515 if not fileExists(dir, 'w'):
1516 dir = resolveFilename(SCOPE_HDD)
1520 # XXX: this message is a little odd as we might be recording to a remote device
1521 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1524 if self.isInstantRecordRunning():
1525 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1526 title=_("A recording is currently running.\nWhat do you want to do?"), \
1527 list=((_("add recording (stop after current event)"), "event"), \
1528 (_("add recording (enter recording duration)"), "manualduration"), \
1529 (_("add recording (enter recording endtime)"), "manualendtime"), \
1530 (_("add recording (indefinitely)"), "indefinitely"), \
1531 (_("change recording (duration)"), "changeduration"), \
1532 (_("change recording (endtime)"), "changeendtime"), \
1533 (_("stop recording"), "stop"), \
1534 (_("do nothing"), "no")))
1536 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1537 title=_("Start recording?"), \
1538 list=((_("add recording (stop after current event)"), "event"), \
1539 (_("add recording (enter recording duration)"), "manualduration"), \
1540 (_("add recording (enter recording endtime)"), "manualendtime"), \
1541 (_("add recording (indefinitely)"), "indefinitely"), \
1542 (_("don't record"), "no")))
1544 from Tools.ISO639 import LanguageCodes
1546 class InfoBarAudioSelection:
1548 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1550 "audioSelection": (self.audioSelection, _("Audio Options...")),
1553 def audioSelection(self):
1554 service = self.session.nav.getCurrentService()
1555 self.audioTracks = audio = service and service.audioTracks()
1556 n = audio and audio.getNumberOfTracks() or 0
1559 self.audioChannel = service.audioChannel()
1563 i = audio.getTrackInfo(idx)
1564 language = i.getLanguage()
1565 description = i.getDescription()
1567 if LanguageCodes.has_key(language):
1568 language = LanguageCodes[language][0]
1570 if len(description):
1571 description += " (" + language + ")"
1573 description = language
1575 tlist.append((description, idx))
1578 tlist.sort(key=lambda x: x[0])
1580 selectedAudio = self.audioTracks.getCurrentTrack()
1585 if x[1] != selectedAudio:
1590 if SystemInfo["CanDownmixAC3"]:
1591 tlist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1592 ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"),
1594 keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1597 tlist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
1598 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1600 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
1602 del self.audioTracks
1604 def changeAC3Downmix(self, arg):
1605 choicelist = self.session.current_dialog["list"]
1606 list = choicelist.list
1608 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1609 _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
1610 choicelist.setList(list)
1611 if config.av.downmix_ac3.value:
1612 config.av.downmix_ac3.value = False
1614 config.av.downmix_ac3.value = True
1615 config.av.downmix_ac3.save()
1617 def audioSelected(self, audio):
1618 if audio is not None:
1619 if isinstance(audio[1], str):
1620 if audio[1] == "mode":
1621 keys = ["red", "green", "yellow"]
1622 selection = self.audioChannel.getCurrentChannel()
1623 tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
1624 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
1626 del self.audioChannel
1627 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1628 self.audioTracks.selectTrack(audio[1])
1630 del self.audioChannel
1631 del self.audioTracks
1633 def modeSelected(self, mode):
1634 if mode is not None:
1635 self.audioChannel.selectChannel(mode[1])
1636 del self.audioChannel
1638 class InfoBarSubserviceSelection:
1640 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1642 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1645 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1647 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1648 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1650 self["SubserviceQuickzapAction"].setEnabled(False)
1652 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1654 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1659 def checkSubservicesAvail(self):
1660 service = self.session.nav.getCurrentService()
1661 subservices = service and service.subServices()
1662 if not subservices or subservices.getNumberOfSubservices() == 0:
1663 self["SubserviceQuickzapAction"].setEnabled(False)
1665 def nextSubservice(self):
1666 self.changeSubservice(+1)
1668 def prevSubservice(self):
1669 self.changeSubservice(-1)
1671 def changeSubservice(self, direction):
1672 service = self.session.nav.getCurrentService()
1673 subservices = service and service.subServices()
1674 n = subservices and subservices.getNumberOfSubservices()
1677 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1680 if subservices.getSubservice(idx).toString() == ref.toString():
1685 selection += direction
1690 newservice = subservices.getSubservice(selection)
1691 if newservice.valid():
1694 self.session.nav.playService(newservice, False)
1696 def subserviceSelection(self):
1697 service = self.session.nav.getCurrentService()
1698 subservices = service and service.subServices()
1699 self.bouquets = self.servicelist.getBouquetList()
1700 n = subservices and subservices.getNumberOfSubservices()
1703 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1707 i = subservices.getSubservice(idx)
1708 if i.toString() == ref.toString():
1710 tlist.append((i.getName(), i))
1713 if self.bouquets and len(self.bouquets):
1714 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1715 if config.usage.multibouquet.value:
1716 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1718 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1721 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1722 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1725 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys)
1727 def subserviceSelected(self, service):
1729 if not service is None:
1730 if isinstance(service[1], str):
1731 if service[1] == "quickzap":
1732 from Screens.SubservicesQuickzap import SubservicesQuickzap
1733 self.session.open(SubservicesQuickzap, service[2])
1735 self["SubserviceQuickzapAction"].setEnabled(True)
1736 self.session.nav.playService(service[1], False)
1738 def addSubserviceToBouquetCallback(self, service):
1739 if len(service) > 1 and isinstance(service[1], eServiceReference):
1740 self.selectedSubservice = service
1741 if self.bouquets is None:
1744 cnt = len(self.bouquets)
1745 if cnt > 1: # show bouquet list
1746 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1747 elif cnt == 1: # add to only one existing bouquet
1748 self.addSubserviceToBouquet(self.bouquets[0][1])
1749 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1751 def bouquetSelClosed(self, confirmed):
1753 del self.selectedSubservice
1755 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1757 def addSubserviceToBouquet(self, dest):
1758 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1760 self.bsel.close(True)
1762 del self.selectedSubservice
1764 class InfoBarAdditionalInfo:
1767 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1768 self["TimeshiftPossible"] = self["RecordingPossible"]
1769 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1770 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1771 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1772 self["ExtensionsAvailable"] = Boolean(fixed=1)
1774 class InfoBarNotifications:
1776 self.onExecBegin.append(self.checkNotifications)
1777 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1778 self.onClose.append(self.__removeNotification)
1780 def __removeNotification(self):
1781 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1783 def checkNotificationsIfExecing(self):
1785 self.checkNotifications()
1787 def checkNotifications(self):
1788 notifications = Notifications.notifications
1790 n = notifications[0]
1792 del notifications[0]
1795 if n[3].has_key("onSessionOpenCallback"):
1796 n[3]["onSessionOpenCallback"]()
1797 del n[3]["onSessionOpenCallback"]
1800 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1802 dlg = self.session.open(n[1], *n[2], **n[3])
1804 # remember that this notification is currently active
1806 Notifications.current_notifications.append(d)
1807 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1809 def __notificationClosed(self, d):
1810 Notifications.current_notifications.remove(d)
1812 class InfoBarServiceNotifications:
1814 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1816 iPlayableService.evEnd: self.serviceHasEnded
1819 def serviceHasEnded(self):
1820 print "service end!"
1823 self.setSeekState(self.SEEK_STATE_PLAY)
1827 class InfoBarCueSheetSupport:
1833 ENABLE_RESUME_SUPPORT = False
1835 def __init__(self, actionmap = "InfobarCueSheetActions"):
1836 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1838 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1839 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1840 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1844 self.is_closing = False
1845 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1847 iPlayableService.evStart: self.__serviceStarted,
1850 def __serviceStarted(self):
1853 print "new service started! trying to download cuts!"
1854 self.downloadCuesheet()
1856 if self.ENABLE_RESUME_SUPPORT:
1859 for (pts, what) in self.cut_list:
1860 if what == self.CUT_TYPE_LAST:
1863 if last is not None:
1864 self.resume_point = last
1865 if config.usage.on_movie_start.value == "ask":
1866 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1867 elif config.usage.on_movie_start.value == "resume":
1868 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1869 # TRANSLATORS: at the start of a movie, when the user has selected
1870 # TRANSLATORS: "Resume from last position" as start behavior.
1871 # TRANSLATORS: The purpose is to notify the user that the movie starts
1872 # TRANSLATORS: in the middle somewhere and not from the beginning.
1873 # TRANSLATORS: (Some translators seem to have interpreted it as a
1874 # TRANSLATORS: question or a choice, but it is a statement.)
1875 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1877 def playLastCB(self, answer):
1879 self.doSeek(self.resume_point)
1880 self.hideAfterResume()
1882 def hideAfterResume(self):
1883 if isinstance(self, InfoBarShowHide):
1886 def __getSeekable(self):
1887 service = self.session.nav.getCurrentService()
1890 return service.seek()
1892 def cueGetCurrentPosition(self):
1893 seek = self.__getSeekable()
1896 r = seek.getPlayPosition()
1901 def cueGetEndCutPosition(self):
1904 for cp in self.cut_list:
1905 if cp[1] == self.CUT_TYPE_OUT:
1909 elif cp[1] == self.CUT_TYPE_IN:
1913 def jumpPreviousNextMark(self, cmp, start=False):
1914 current_pos = self.cueGetCurrentPosition()
1915 if current_pos is None:
1917 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
1918 if mark is not None:
1926 def jumpPreviousMark(self):
1927 # we add 2 seconds, so if the play position is <2s after
1928 # the mark, the mark before will be used
1929 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
1931 def jumpNextMark(self):
1932 if not self.jumpPreviousNextMark(lambda x: x):
1935 def getNearestCutPoint(self, pts, cmp=abs, start=False):
1941 bestdiff = cmp(0 - pts)
1943 nearest = [0, False]
1944 for cp in self.cut_list:
1945 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
1947 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
1948 diff = cmp(cp[0] - pts)
1954 if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
1955 diff = cmp(cp[0] - pts)
1956 if diff >= 0 and (nearest is None or bestdiff > diff):
1961 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
1962 current_pos = self.cueGetCurrentPosition()
1963 if current_pos is None:
1964 print "not seekable"
1967 nearest_cutpoint = self.getNearestCutPoint(current_pos)
1969 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
1971 return nearest_cutpoint
1973 self.removeMark(nearest_cutpoint)
1974 elif not onlyremove and not onlyreturn:
1975 self.addMark((current_pos, self.CUT_TYPE_MARK))
1980 def addMark(self, point):
1981 insort(self.cut_list, point)
1982 self.uploadCuesheet()
1983 self.showAfterCuesheetOperation()
1985 def removeMark(self, point):
1986 self.cut_list.remove(point)
1987 self.uploadCuesheet()
1988 self.showAfterCuesheetOperation()
1990 def showAfterCuesheetOperation(self):
1991 if isinstance(self, InfoBarShowHide):
1994 def __getCuesheet(self):
1995 service = self.session.nav.getCurrentService()
1998 return service.cueSheet()
2000 def uploadCuesheet(self):
2001 cue = self.__getCuesheet()
2004 print "upload failed, no cuesheet interface"
2006 cue.setCutList(self.cut_list)
2008 def downloadCuesheet(self):
2009 cue = self.__getCuesheet()
2012 print "download failed, no cuesheet interface"
2015 self.cut_list = cue.getCutList()
2017 class InfoBarSummary(Screen):
2019 <screen position="0,0" size="132,64">
2020 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2021 <convert type="ClockToText">WithSeconds</convert>
2023 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2024 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2025 <convert type="ConditionalShowHide">Blink</convert>
2027 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2028 <convert type="ServiceName">Name</convert>
2030 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2031 <convert type="EventTime">Progress</convert>
2035 # for picon: (path="piconlcd" will use LCD picons)
2036 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2037 # <convert type="ServiceName">Reference</convert>
2040 class InfoBarSummarySupport:
2044 def createSummary(self):
2045 return InfoBarSummary
2047 class InfoBarMoviePlayerSummary(Screen):
2049 <screen position="0,0" size="132,64">
2050 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2051 <convert type="ClockToText">WithSeconds</convert>
2053 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2054 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2055 <convert type="ConditionalShowHide">Blink</convert>
2057 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2058 <convert type="ServiceName">Name</convert>
2060 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2061 <convert type="ServicePosition">Position</convert>
2065 class InfoBarMoviePlayerSummarySupport:
2069 def createSummary(self):
2070 return InfoBarMoviePlayerSummary
2072 class InfoBarTeletextPlugin:
2074 self.teletext_plugin = None
2076 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2077 self.teletext_plugin = p
2079 if self.teletext_plugin is not None:
2080 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2082 "startTeletext": (self.startTeletext, _("View teletext..."))
2085 print "no teletext plugin found!"
2087 def startTeletext(self):
2088 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2090 class InfoBarSubtitleSupport(object):
2092 object.__init__(self)
2093 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2094 self.__subtitles_enabled = False
2096 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2098 iPlayableService.evEnd: self.__serviceStopped,
2099 iPlayableService.evUpdatedInfo: self.__updatedInfo
2101 self.cached_subtitle_checked = False
2102 self.__selected_subtitle = None
2104 def __serviceStopped(self):
2105 self.subtitle_window.hide()
2106 self.__subtitles_enabled = False
2107 self.cached_subtitle_checked = False
2109 def __updatedInfo(self):
2110 if not self.cached_subtitle_checked:
2111 subtitle = self.getCurrentServiceSubtitle()
2112 self.cached_subtitle_checked = True
2113 self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()
2114 if self.__selected_subtitle:
2115 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2116 self.subtitle_window.show()
2117 self.__subtitles_enabled = True
2119 def getCurrentServiceSubtitle(self):
2120 service = self.session.nav.getCurrentService()
2121 return service and service.subtitle()
2123 def setSubtitlesEnable(self, enable=True):
2124 subtitle = self.getCurrentServiceSubtitle()
2125 if enable and self.__selected_subtitle is not None:
2126 if subtitle and not self.__subtitles_enabled:
2127 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2128 self.subtitle_window.show()
2129 self.__subtitles_enabled = True
2132 subtitle.disableSubtitles(self.subtitle_window.instance)
2133 self.__subtitles_enabled = False
2134 self.subtitle_window.hide()
2136 def setSelectedSubtitle(self, subtitle):
2137 self.__selected_subtitle = subtitle
2139 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2140 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2142 class InfoBarServiceErrorPopupSupport:
2144 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2146 iPlayableService.evTuneFailed: self.__tuneFailed,
2147 iPlayableService.evStart: self.__serviceStarted
2149 self.__serviceStarted()
2151 def __serviceStarted(self):
2152 self.last_error = None
2153 Notifications.RemovePopup(id = "ZapError")
2155 def __tuneFailed(self):
2156 service = self.session.nav.getCurrentService()
2157 info = service and service.info()
2158 error = info and info.getInfo(iServiceInformation.sDVBState)
2160 if error == self.last_error:
2163 self.last_error = error
2166 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2167 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2168 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2169 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2170 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2171 eDVBServicePMTHandler.eventNewProgramInfo: None,
2172 eDVBServicePMTHandler.eventTuned: None,
2173 eDVBServicePMTHandler.eventSOF: None,
2174 eDVBServicePMTHandler.eventEOF: None,
2175 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2176 }.get(error) #this returns None when the key not exist in the dict
2178 if error is not None:
2179 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2181 Notifications.RemovePopup(id = "ZapError")