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):
405 while self.services[self.current].ref != service:
408 def nextService(self):
411 if self.current+1 < self.length:
416 def prevService(self):
419 if self.current-1 > -1:
422 self.current = self.length - 1
424 def currentService(self):
427 return self.services[self.current]
430 """ EPG - Opens an EPG list when the showEPGList action fires """
432 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
434 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
437 self.is_now_next = False
439 self.bouquetSel = None
440 self.eventView = None
441 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
443 "showEventInfo": (self.openEventView, _("show EPG...")),
444 "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
445 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
448 def showEventInfoWhenNotVisible(self):
455 def zapToService(self, service):
456 if not service is None:
457 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
458 self.servicelist.clearPath()
459 if self.servicelist.bouquet_root != self.epg_bouquet:
460 self.servicelist.enterPath(self.servicelist.bouquet_root)
461 self.servicelist.enterPath(self.epg_bouquet)
462 self.servicelist.setCurrentSelection(service) #select the service in servicelist
463 self.servicelist.zap()
465 def getBouquetServices(self, bouquet):
467 servicelist = eServiceCenter.getInstance().list(bouquet)
468 if not servicelist is None:
470 service = servicelist.getNext()
471 if not service.valid(): #check if end of list
473 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
475 services.append(ServiceReference(service))
478 def openBouquetEPG(self, bouquet, withCallback=True):
479 services = self.getBouquetServices(bouquet)
481 self.epg_bouquet = bouquet
483 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
485 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
487 def changeBouquetCB(self, direction, epg):
490 self.bouquetSel.down()
493 bouquet = self.bouquetSel.getCurrent()
494 services = self.getBouquetServices(bouquet)
496 self.epg_bouquet = bouquet
497 epg.setServices(services)
499 def closed(self, ret=False):
500 closedScreen = self.dlg_stack.pop()
501 if self.bouquetSel and closedScreen == self.bouquetSel:
502 self.bouquetSel = None
503 elif self.eventView and closedScreen == self.eventView:
504 self.eventView = None
506 dlgs=len(self.dlg_stack)
508 self.dlg_stack[dlgs-1].close(dlgs > 1)
510 def openMultiServiceEPG(self, withCallback=True):
511 bouquets = self.servicelist.getBouquetList()
516 if cnt > 1: # show bouquet list
518 self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
519 self.dlg_stack.append(self.bouquetSel)
521 self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
523 self.openBouquetEPG(bouquets[0][1], withCallback)
525 def changeServiceCB(self, direction, epg):
528 self.serviceSel.nextService()
530 self.serviceSel.prevService()
531 epg.setService(self.serviceSel.currentService())
533 def SingleServiceEPGClosed(self, ret=False):
534 self.serviceSel = None
536 def openSingleServiceEPG(self):
537 ref=self.session.nav.getCurrentlyPlayingServiceReference()
539 if self.servicelist.getMutableList() is not None: # bouquet in channellist
540 current_path = self.servicelist.getRoot()
541 services = self.getBouquetServices(current_path)
542 self.serviceSel = SimpleServicelist(services)
543 self.serviceSel.selectService(ref)
544 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
546 self.session.open(EPGSelection, ref)
548 def showEventInfoPlugins(self):
549 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
552 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
553 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
555 self.openSingleServiceEPG()
557 def runPlugin(self, plugin):
558 plugin(session = self.session, servicelist = self.servicelist)
560 def EventInfoPluginChosen(self, answer):
561 if answer is not None:
564 def openSimilarList(self, eventid, refstr):
565 self.session.open(EPGSelection, refstr, None, eventid)
567 def getNowNext(self):
569 service = self.session.nav.getCurrentService()
570 info = service and service.info()
571 ptr = info and info.getEvent(0)
574 ptr = info and info.getEvent(1)
577 self.epglist = epglist
579 def __evEventInfoChanged(self):
580 if self.is_now_next and len(self.dlg_stack) == 1:
582 assert self.eventView
584 self.eventView.setEvent(self.epglist[0])
586 def openEventView(self):
587 ref = self.session.nav.getCurrentlyPlayingServiceReference()
589 epglist = self.epglist
591 self.is_now_next = False
592 epg = eEPGCache.getInstance()
593 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
596 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
600 self.is_now_next = True
602 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
603 self.dlg_stack.append(self.eventView)
605 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
606 self.openMultiServiceEPG(False)
608 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
609 epglist = self.epglist
612 epglist[0]=epglist[1]
616 class InfoBarRdsDecoder:
617 """provides RDS and Rass support/display"""
619 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
620 self.rass_interactive = None
622 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
624 iPlayableService.evEnd: self.__serviceStopped,
625 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
628 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
630 "startRassInteractive": self.startRassInteractive
633 self["RdsActions"].setEnabled(False)
635 self.onLayoutFinish.append(self.rds_display.show)
636 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
638 def RassInteractivePossibilityChanged(self, state):
639 self["RdsActions"].setEnabled(state)
641 def RassSlidePicChanged(self):
642 if not self.rass_interactive:
643 service = self.session.nav.getCurrentService()
644 decoder = service and service.rdsDecoder()
646 decoder.showRassSlidePicture()
648 def __serviceStopped(self):
649 if self.rass_interactive is not None:
650 rass_interactive = self.rass_interactive
651 self.rass_interactive = None
652 rass_interactive.close()
654 def startRassInteractive(self):
655 self.rds_display.hide()
656 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
658 def RassInteractiveClosed(self, *val):
659 if self.rass_interactive is not None:
660 self.rass_interactive = None
661 self.RassSlidePicChanged()
662 self.rds_display.show()
665 """handles actions like seeking, pause"""
667 SEEK_STATE_PLAY = (0, 0, 0, ">")
668 SEEK_STATE_PAUSE = (1, 0, 0, "||")
669 SEEK_STATE_EOF = (1, 0, 0, "END")
671 def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
672 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
674 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
675 iPlayableService.evStart: self.__serviceStarted,
677 iPlayableService.evEOF: self.__evEOF,
678 iPlayableService.evSOF: self.__evSOF,
681 self.minSpeedBackward = useSeekBackHack and 16 or 0
683 class InfoBarSeekActionMap(HelpableActionMap):
684 def __init__(self, screen, *args, **kwargs):
685 HelpableActionMap.__init__(self, screen, *args, **kwargs)
688 def action(self, contexts, action):
689 print "action:", action
690 if action[:5] == "seek:":
691 time = int(action[5:])
692 self.screen.doSeekRelative(time * 90000)
694 elif action[:8] == "seekdef:":
695 key = int(action[8:])
696 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
697 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
698 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
699 self.screen.doSeekRelative(time * 90000)
702 return HelpableActionMap.action(self, contexts, action)
704 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
706 "playpauseService": self.playpauseService,
707 "pauseService": (self.pauseService, _("pause")),
708 "unPauseService": (self.unPauseService, _("continue")),
710 "seekFwd": (self.seekFwd, _("skip forward")),
711 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
712 "seekBack": (self.seekBack, _("skip backward")),
713 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
715 # give them a little more priority to win over color buttons
717 self["SeekActions"].setEnabled(False)
719 self.seekstate = self.SEEK_STATE_PLAY
720 self.lastseekstate = self.SEEK_STATE_PLAY
722 self.onPlayStateChanged = [ ]
724 self.lockedBecauseOfSkipping = False
726 self.__seekableStatusChanged()
728 def makeStateForward(self, n):
729 minspeed = config.seek.stepwise_minspeed.value
730 repeat = int(config.seek.stepwise_repeat.value)
731 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
732 return (0, n * repeat, repeat, ">> %dx" % n)
734 return (0, n, 0, ">> %dx" % n)
736 def makeStateBackward(self, n):
737 minspeed = config.seek.stepwise_minspeed.value
738 repeat = int(config.seek.stepwise_repeat.value)
739 if self.minSpeedBackward and n < self.minSpeedBackward:
740 r = (self.minSpeedBackward - 1)/ n + 1
741 if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
743 return (0, -n * r, r, "<< %dx" % n)
744 elif minspeed != "Never" and n >= int(minspeed) and repeat > 1:
745 return (0, -n * repeat, repeat, "<< %dx" % n)
747 return (0, -n, 0, "<< %dx" % n)
749 def makeStateSlowMotion(self, n):
750 return (0, 0, n, "/%d" % n)
752 def isStateForward(self, state):
755 def isStateBackward(self, state):
758 def isStateSlowMotion(self, state):
759 return state[1] == 0 and state[2] > 1
761 def getHigher(self, n, lst):
767 def getLower(self, n, lst):
775 def showAfterSeek(self):
776 if isinstance(self, InfoBarShowHide):
786 service = self.session.nav.getCurrentService()
790 seek = service.seek()
792 if seek is None or not seek.isCurrentlySeekable():
797 def isSeekable(self):
798 if self.getSeek() is None:
802 def __seekableStatusChanged(self):
803 # print "seekable status changed!"
804 if not self.isSeekable():
805 self["SeekActions"].setEnabled(False)
806 # print "not seekable, return to play"
807 self.setSeekState(self.SEEK_STATE_PLAY)
809 self["SeekActions"].setEnabled(True)
812 def __serviceStarted(self):
813 self.seekstate = self.SEEK_STATE_PLAY
814 self.__seekableStatusChanged()
816 def setSeekState(self, state):
817 service = self.session.nav.getCurrentService()
822 if not self.isSeekable():
823 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
824 state = self.SEEK_STATE_PLAY
826 pauseable = service.pause()
828 if pauseable is None:
829 print "not pauseable."
830 state = self.SEEK_STATE_PLAY
832 oldstate = self.seekstate
833 self.seekstate = state
836 if oldstate[i] != self.seekstate[i]:
837 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
839 for c in self.onPlayStateChanged:
842 self.checkSkipShowHideLock()
846 def playpauseService(self):
847 if self.seekstate != self.SEEK_STATE_PLAY:
848 self.unPauseService()
852 def pauseService(self):
853 if self.seekstate == self.SEEK_STATE_PAUSE:
854 if config.seek.on_pause.value == "play":
855 self.unPauseService()
856 elif config.seek.on_pause.value == "step":
857 self.doSeekRelative(0)
858 elif config.seek.on_pause.value == "last":
859 self.setSeekState(self.lastseekstate)
860 self.lastseekstate = self.SEEK_STATE_PLAY
862 if self.seekstate != self.SEEK_STATE_EOF:
863 self.lastseekstate = self.seekstate
864 self.setSeekState(self.SEEK_STATE_PAUSE);
866 def unPauseService(self):
868 if self.seekstate == self.SEEK_STATE_PLAY:
870 self.setSeekState(self.SEEK_STATE_PLAY)
872 def doSeek(self, pts):
873 seekable = self.getSeek()
878 def doSeekRelative(self, pts):
879 seekable = self.getSeek()
882 prevstate = self.seekstate
884 if self.seekstate == self.SEEK_STATE_EOF:
885 if prevstate == self.SEEK_STATE_PAUSE:
886 self.setSeekState(self.SEEK_STATE_PAUSE)
888 self.setSeekState(self.SEEK_STATE_PLAY)
889 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
890 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
894 if self.seekstate == self.SEEK_STATE_PLAY:
895 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
896 elif self.seekstate == self.SEEK_STATE_PAUSE:
897 if len(config.seek.speeds_slowmotion.value):
898 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
900 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
901 elif self.seekstate == self.SEEK_STATE_EOF:
903 elif self.isStateForward(self.seekstate):
904 speed = self.seekstate[1]
905 if self.seekstate[2]:
906 speed /= self.seekstate[2]
907 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
908 self.setSeekState(self.makeStateForward(speed))
909 elif self.isStateBackward(self.seekstate):
910 speed = -self.seekstate[1]
911 if self.seekstate[2]:
912 speed /= self.seekstate[2]
913 speed = self.getLower(speed, config.seek.speeds_backward.value)
915 self.setSeekState(self.makeStateBackward(speed))
917 self.setSeekState(self.SEEK_STATE_PLAY)
918 elif self.isStateSlowMotion(self.seekstate):
919 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
920 self.setSeekState(self.makeStateSlowMotion(speed))
923 seekstate = self.seekstate
924 if seekstate == self.SEEK_STATE_PLAY:
925 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
926 elif seekstate == self.SEEK_STATE_EOF:
927 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
928 self.doSeekRelative(-6)
929 elif seekstate == self.SEEK_STATE_PAUSE:
930 self.doSeekRelative(-3)
931 elif self.isStateForward(seekstate):
934 speed /= seekstate[2]
935 speed = self.getLower(speed, config.seek.speeds_forward.value)
937 self.setSeekState(self.makeStateForward(speed))
939 self.setSeekState(self.SEEK_STATE_PLAY)
940 elif self.isStateBackward(seekstate):
941 speed = -seekstate[1]
943 speed /= seekstate[2]
944 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
945 self.setSeekState(self.makeStateBackward(speed))
946 elif self.isStateSlowMotion(seekstate):
947 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
949 self.setSeekState(self.makeStateSlowMotion(speed))
951 self.setSeekState(self.SEEK_STATE_PAUSE)
953 def seekFwdManual(self):
954 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
956 def fwdSeekTo(self, minutes):
957 print "Seek", minutes, "minutes forward"
958 self.doSeekRelative(minutes * 60 * 90000)
960 def seekBackManual(self):
961 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
963 def rwdSeekTo(self, minutes):
965 self.doSeekRelative(-minutes * 60 * 90000)
967 def checkSkipShowHideLock(self):
968 wantlock = self.seekstate != self.SEEK_STATE_PLAY
970 if config.usage.show_infobar_on_skip.value:
971 if self.lockedBecauseOfSkipping and not wantlock:
973 self.lockedBecauseOfSkipping = False
975 if wantlock and not self.lockedBecauseOfSkipping:
977 self.lockedBecauseOfSkipping = True
979 def calcRemainingTime(self):
980 seekable = self.getSeek()
981 if seekable is not None:
982 len = seekable.getLength()
984 tmp = self.cueGetEndCutPosition()
989 pos = seekable.getPlayPosition()
990 speednom = self.seekstate[1] or 1
991 speedden = self.seekstate[2] or 1
992 if not len[0] and not pos[0]:
995 time = (len[1] - pos[1])*speedden/(90*speednom)
1000 if self.seekstate == self.SEEK_STATE_EOF:
1003 # if we are seeking forward, we try to end up ~1s before the end, and pause there.
1004 seekstate = self.seekstate
1005 if self.seekstate != self.SEEK_STATE_PAUSE:
1006 self.setSeekState(self.SEEK_STATE_EOF)
1008 if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
1009 seekable = self.getSeek()
1010 if seekable is not None:
1012 if seekstate == self.SEEK_STATE_PLAY: # regular EOF
1013 self.doEofInternal(True)
1015 self.doEofInternal(False)
1017 def doEofInternal(self, playing):
1018 pass # Defined in subclasses
1021 self.setSeekState(self.SEEK_STATE_PLAY)
1024 from Screens.PVRState import PVRState, TimeshiftState
1026 class InfoBarPVRState:
1027 def __init__(self, screen=PVRState, force_show = False):
1028 self.onPlayStateChanged.append(self.__playStateChanged)
1029 self.pvrStateDialog = self.session.instantiateDialog(screen)
1030 self.onShow.append(self._mayShow)
1031 self.onHide.append(self.pvrStateDialog.hide)
1032 self.force_show = force_show
1035 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1036 self.pvrStateDialog.show()
1038 def __playStateChanged(self, state):
1039 playstateString = state[3]
1040 self.pvrStateDialog["state"].setText(playstateString)
1042 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
1043 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
1044 self.pvrStateDialog.hide()
1049 class InfoBarTimeshiftState(InfoBarPVRState):
1051 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1054 if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
1055 self.pvrStateDialog.show()
1057 class InfoBarShowMovies:
1059 # i don't really like this class.
1060 # it calls a not further specified "movie list" on up/down/movieList,
1061 # so this is not more than an action map
1063 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1065 "movieList": (self.showMovies, _("movie list")),
1066 "up": (self.showMovies, _("movie list")),
1067 "down": (self.showMovies, _("movie list"))
1070 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1074 # Timeshift works the following way:
1075 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1076 # - normal playback TUNER unused PLAY enable disable disable
1077 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1078 # - user presess pause again FILE record PLAY enable disable enable
1079 # - user fast forwards FILE record FF enable disable enable
1080 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1081 # - user backwards FILE record BACK # !! enable disable enable
1085 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1086 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1087 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1088 # - the user can now PVR around
1089 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1090 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1092 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1093 # - if the user rewinds, or press pause, timeshift will be activated again
1095 # note that a timeshift can be enabled ("recording") and
1096 # activated (currently time-shifting).
1098 class InfoBarTimeshift:
1100 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1102 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1103 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1105 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1107 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1108 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1109 }, prio=-1) # priority over record
1111 self.timeshift_enabled = 0
1112 self.timeshift_state = 0
1113 self.ts_rewind_timer = eTimer()
1114 self.ts_rewind_timer.callback.append(self.rewindService)
1116 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1118 iPlayableService.evStart: self.__serviceStarted,
1119 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1122 def getTimeshift(self):
1123 service = self.session.nav.getCurrentService()
1124 return service and service.timeshift()
1126 def startTimeshift(self):
1127 print "enable timeshift"
1128 ts = self.getTimeshift()
1130 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1131 print "no ts interface"
1134 if self.timeshift_enabled:
1135 print "hu, timeshift already enabled?"
1137 if not ts.startTimeshift():
1138 self.timeshift_enabled = 1
1140 # we remove the "relative time" for now.
1141 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1144 #self.setSeekState(self.SEEK_STATE_PAUSE)
1145 self.activateTimeshiftEnd(False)
1147 # enable the "TimeshiftEnableActions", which will override
1148 # the startTimeshift actions
1149 self.__seekableStatusChanged()
1151 print "timeshift failed"
1153 def stopTimeshift(self):
1154 if not self.timeshift_enabled:
1156 print "disable timeshift"
1157 ts = self.getTimeshift()
1160 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1162 def stopTimeshiftConfirmed(self, confirmed):
1166 ts = self.getTimeshift()
1171 self.timeshift_enabled = 0
1174 self.__seekableStatusChanged()
1176 # activates timeshift, and seeks to (almost) the end
1177 def activateTimeshiftEnd(self, back = True):
1178 ts = self.getTimeshift()
1179 print "activateTimeshiftEnd"
1184 if ts.isTimeshiftActive():
1185 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1189 ts.activateTimeshift() # activate timeshift will automatically pause
1190 self.setSeekState(self.SEEK_STATE_PAUSE)
1193 self.doSeek(-5) # seek some gops before end
1194 self.ts_rewind_timer.start(200, 1)
1196 self.doSeek(-1) # seek 1 gop before end
1198 def rewindService(self):
1199 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1201 # same as activateTimeshiftEnd, but pauses afterwards.
1202 def activateTimeshiftEndAndPause(self):
1203 print "activateTimeshiftEndAndPause"
1204 #state = self.seekstate
1205 self.activateTimeshiftEnd(False)
1207 def __seekableStatusChanged(self):
1210 # print "self.isSeekable", self.isSeekable()
1211 # print "self.timeshift_enabled", self.timeshift_enabled
1213 # when this service is not seekable, but timeshift
1214 # is enabled, this means we can activate
1216 if not self.isSeekable() and self.timeshift_enabled:
1219 # print "timeshift activate:", enabled
1220 self["TimeshiftActivateActions"].setEnabled(enabled)
1222 def __serviceStarted(self):
1223 self.timeshift_enabled = False
1224 self.__seekableStatusChanged()
1226 from Screens.PiPSetup import PiPSetup
1228 class InfoBarExtensions:
1229 EXTENSION_SINGLE = 0
1235 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1237 "extensions": (self.showExtensionSelection, _("view extensions...")),
1238 }, 1) # lower priority
1240 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1241 self.list.append((type, extension, key))
1243 def updateExtension(self, extension, key = None):
1244 self.extensionsList.append(extension)
1246 if self.extensionKeys.has_key(key):
1250 for x in self.availableKeys:
1251 if not self.extensionKeys.has_key(x):
1256 self.extensionKeys[key] = len(self.extensionsList) - 1
1258 def updateExtensions(self):
1259 self.extensionsList = []
1260 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1261 self.extensionKeys = {}
1263 if x[0] == self.EXTENSION_SINGLE:
1264 self.updateExtension(x[1], x[2])
1267 self.updateExtension(y[0], y[1])
1270 def showExtensionSelection(self):
1271 self.updateExtensions()
1272 extensionsList = self.extensionsList[:]
1275 for x in self.availableKeys:
1276 if self.extensionKeys.has_key(x):
1277 entry = self.extensionKeys[x]
1278 extension = self.extensionsList[entry]
1280 name = str(extension[0]())
1281 list.append((extension[0](), extension))
1283 extensionsList.remove(extension)
1285 extensionsList.remove(extension)
1286 list.extend([(x[0](), x) for x in extensionsList])
1288 keys += [""] * len(extensionsList)
1289 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
1291 def extensionCallback(self, answer):
1292 if answer is not None:
1295 from Tools.BoundFunction import boundFunction
1297 # depends on InfoBarExtensions
1299 class InfoBarPlugins:
1301 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1303 def getPluginName(self, name):
1306 def getPluginList(self):
1307 list = [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
1308 list.sort(key = lambda e: e[2]) # sort by name
1311 def runPlugin(self, plugin):
1312 if isinstance(self, InfoBarChannelSelection):
1313 plugin(session = self.session, servicelist = self.servicelist)
1315 plugin(session = self.session)
1317 from Components.Task import job_manager
1318 class InfoBarJobman:
1320 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1322 def getJobList(self):
1323 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1325 def getJobName(self, job):
1326 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1328 def showJobView(self, job):
1329 from Screens.TaskView import JobView
1330 job_manager.in_background = False
1331 self.session.openWithCallback(self.JobViewCB, JobView, job)
1333 def JobViewCB(self, in_background):
1334 job_manager.in_background = in_background
1336 # depends on InfoBarExtensions
1337 class InfoBarSleepTimer:
1339 self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, lambda: True), "1")
1341 def getSleepTimerName(self):
1342 return _("Sleep Timer")
1344 def showSleepTimerSetup(self):
1345 self.session.open(SleepTimerEdit)
1347 # depends on InfoBarExtensions
1350 self.session.pipshown = False
1351 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1352 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1353 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1354 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1357 return self.session.pipshown
1359 def pipHandles0Action(self):
1360 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1362 def getShowHideName(self):
1363 if self.session.pipshown:
1364 return _("Disable Picture in Picture")
1366 return _("Activate Picture in Picture")
1368 def getSwapName(self):
1369 return _("Swap Services")
1371 def getMoveName(self):
1372 return _("Move Picture in Picture")
1375 if self.session.pipshown:
1376 del self.session.pip
1377 self.session.pipshown = False
1379 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1380 self.session.pip.show()
1381 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1382 if self.session.pip.playService(newservice):
1383 self.session.pipshown = True
1384 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1386 self.session.pipshown = False
1387 del self.session.pip
1388 self.session.nav.playService(newservice)
1391 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1392 if self.session.pip.servicePath:
1393 servicepath = self.servicelist.getCurrentServicePath()
1394 ref=servicepath[len(servicepath)-1]
1395 pipref=self.session.pip.getCurrentService()
1396 self.session.pip.playService(swapservice)
1397 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1398 if pipref.toString() != ref.toString(): # is a subservice ?
1399 self.session.nav.stopService() # stop portal
1400 self.session.nav.playService(pipref) # start subservice
1401 self.session.pip.servicePath=servicepath
1404 self.session.open(PiPSetup, pip = self.session.pip)
1406 def pipDoHandle0Action(self):
1407 use = config.usage.pip_zero_button.value
1410 elif "swapstop" == use:
1416 from RecordTimer import parseEvent, RecordTimerEntry
1418 class InfoBarInstantRecord:
1419 """Instant Record - handles the instantRecord action in order to
1420 start/stop instant records"""
1422 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1424 "instantRecord": (self.instantRecord, _("Instant Record...")),
1428 def stopCurrentRecording(self, entry = -1):
1429 if entry is not None and entry != -1:
1430 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1431 self.recording.remove(self.recording[entry])
1433 def startInstantRecording(self, limitEvent = False):
1434 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1436 # try to get event info
1439 service = self.session.nav.getCurrentService()
1440 epg = eEPGCache.getInstance()
1441 event = epg.lookupEventTime(serviceref, -1, 0)
1443 info = service.info()
1444 ev = info.getEvent(0)
1450 end = begin + 3600 # dummy
1451 name = "instant record"
1455 if event is not None:
1456 curEvent = parseEvent(event)
1458 description = curEvent[3]
1459 eventid = curEvent[4]
1464 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1466 if isinstance(serviceref, eServiceReference):
1467 serviceref = ServiceReference(serviceref)
1469 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
1470 recording.dontSave = True
1472 if event is None or limitEvent == False:
1473 recording.autoincrease = True
1474 if recording.setAutoincreaseEnd():
1475 self.session.nav.RecordTimer.record(recording)
1476 self.recording.append(recording)
1478 simulTimerList = self.session.nav.RecordTimer.record(recording)
1479 if simulTimerList is not None: # conflict with other recording
1480 name = simulTimerList[1].name
1481 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1482 print "[TIMER] conflicts with", name_date
1483 recording.autoincrease = True # start with max available length, then increment
1484 if recording.setAutoincreaseEnd():
1485 self.session.nav.RecordTimer.record(recording)
1486 self.recording.append(recording)
1487 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1489 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1490 recording.autoincrease = False
1492 self.recording.append(recording)
1494 def isInstantRecordRunning(self):
1495 print "self.recording:", self.recording
1497 for x in self.recording:
1502 def recordQuestionCallback(self, answer):
1503 print "pre:\n", self.recording
1505 if answer is None or answer[1] == "no":
1508 recording = self.recording[:]
1510 if not x in self.session.nav.RecordTimer.timer_list:
1511 self.recording.remove(x)
1512 elif x.dontSave and x.isRunning():
1513 list.append((x, False))
1515 if answer[1] == "changeduration":
1516 if len(self.recording) == 1:
1517 self.changeDuration(0)
1519 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1520 elif answer[1] == "changeendtime":
1521 if len(self.recording) == 1:
1524 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1525 elif answer[1] == "stop":
1526 if len(self.recording) == 1:
1527 self.stopCurrentRecording(0)
1529 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1530 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1531 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1532 if answer[1] == "manualduration":
1533 self.changeDuration(len(self.recording)-1)
1534 elif answer[1] == "manualendtime":
1535 self.setEndtime(len(self.recording)-1)
1536 print "after:\n", self.recording
1538 def setEndtime(self, entry):
1539 if entry is not None and entry >= 0:
1540 self.selectedEntry = entry
1541 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1542 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1543 dlg.setTitle(_("Please change recording endtime"))
1545 def TimeDateInputClosed(self, ret):
1548 localendtime = localtime(ret[1])
1549 print "stopping recording at", strftime("%c", localendtime)
1550 if self.recording[self.selectedEntry].end != ret[1]:
1551 self.recording[self.selectedEntry].autoincrease = False
1552 self.recording[self.selectedEntry].end = ret[1]
1553 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1555 def changeDuration(self, entry):
1556 if entry is not None and entry >= 0:
1557 self.selectedEntry = entry
1558 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1560 def inputCallback(self, value):
1561 if value is not None:
1562 print "stopping recording after", int(value), "minutes."
1563 entry = self.recording[self.selectedEntry]
1565 entry.autoincrease = False
1566 entry.end = int(time()) + 60 * int(value)
1567 self.session.nav.RecordTimer.timeChanged(entry)
1569 def instantRecord(self):
1570 dir = config.movielist.last_videodir.value
1571 if not fileExists(dir, 'w'):
1572 dir = resolveFilename(SCOPE_HDD)
1576 # XXX: this message is a little odd as we might be recording to a remote device
1577 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1580 if self.isInstantRecordRunning():
1581 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1582 title=_("A recording is currently running.\nWhat do you want to do?"), \
1583 list=((_("add recording (stop after current event)"), "event"), \
1584 (_("add recording (enter recording duration)"), "manualduration"), \
1585 (_("add recording (enter recording endtime)"), "manualendtime"), \
1586 (_("add recording (indefinitely)"), "indefinitely"), \
1587 (_("change recording (duration)"), "changeduration"), \
1588 (_("change recording (endtime)"), "changeendtime"), \
1589 (_("stop recording"), "stop"), \
1590 (_("do nothing"), "no")))
1592 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1593 title=_("Start recording?"), \
1594 list=((_("add recording (stop after current event)"), "event"), \
1595 (_("add recording (enter recording duration)"), "manualduration"), \
1596 (_("add recording (enter recording endtime)"), "manualendtime"), \
1597 (_("add recording (indefinitely)"), "indefinitely"), \
1598 (_("don't record"), "no")))
1600 from Tools.ISO639 import LanguageCodes
1602 class InfoBarAudioSelection:
1604 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1606 "audioSelection": (self.audioSelection, _("Audio Options...")),
1609 def audioSelection(self):
1610 service = self.session.nav.getCurrentService()
1611 self.audioTracks = audio = service and service.audioTracks()
1612 n = audio and audio.getNumberOfTracks() or 0
1615 self.audioChannel = service.audioChannel()
1619 i = audio.getTrackInfo(idx)
1620 language = i.getLanguage()
1621 description = i.getDescription()
1623 if LanguageCodes.has_key(language):
1624 language = LanguageCodes[language][0]
1626 if len(description):
1627 description += " (" + language + ")"
1629 description = language
1631 tlist.append((description, idx))
1634 tlist.sort(key=lambda x: x[0])
1636 selectedAudio = self.audioTracks.getCurrentTrack()
1641 if x[1] != selectedAudio:
1646 if SystemInfo["CanDownmixAC3"]:
1647 tlist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
1648 ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"),
1650 keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1653 tlist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
1654 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
1656 self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys, skin_name = "AudioTrackSelection")
1658 del self.audioTracks
1660 def changeAC3Downmix(self, arg):
1661 choicelist = self.session.current_dialog["list"]
1662 list = choicelist.list
1664 list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
1665 _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
1666 choicelist.setList(list)
1667 if config.av.downmix_ac3.value:
1668 config.av.downmix_ac3.value = False
1670 config.av.downmix_ac3.value = True
1671 config.av.downmix_ac3.save()
1673 def audioSelected(self, audio):
1674 if audio is not None:
1675 if isinstance(audio[1], str):
1676 if audio[1] == "mode":
1677 keys = ["red", "green", "yellow"]
1678 selection = self.audioChannel.getCurrentChannel()
1679 tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
1680 self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys, skin_name ="AudioModeSelection")
1682 del self.audioChannel
1683 if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
1684 self.audioTracks.selectTrack(audio[1])
1686 del self.audioChannel
1687 del self.audioTracks
1689 def modeSelected(self, mode):
1690 if mode is not None:
1691 self.audioChannel.selectChannel(mode[1])
1692 del self.audioChannel
1694 class InfoBarSubserviceSelection:
1696 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1698 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1701 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1703 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1704 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1706 self["SubserviceQuickzapAction"].setEnabled(False)
1708 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1710 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1715 def checkSubservicesAvail(self):
1716 service = self.session.nav.getCurrentService()
1717 subservices = service and service.subServices()
1718 if not subservices or subservices.getNumberOfSubservices() == 0:
1719 self["SubserviceQuickzapAction"].setEnabled(False)
1721 def nextSubservice(self):
1722 self.changeSubservice(+1)
1724 def prevSubservice(self):
1725 self.changeSubservice(-1)
1727 def changeSubservice(self, direction):
1728 service = self.session.nav.getCurrentService()
1729 subservices = service and service.subServices()
1730 n = subservices and subservices.getNumberOfSubservices()
1733 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1736 if subservices.getSubservice(idx).toString() == ref.toString():
1741 selection += direction
1746 newservice = subservices.getSubservice(selection)
1747 if newservice.valid():
1750 self.session.nav.playService(newservice, False)
1752 def subserviceSelection(self):
1753 service = self.session.nav.getCurrentService()
1754 subservices = service and service.subServices()
1755 self.bouquets = self.servicelist.getBouquetList()
1756 n = subservices and subservices.getNumberOfSubservices()
1759 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1763 i = subservices.getSubservice(idx)
1764 if i.toString() == ref.toString():
1766 tlist.append((i.getName(), i))
1769 if self.bouquets and len(self.bouquets):
1770 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1771 if config.usage.multibouquet.value:
1772 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1774 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1777 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1778 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1781 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
1783 def subserviceSelected(self, service):
1785 if not service is None:
1786 if isinstance(service[1], str):
1787 if service[1] == "quickzap":
1788 from Screens.SubservicesQuickzap import SubservicesQuickzap
1789 self.session.open(SubservicesQuickzap, service[2])
1791 self["SubserviceQuickzapAction"].setEnabled(True)
1792 self.session.nav.playService(service[1], False)
1794 def addSubserviceToBouquetCallback(self, service):
1795 if len(service) > 1 and isinstance(service[1], eServiceReference):
1796 self.selectedSubservice = service
1797 if self.bouquets is None:
1800 cnt = len(self.bouquets)
1801 if cnt > 1: # show bouquet list
1802 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1803 elif cnt == 1: # add to only one existing bouquet
1804 self.addSubserviceToBouquet(self.bouquets[0][1])
1805 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1807 def bouquetSelClosed(self, confirmed):
1809 del self.selectedSubservice
1811 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1813 def addSubserviceToBouquet(self, dest):
1814 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1816 self.bsel.close(True)
1818 del self.selectedSubservice
1820 class InfoBarAdditionalInfo:
1823 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1824 self["TimeshiftPossible"] = self["RecordingPossible"]
1825 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1826 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1827 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1828 self["ExtensionsAvailable"] = Boolean(fixed=1)
1830 class InfoBarNotifications:
1832 self.onExecBegin.append(self.checkNotifications)
1833 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1834 self.onClose.append(self.__removeNotification)
1836 def __removeNotification(self):
1837 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1839 def checkNotificationsIfExecing(self):
1841 self.checkNotifications()
1843 def checkNotifications(self):
1844 notifications = Notifications.notifications
1846 n = notifications[0]
1848 del notifications[0]
1851 if n[3].has_key("onSessionOpenCallback"):
1852 n[3]["onSessionOpenCallback"]()
1853 del n[3]["onSessionOpenCallback"]
1856 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1858 dlg = self.session.open(n[1], *n[2], **n[3])
1860 # remember that this notification is currently active
1862 Notifications.current_notifications.append(d)
1863 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1865 def __notificationClosed(self, d):
1866 Notifications.current_notifications.remove(d)
1868 class InfoBarServiceNotifications:
1870 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1872 iPlayableService.evEnd: self.serviceHasEnded
1875 def serviceHasEnded(self):
1876 print "service end!"
1879 self.setSeekState(self.SEEK_STATE_PLAY)
1883 class InfoBarCueSheetSupport:
1889 ENABLE_RESUME_SUPPORT = False
1891 def __init__(self, actionmap = "InfobarCueSheetActions"):
1892 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1894 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1895 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1896 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1900 self.is_closing = False
1901 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1903 iPlayableService.evStart: self.__serviceStarted,
1906 def __serviceStarted(self):
1909 print "new service started! trying to download cuts!"
1910 self.downloadCuesheet()
1912 if self.ENABLE_RESUME_SUPPORT:
1915 for (pts, what) in self.cut_list:
1916 if what == self.CUT_TYPE_LAST:
1919 if last is not None:
1920 self.resume_point = last
1921 if config.usage.on_movie_start.value == "ask":
1922 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
1923 elif config.usage.on_movie_start.value == "resume":
1924 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1925 # TRANSLATORS: at the start of a movie, when the user has selected
1926 # TRANSLATORS: "Resume from last position" as start behavior.
1927 # TRANSLATORS: The purpose is to notify the user that the movie starts
1928 # TRANSLATORS: in the middle somewhere and not from the beginning.
1929 # TRANSLATORS: (Some translators seem to have interpreted it as a
1930 # TRANSLATORS: question or a choice, but it is a statement.)
1931 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1933 def playLastCB(self, answer):
1935 self.doSeek(self.resume_point)
1936 self.hideAfterResume()
1938 def hideAfterResume(self):
1939 if isinstance(self, InfoBarShowHide):
1942 def __getSeekable(self):
1943 service = self.session.nav.getCurrentService()
1946 return service.seek()
1948 def cueGetCurrentPosition(self):
1949 seek = self.__getSeekable()
1952 r = seek.getPlayPosition()
1957 def cueGetEndCutPosition(self):
1960 for cp in self.cut_list:
1961 if cp[1] == self.CUT_TYPE_OUT:
1965 elif cp[1] == self.CUT_TYPE_IN:
1969 def jumpPreviousNextMark(self, cmp, start=False):
1970 current_pos = self.cueGetCurrentPosition()
1971 if current_pos is None:
1973 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
1974 if mark is not None:
1982 def jumpPreviousMark(self):
1983 # we add 2 seconds, so if the play position is <2s after
1984 # the mark, the mark before will be used
1985 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
1987 def jumpNextMark(self):
1988 if not self.jumpPreviousNextMark(lambda x: x):
1991 def getNearestCutPoint(self, pts, cmp=abs, start=False):
1997 bestdiff = cmp(0 - pts)
1999 nearest = [0, False]
2000 for cp in self.cut_list:
2001 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
2003 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
2004 diff = cmp(cp[0] - pts)
2010 if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
2011 diff = cmp(cp[0] - pts)
2012 if diff >= 0 and (nearest is None or bestdiff > diff):
2017 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
2018 current_pos = self.cueGetCurrentPosition()
2019 if current_pos is None:
2020 print "not seekable"
2023 nearest_cutpoint = self.getNearestCutPoint(current_pos)
2025 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
2027 return nearest_cutpoint
2029 self.removeMark(nearest_cutpoint)
2030 elif not onlyremove and not onlyreturn:
2031 self.addMark((current_pos, self.CUT_TYPE_MARK))
2036 def addMark(self, point):
2037 insort(self.cut_list, point)
2038 self.uploadCuesheet()
2039 self.showAfterCuesheetOperation()
2041 def removeMark(self, point):
2042 self.cut_list.remove(point)
2043 self.uploadCuesheet()
2044 self.showAfterCuesheetOperation()
2046 def showAfterCuesheetOperation(self):
2047 if isinstance(self, InfoBarShowHide):
2050 def __getCuesheet(self):
2051 service = self.session.nav.getCurrentService()
2054 return service.cueSheet()
2056 def uploadCuesheet(self):
2057 cue = self.__getCuesheet()
2060 print "upload failed, no cuesheet interface"
2062 cue.setCutList(self.cut_list)
2064 def downloadCuesheet(self):
2065 cue = self.__getCuesheet()
2068 print "download failed, no cuesheet interface"
2071 self.cut_list = cue.getCutList()
2073 class InfoBarSummary(Screen):
2075 <screen position="0,0" size="132,64">
2076 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2077 <convert type="ClockToText">WithSeconds</convert>
2079 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2080 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2081 <convert type="ConditionalShowHide">Blink</convert>
2083 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2084 <convert type="ServiceName">Name</convert>
2086 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2087 <convert type="EventTime">Progress</convert>
2091 # for picon: (path="piconlcd" will use LCD picons)
2092 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2093 # <convert type="ServiceName">Reference</convert>
2096 class InfoBarSummarySupport:
2100 def createSummary(self):
2101 return InfoBarSummary
2103 class InfoBarMoviePlayerSummary(Screen):
2105 <screen position="0,0" size="132,64">
2106 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2107 <convert type="ClockToText">WithSeconds</convert>
2109 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2110 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2111 <convert type="ConditionalShowHide">Blink</convert>
2113 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2114 <convert type="ServiceName">Name</convert>
2116 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2117 <convert type="ServicePosition">Position</convert>
2121 class InfoBarMoviePlayerSummarySupport:
2125 def createSummary(self):
2126 return InfoBarMoviePlayerSummary
2128 class InfoBarTeletextPlugin:
2130 self.teletext_plugin = None
2132 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2133 self.teletext_plugin = p
2135 if self.teletext_plugin is not None:
2136 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2138 "startTeletext": (self.startTeletext, _("View teletext..."))
2141 print "no teletext plugin found!"
2143 def startTeletext(self):
2144 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2146 class InfoBarSubtitleSupport(object):
2148 object.__init__(self)
2149 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2150 self.__subtitles_enabled = False
2152 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2154 iPlayableService.evEnd: self.__serviceStopped,
2155 iPlayableService.evUpdatedInfo: self.__updatedInfo
2157 self.cached_subtitle_checked = False
2158 self.__selected_subtitle = None
2160 def __serviceStopped(self):
2161 self.subtitle_window.hide()
2162 self.__subtitles_enabled = False
2163 self.cached_subtitle_checked = False
2165 def __updatedInfo(self):
2166 if not self.cached_subtitle_checked:
2167 subtitle = self.getCurrentServiceSubtitle()
2168 self.cached_subtitle_checked = True
2169 self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()
2170 if self.__selected_subtitle:
2171 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2172 self.subtitle_window.show()
2173 self.__subtitles_enabled = True
2175 def getCurrentServiceSubtitle(self):
2176 service = self.session.nav.getCurrentService()
2177 return service and service.subtitle()
2179 def setSubtitlesEnable(self, enable=True):
2180 subtitle = self.getCurrentServiceSubtitle()
2181 if enable and self.__selected_subtitle is not None:
2182 if subtitle and not self.__subtitles_enabled:
2183 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2184 self.subtitle_window.show()
2185 self.__subtitles_enabled = True
2188 subtitle.disableSubtitles(self.subtitle_window.instance)
2189 self.__subtitles_enabled = False
2190 self.subtitle_window.hide()
2192 def setSelectedSubtitle(self, subtitle):
2193 self.__selected_subtitle = subtitle
2195 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2196 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2198 class InfoBarServiceErrorPopupSupport:
2200 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2202 iPlayableService.evTuneFailed: self.__tuneFailed,
2203 iPlayableService.evStart: self.__serviceStarted
2205 self.__serviceStarted()
2207 def __serviceStarted(self):
2208 self.last_error = None
2209 Notifications.RemovePopup(id = "ZapError")
2211 def __tuneFailed(self):
2212 service = self.session.nav.getCurrentService()
2213 info = service and service.info()
2214 error = info and info.getInfo(iServiceInformation.sDVBState)
2216 if error == self.last_error:
2219 self.last_error = error
2222 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2223 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2224 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2225 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2226 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2227 eDVBServicePMTHandler.eventNewProgramInfo: None,
2228 eDVBServicePMTHandler.eventTuned: None,
2229 eDVBServicePMTHandler.eventSOF: None,
2230 eDVBServicePMTHandler.eventEOF: None,
2231 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2232 }.get(error) #this returns None when the key not exist in the dict
2234 if error is not None:
2235 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2237 Notifications.RemovePopup(id = "ZapError")