1 from ChannelSelection import ChannelSelection, BouquetSelector, SilentBouquetSelector
3 from Components.ActionMap import ActionMap, HelpableActionMap
4 from Components.ActionMap import NumberActionMap
5 from Components.Harddisk import harddiskmanager
6 from Components.Input import Input
7 from Components.Label import Label
8 from Components.PluginComponent import plugins
9 from Components.ServiceEventTracker import ServiceEventTracker
10 from Components.Sources.Boolean import Boolean
11 from Components.config import config, ConfigBoolean, ConfigClock
12 from Components.SystemInfo import SystemInfo
13 from Components.UsageConfig import preferredInstantRecordPath, defaultMoviePath
14 from EpgSelection import EPGSelection
15 from Plugins.Plugin import PluginDescriptor
17 from Screen import Screen
18 from Screens.ChoiceBox import ChoiceBox
19 from Screens.Dish import Dish
20 from Screens.EventView import EventViewEPGSelect, EventViewSimple
21 from Screens.InputBox import InputBox
22 from Screens.MessageBox import MessageBox
23 from Screens.MinuteInput import MinuteInput
24 from Screens.TimerSelection import TimerSelection
25 from Screens.PictureInPicture import PictureInPicture
26 from Screens.SubtitleDisplay import SubtitleDisplay
27 from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
28 from Screens.TimeDateInput import TimeDateInput
29 from Screens.UnhandledKey import UnhandledKey
30 from ServiceReference import ServiceReference
32 from Tools import Notifications
33 from Tools.Directories import fileExists
35 from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
36 iPlayableService, eServiceReference, eEPGCache, eActionMap
38 from time import time, localtime, strftime
39 from os import stat as os_stat
40 from bisect import insort
42 from RecordTimer import RecordTimerEntry, RecordTimer
45 from Menu import MainMenu, mdom
49 self.dishDialog = self.session.instantiateDialog(Dish)
51 class InfoBarUnhandledKey:
53 self.unhandledKeyDialog = self.session.instantiateDialog(UnhandledKey)
54 self.hideUnhandledKeySymbolTimer = eTimer()
55 self.hideUnhandledKeySymbolTimer.callback.append(self.unhandledKeyDialog.hide)
56 self.checkUnusedTimer = eTimer()
57 self.checkUnusedTimer.callback.append(self.checkUnused)
58 self.onLayoutFinish.append(self.unhandledKeyDialog.hide)
59 eActionMap.getInstance().bindAction('', -0x7FFFFFFF, self.actionA) #highest prio
60 eActionMap.getInstance().bindAction('', 0x7FFFFFFF, self.actionB) #lowest prio
64 #this function is called on every keypress!
65 def actionA(self, key, flag):
67 if self.flags & (1<<1):
68 self.flags = self.uflags = 0
69 self.flags |= (1<<flag)
71 self.checkUnusedTimer.start(0, True)
74 #this function is only called when no other action has handled this key
75 def actionB(self, key, flag):
77 self.uflags |= (1<<flag)
79 def checkUnused(self):
80 if self.flags == self.uflags:
81 self.unhandledKeyDialog.show()
82 self.hideUnhandledKeySymbolTimer.start(2000, True)
84 class InfoBarShowHide:
85 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
93 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
95 "toggleShow": self.toggleShow,
97 }, 1) # lower prio to make it possible to override ok and cancel..
99 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
101 iPlayableService.evStart: self.serviceStarted,
104 self.__state = self.STATE_SHOWN
107 self.hideTimer = eTimer()
108 self.hideTimer.callback.append(self.doTimerHide)
109 self.hideTimer.start(5000, True)
111 self.onShow.append(self.__onShow)
112 self.onHide.append(self.__onHide)
114 def serviceStarted(self):
116 if config.usage.show_infobar_on_zap.value:
120 self.__state = self.STATE_SHOWN
121 self.startHideTimer()
123 def startHideTimer(self):
124 if self.__state == self.STATE_SHOWN and not self.__locked:
125 idx = config.usage.infobar_timeout.index
127 self.hideTimer.start(idx*1000, True)
130 self.__state = self.STATE_HIDDEN
134 self.startHideTimer()
136 def doTimerHide(self):
137 self.hideTimer.stop()
138 if self.__state == self.STATE_SHOWN:
141 def toggleShow(self):
142 if self.__state == self.STATE_SHOWN:
144 self.hideTimer.stop()
145 elif self.__state == self.STATE_HIDDEN:
149 self.__locked = self.__locked + 1
152 self.hideTimer.stop()
154 def unlockShow(self):
155 self.__locked = self.__locked - 1
157 self.startHideTimer()
159 # def startShow(self):
160 # self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
161 # self.__state = self.STATE_SHOWN
163 # def startHide(self):
164 # self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
165 # self.__state = self.STATE_HIDDEN
167 class NumberZap(Screen):
174 self.close(int(self["number"].getText()))
176 def keyNumberGlobal(self, number):
177 self.Timer.start(3000, True) #reset timer
178 self.field = self.field + str(number)
179 self["number"].setText(self.field)
180 if len(self.field) >= 4:
183 def __init__(self, session, number):
184 Screen.__init__(self, session)
185 self.field = str(number)
187 self["channel"] = Label(_("Channel:"))
189 self["number"] = Label(self.field)
191 self["actions"] = NumberActionMap( [ "SetupActions" ],
195 "1": self.keyNumberGlobal,
196 "2": self.keyNumberGlobal,
197 "3": self.keyNumberGlobal,
198 "4": self.keyNumberGlobal,
199 "5": self.keyNumberGlobal,
200 "6": self.keyNumberGlobal,
201 "7": self.keyNumberGlobal,
202 "8": self.keyNumberGlobal,
203 "9": self.keyNumberGlobal,
204 "0": self.keyNumberGlobal
207 self.Timer = eTimer()
208 self.Timer.callback.append(self.keyOK)
209 self.Timer.start(3000, True)
211 class InfoBarNumberZap:
212 """ Handles an initial number for NumberZapping """
214 self["NumberActions"] = NumberActionMap( [ "NumberActions"],
216 "1": self.keyNumberGlobal,
217 "2": self.keyNumberGlobal,
218 "3": self.keyNumberGlobal,
219 "4": self.keyNumberGlobal,
220 "5": self.keyNumberGlobal,
221 "6": self.keyNumberGlobal,
222 "7": self.keyNumberGlobal,
223 "8": self.keyNumberGlobal,
224 "9": self.keyNumberGlobal,
225 "0": self.keyNumberGlobal,
228 def keyNumberGlobal(self, number):
229 # print "You pressed number " + str(number)
231 if isinstance(self, InfoBarPiP) and self.pipHandles0Action():
232 self.pipDoHandle0Action()
234 self.servicelist.recallPrevService()
236 if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
237 self.session.openWithCallback(self.numberEntered, NumberZap, number)
239 def numberEntered(self, retval):
240 # print self.servicelist
242 self.zapToNumber(retval)
244 def searchNumberHelper(self, serviceHandler, num, bouquet):
245 servicelist = serviceHandler.list(bouquet)
246 if not servicelist is None:
248 serviceIterator = servicelist.getNext()
249 if not serviceIterator.valid(): #check end of list
251 playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
254 if not num: #found service with searched number ?
255 return serviceIterator, 0
258 def zapToNumber(self, number):
259 bouquet = self.servicelist.bouquet_root
261 serviceHandler = eServiceCenter.getInstance()
262 if not config.usage.multibouquet.value:
263 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
265 bouquetlist = serviceHandler.list(bouquet)
266 if not bouquetlist is None:
268 bouquet = bouquetlist.getNext()
269 if not bouquet.valid(): #check end of list
271 if bouquet.flags & eServiceReference.isDirectory:
272 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
273 if not service is None:
274 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
275 self.servicelist.clearPath()
276 if self.servicelist.bouquet_root != bouquet:
277 self.servicelist.enterPath(self.servicelist.bouquet_root)
278 self.servicelist.enterPath(bouquet)
279 self.servicelist.setCurrentSelection(service) #select the service in servicelist
280 self.servicelist.zap()
282 config.misc.initialchannelselection = ConfigBoolean(default = True)
284 class InfoBarChannelSelection:
285 """ ChannelSelection - handles the channelSelection dialog and the initial
286 channelChange actions which open the channelSelection dialog """
289 self.servicelist = self.session.instantiateDialog(ChannelSelection)
291 if config.misc.initialchannelselection.value:
292 self.onShown.append(self.firstRun)
294 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
296 "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
297 "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
298 "zapUp": (self.zapUp, _("previous channel")),
299 "zapDown": (self.zapDown, _("next channel")),
300 "historyBack": (self.historyBack, _("previous channel in history")),
301 "historyNext": (self.historyNext, _("next channel in history")),
302 "openServiceList": (self.openServiceList, _("open servicelist")),
305 def showTvChannelList(self, zap=False):
306 self.servicelist.setModeTv()
308 self.servicelist.zap()
309 self.session.execDialog(self.servicelist)
311 def showRadioChannelList(self, zap=False):
312 self.servicelist.setModeRadio()
314 self.servicelist.zap()
315 self.session.execDialog(self.servicelist)
318 self.onShown.remove(self.firstRun)
319 config.misc.initialchannelselection.value = False
320 config.misc.initialchannelselection.save()
321 self.switchChannelDown()
323 def historyBack(self):
324 self.servicelist.historyBack()
326 def historyNext(self):
327 self.servicelist.historyNext()
329 def switchChannelUp(self):
330 self.servicelist.moveUp()
331 self.session.execDialog(self.servicelist)
333 def switchChannelDown(self):
334 self.servicelist.moveDown()
335 self.session.execDialog(self.servicelist)
337 def openServiceList(self):
338 self.session.execDialog(self.servicelist)
341 if self.servicelist.inBouquet():
342 prev = self.servicelist.getCurrentSelection()
344 prev = prev.toString()
346 if config.usage.quickzap_bouquet_change.value:
347 if self.servicelist.atBegin():
348 self.servicelist.prevBouquet()
349 self.servicelist.moveUp()
350 cur = self.servicelist.getCurrentSelection()
351 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
354 self.servicelist.moveUp()
355 self.servicelist.zap()
358 if self.servicelist.inBouquet():
359 prev = self.servicelist.getCurrentSelection()
361 prev = prev.toString()
363 if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
364 self.servicelist.nextBouquet()
366 self.servicelist.moveDown()
367 cur = self.servicelist.getCurrentSelection()
368 if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
371 self.servicelist.moveDown()
372 self.servicelist.zap()
375 """ Handles a menu action, to open the (main) menu """
377 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
379 "mainMenu": (self.mainMenu, _("Enter main menu...")),
381 self.session.infobar = None
384 print "loading mainmenu XML..."
385 menu = mdom.getroot()
386 assert menu.tag == "menu", "root element in menu must be 'menu'!"
388 self.session.infobar = self
389 # so we can access the currently active infobar from screens opened from within the mainmenu
390 # at the moment used from the SubserviceSelection
392 self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)
394 def mainMenuClosed(self, *val):
395 self.session.infobar = None
397 class InfoBarSimpleEventView:
398 """ Opens the Eventview for now/next """
400 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
402 "showEventInfo": (self.openEventView, _("show event details")),
403 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
406 def showEventInfoWhenNotVisible(self):
413 def openEventView(self):
415 self.epglist = epglist
416 service = self.session.nav.getCurrentService()
417 ref = self.session.nav.getCurrentlyPlayingServiceReference()
418 info = service.info()
426 self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
428 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
429 epglist = self.epglist
432 epglist[0] = epglist[1]
436 class SimpleServicelist:
437 def __init__(self, services):
438 self.services = services
439 self.length = len(services)
442 def selectService(self, service):
448 while self.services[self.current].ref != service:
450 if self.current >= self.length:
454 def nextService(self):
457 if self.current+1 < self.length:
462 def prevService(self):
465 if self.current-1 > -1:
468 self.current = self.length - 1
470 def currentService(self):
471 if not self.length or self.current >= self.length:
473 return self.services[self.current]
476 """ EPG - Opens an EPG list when the showEPGList action fires """
478 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
480 iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
483 self.is_now_next = False
485 self.bouquetSel = None
486 self.eventView = None
487 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
489 "showEventInfo": (self.openEventView, _("show EPG...")),
490 "showEventInfoPlugin": (self.showEventInfoPlugins, _("list of EPG views...")),
491 "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
494 def showEventInfoWhenNotVisible(self):
501 def zapToService(self, service):
502 if not service is None:
503 if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
504 self.servicelist.clearPath()
505 if self.servicelist.bouquet_root != self.epg_bouquet:
506 self.servicelist.enterPath(self.servicelist.bouquet_root)
507 self.servicelist.enterPath(self.epg_bouquet)
508 self.servicelist.setCurrentSelection(service) #select the service in servicelist
509 self.servicelist.zap()
511 def getBouquetServices(self, bouquet):
513 servicelist = eServiceCenter.getInstance().list(bouquet)
514 if not servicelist is None:
516 service = servicelist.getNext()
517 if not service.valid(): #check if end of list
519 if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
521 services.append(ServiceReference(service))
524 def openBouquetEPG(self, bouquet, withCallback=True):
525 services = self.getBouquetServices(bouquet)
527 self.epg_bouquet = bouquet
529 self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
531 self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
533 def changeBouquetCB(self, direction, epg):
536 self.bouquetSel.down()
539 bouquet = self.bouquetSel.getCurrent()
540 services = self.getBouquetServices(bouquet)
542 self.epg_bouquet = bouquet
543 epg.setServices(services)
545 def closed(self, ret=False):
546 closedScreen = self.dlg_stack.pop()
547 if self.bouquetSel and closedScreen == self.bouquetSel:
548 self.bouquetSel = None
549 elif self.eventView and closedScreen == self.eventView:
550 self.eventView = None
552 dlgs=len(self.dlg_stack)
554 self.dlg_stack[dlgs-1].close(dlgs > 1)
556 def openMultiServiceEPG(self, withCallback=True):
557 bouquets = self.servicelist.getBouquetList()
558 root = self.servicelist.getRoot()
563 if cnt > 1: # create bouquet list for bouq+/-
564 self.bouquetSel = SilentBouquetSelector(bouquets, True, self.servicelist.getBouquetNumOffset(root))
566 self.openBouquetEPG(root, withCallback)
568 def changeServiceCB(self, direction, epg):
571 self.serviceSel.nextService()
573 self.serviceSel.prevService()
574 epg.setService(self.serviceSel.currentService())
576 def SingleServiceEPGClosed(self, ret=False):
577 self.serviceSel = None
579 def openSingleServiceEPG(self):
580 ref=self.session.nav.getCurrentlyPlayingServiceReference()
582 if self.servicelist.getMutableList() is not None: # bouquet in channellist
583 current_path = self.servicelist.getRoot()
584 services = self.getBouquetServices(current_path)
585 self.serviceSel = SimpleServicelist(services)
586 if self.serviceSel.selectService(ref):
587 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
589 self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref)
591 self.session.open(EPGSelection, ref)
593 def showEventInfoPlugins(self):
594 list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
597 list.append((_("show single service EPG..."), self.openSingleServiceEPG))
598 list.append((_("Multi EPG"), self.openMultiServiceEPG))
599 self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
601 self.openSingleServiceEPG()
603 def runPlugin(self, plugin):
604 plugin(session = self.session, servicelist = self.servicelist)
606 def EventInfoPluginChosen(self, answer):
607 if answer is not None:
610 def openSimilarList(self, eventid, refstr):
611 self.session.open(EPGSelection, refstr, None, eventid)
613 def getNowNext(self):
615 service = self.session.nav.getCurrentService()
616 info = service and service.info()
617 ptr = info and info.getEvent(0)
620 ptr = info and info.getEvent(1)
623 self.epglist = epglist
625 def __evEventInfoChanged(self):
626 if self.is_now_next and len(self.dlg_stack) == 1:
628 assert self.eventView
630 self.eventView.setEvent(self.epglist[0])
632 def openEventView(self):
633 ref = self.session.nav.getCurrentlyPlayingServiceReference()
635 epglist = self.epglist
637 self.is_now_next = False
638 epg = eEPGCache.getInstance()
639 ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
642 ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
646 self.is_now_next = True
648 self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
649 self.dlg_stack.append(self.eventView)
651 print "no epg for the service avail.. so we show multiepg instead of eventinfo"
652 self.openMultiServiceEPG(False)
654 def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
655 epglist = self.epglist
658 epglist[0]=epglist[1]
662 class InfoBarRdsDecoder:
663 """provides RDS and Rass support/display"""
665 self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
666 self.rass_interactive = None
668 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
670 iPlayableService.evEnd: self.__serviceStopped,
671 iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
674 self["RdsActions"] = ActionMap(["InfobarRdsActions"],
676 "startRassInteractive": self.startRassInteractive
679 self["RdsActions"].setEnabled(False)
681 self.onLayoutFinish.append(self.rds_display.show)
682 self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
684 def RassInteractivePossibilityChanged(self, state):
685 self["RdsActions"].setEnabled(state)
687 def RassSlidePicChanged(self):
688 if not self.rass_interactive:
689 service = self.session.nav.getCurrentService()
690 decoder = service and service.rdsDecoder()
692 decoder.showRassSlidePicture()
694 def __serviceStopped(self):
695 if self.rass_interactive is not None:
696 rass_interactive = self.rass_interactive
697 self.rass_interactive = None
698 rass_interactive.close()
700 def startRassInteractive(self):
701 self.rds_display.hide()
702 self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
704 def RassInteractiveClosed(self, *val):
705 if self.rass_interactive is not None:
706 self.rass_interactive = None
707 self.RassSlidePicChanged()
708 self.rds_display.show()
711 """handles actions like seeking, pause"""
713 SEEK_STATE_PLAY = (0, 0, 0, ">")
714 SEEK_STATE_PAUSE = (1, 0, 0, "||")
715 SEEK_STATE_EOF = (1, 0, 0, "END")
717 def __init__(self, actionmap = "InfobarSeekActions"):
718 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
720 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
721 iPlayableService.evStart: self.__serviceStarted,
723 iPlayableService.evEOF: self.__evEOF,
724 iPlayableService.evSOF: self.__evSOF,
726 self.fast_winding_hint_message_showed = False
728 class InfoBarSeekActionMap(HelpableActionMap):
729 def __init__(self, screen, *args, **kwargs):
730 HelpableActionMap.__init__(self, screen, *args, **kwargs)
733 def action(self, contexts, action):
734 print "action:", action
735 if action[:5] == "seek:":
736 time = int(action[5:])
737 self.screen.doSeekRelative(time * 90000)
739 elif action[:8] == "seekdef:":
740 key = int(action[8:])
741 time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
742 -config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
743 -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
744 self.screen.doSeekRelative(time * 90000)
747 return HelpableActionMap.action(self, contexts, action)
749 self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
751 "playpauseService": self.playpauseService,
752 "pauseService": (self.pauseService, _("pause")),
753 "unPauseService": (self.unPauseService, _("continue")),
755 "seekFwd": (self.seekFwd, _("skip forward")),
756 "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
757 "seekBack": (self.seekBack, _("skip backward")),
758 "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
760 # give them a little more priority to win over color buttons
762 self["SeekActions"].setEnabled(False)
764 self.seekstate = self.SEEK_STATE_PLAY
765 self.lastseekstate = self.SEEK_STATE_PLAY
767 self.onPlayStateChanged = [ ]
769 self.lockedBecauseOfSkipping = False
771 self.__seekableStatusChanged()
773 def makeStateForward(self, n):
774 return (0, n, 0, ">> %dx" % n)
776 def makeStateBackward(self, n):
777 return (0, -n, 0, "<< %dx" % n)
779 def makeStateSlowMotion(self, n):
780 return (0, 0, n, "/%d" % n)
782 def isStateForward(self, state):
785 def isStateBackward(self, state):
788 def isStateSlowMotion(self, state):
789 return state[1] == 0 and state[2] > 1
791 def getHigher(self, n, lst):
797 def getLower(self, n, lst):
805 def showAfterSeek(self):
806 if isinstance(self, InfoBarShowHide):
816 service = self.session.nav.getCurrentService()
820 seek = service.seek()
822 if seek is None or not seek.isCurrentlySeekable():
827 def isSeekable(self):
828 if self.getSeek() is None:
832 def __seekableStatusChanged(self):
833 # print "seekable status changed!"
834 if not self.isSeekable():
835 self["SeekActions"].setEnabled(False)
836 # print "not seekable, return to play"
837 self.setSeekState(self.SEEK_STATE_PLAY)
839 self["SeekActions"].setEnabled(True)
842 def __serviceStarted(self):
843 self.fast_winding_hint_message_showed = False
844 self.seekstate = self.SEEK_STATE_PLAY
845 self.__seekableStatusChanged()
847 def setSeekState(self, state):
848 service = self.session.nav.getCurrentService()
853 if not self.isSeekable():
854 if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
855 state = self.SEEK_STATE_PLAY
857 pauseable = service.pause()
859 if pauseable is None:
860 print "not pauseable."
861 state = self.SEEK_STATE_PLAY
863 self.seekstate = state
865 if pauseable is not None:
866 if self.seekstate[0]:
867 print "resolved to PAUSE"
869 elif self.seekstate[1]:
870 print "resolved to FAST FORWARD"
871 pauseable.setFastForward(self.seekstate[1])
872 elif self.seekstate[2]:
873 print "resolved to SLOW MOTION"
874 pauseable.setSlowMotion(self.seekstate[2])
876 print "resolved to PLAY"
879 for c in self.onPlayStateChanged:
882 self.checkSkipShowHideLock()
886 def playpauseService(self):
887 if self.seekstate != self.SEEK_STATE_PLAY:
888 self.unPauseService()
892 def pauseService(self):
893 if self.seekstate == self.SEEK_STATE_PAUSE:
894 if config.seek.on_pause.value == "play":
895 self.unPauseService()
896 elif config.seek.on_pause.value == "step":
897 self.doSeekRelative(1)
898 elif config.seek.on_pause.value == "last":
899 self.setSeekState(self.lastseekstate)
900 self.lastseekstate = self.SEEK_STATE_PLAY
902 if self.seekstate != self.SEEK_STATE_EOF:
903 self.lastseekstate = self.seekstate
904 self.setSeekState(self.SEEK_STATE_PAUSE);
906 def unPauseService(self):
908 if self.seekstate == self.SEEK_STATE_PLAY:
910 self.setSeekState(self.SEEK_STATE_PLAY)
912 def doSeek(self, pts):
913 seekable = self.getSeek()
918 def doSeekRelative(self, pts):
919 seekable = self.getSeek()
922 prevstate = self.seekstate
924 if self.seekstate == self.SEEK_STATE_EOF:
925 if prevstate == self.SEEK_STATE_PAUSE:
926 self.setSeekState(self.SEEK_STATE_PAUSE)
928 self.setSeekState(self.SEEK_STATE_PLAY)
929 seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
930 if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
934 seek = self.getSeek()
935 if seek and not (seek.isCurrentlySeekable() & 2):
936 if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
937 self.session.open(MessageBox, _("No fast winding possible yet.. but you can use the number buttons to skip forward/backward!"), MessageBox.TYPE_INFO, timeout=10)
938 self.fast_winding_hint_message_showed = True
940 return 0 # trade as unhandled action
941 if self.seekstate == self.SEEK_STATE_PLAY:
942 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
943 elif self.seekstate == self.SEEK_STATE_PAUSE:
944 if len(config.seek.speeds_slowmotion.value):
945 self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
947 self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
948 elif self.seekstate == self.SEEK_STATE_EOF:
950 elif self.isStateForward(self.seekstate):
951 speed = self.seekstate[1]
952 if self.seekstate[2]:
953 speed /= self.seekstate[2]
954 speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
955 self.setSeekState(self.makeStateForward(speed))
956 elif self.isStateBackward(self.seekstate):
957 speed = -self.seekstate[1]
958 if self.seekstate[2]:
959 speed /= self.seekstate[2]
960 speed = self.getLower(speed, config.seek.speeds_backward.value)
962 self.setSeekState(self.makeStateBackward(speed))
964 self.setSeekState(self.SEEK_STATE_PLAY)
965 elif self.isStateSlowMotion(self.seekstate):
966 speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
967 self.setSeekState(self.makeStateSlowMotion(speed))
970 seek = self.getSeek()
971 if seek and not (seek.isCurrentlySeekable() & 2):
972 if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
973 self.session.open(MessageBox, _("No fast winding possible yet.. but you can use the number buttons to skip forward/backward!"), MessageBox.TYPE_INFO, timeout=10)
974 self.fast_winding_hint_message_showed = True
976 return 0 # trade as unhandled action
977 seekstate = self.seekstate
978 if seekstate == self.SEEK_STATE_PLAY:
979 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
980 elif seekstate == self.SEEK_STATE_EOF:
981 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
982 self.doSeekRelative(-6)
983 elif seekstate == self.SEEK_STATE_PAUSE:
984 self.doSeekRelative(-1)
985 elif self.isStateForward(seekstate):
988 speed /= seekstate[2]
989 speed = self.getLower(speed, config.seek.speeds_forward.value)
991 self.setSeekState(self.makeStateForward(speed))
993 self.setSeekState(self.SEEK_STATE_PLAY)
994 elif self.isStateBackward(seekstate):
995 speed = -seekstate[1]
997 speed /= seekstate[2]
998 speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
999 self.setSeekState(self.makeStateBackward(speed))
1000 elif self.isStateSlowMotion(seekstate):
1001 speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
1003 self.setSeekState(self.makeStateSlowMotion(speed))
1005 self.setSeekState(self.SEEK_STATE_PAUSE)
1007 def seekFwdManual(self):
1008 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
1010 def fwdSeekTo(self, minutes):
1011 print "Seek", minutes, "minutes forward"
1012 self.doSeekRelative(minutes * 60 * 90000)
1014 def seekBackManual(self):
1015 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
1017 def rwdSeekTo(self, minutes):
1019 self.doSeekRelative(-minutes * 60 * 90000)
1021 def checkSkipShowHideLock(self):
1022 wantlock = self.seekstate != self.SEEK_STATE_PLAY
1024 if config.usage.show_infobar_on_skip.value:
1025 if self.lockedBecauseOfSkipping and not wantlock:
1027 self.lockedBecauseOfSkipping = False
1029 if wantlock and not self.lockedBecauseOfSkipping:
1031 self.lockedBecauseOfSkipping = True
1033 def calcRemainingTime(self):
1034 seekable = self.getSeek()
1035 if seekable is not None:
1036 len = seekable.getLength()
1038 tmp = self.cueGetEndCutPosition()
1043 pos = seekable.getPlayPosition()
1044 speednom = self.seekstate[1] or 1
1045 speedden = self.seekstate[2] or 1
1046 if not len[0] and not pos[0]:
1047 if len[1] <= pos[1]:
1049 time = (len[1] - pos[1])*speedden/(90*speednom)
1054 if self.seekstate == self.SEEK_STATE_EOF:
1057 # if we are seeking forward, we try to end up ~1s before the end, and pause there.
1058 seekstate = self.seekstate
1059 if self.seekstate != self.SEEK_STATE_PAUSE:
1060 self.setSeekState(self.SEEK_STATE_EOF)
1062 if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
1063 seekable = self.getSeek()
1064 if seekable is not None:
1066 if seekstate == self.SEEK_STATE_PLAY: # regular EOF
1067 self.doEofInternal(True)
1069 self.doEofInternal(False)
1071 def doEofInternal(self, playing):
1072 pass # Defined in subclasses
1075 self.setSeekState(self.SEEK_STATE_PLAY)
1078 from Screens.PVRState import PVRState, TimeshiftState
1080 class InfoBarPVRState:
1081 def __init__(self, screen=PVRState, force_show = False):
1082 self.onPlayStateChanged.append(self.__playStateChanged)
1083 self.pvrStateDialog = self.session.instantiateDialog(screen)
1084 self.onShow.append(self._mayShow)
1085 self.onHide.append(self.pvrStateDialog.hide)
1086 self.force_show = force_show
1089 if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
1090 self.pvrStateDialog.show()
1092 def __playStateChanged(self, state):
1093 playstateString = state[3]
1094 self.pvrStateDialog["state"].setText(playstateString)
1096 # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
1097 if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
1098 self.pvrStateDialog.hide()
1102 class InfoBarTimeshiftState(InfoBarPVRState):
1104 InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
1105 self.__hideTimer = eTimer()
1106 self.__hideTimer.callback.append(self.__hideTimeshiftState)
1109 if self.execing and self.timeshift_enabled:
1110 self.pvrStateDialog.show()
1111 if self.seekstate == self.SEEK_STATE_PLAY and not self.shown:
1112 self.__hideTimer.start(5*1000, True)
1114 def __hideTimeshiftState(self):
1115 self.pvrStateDialog.hide()
1117 class InfoBarShowMovies:
1119 # i don't really like this class.
1120 # it calls a not further specified "movie list" on up/down/movieList,
1121 # so this is not more than an action map
1123 self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
1125 "movieList": (self.showMovies, _("movie list")),
1126 "up": (self.showMovies, _("movie list")),
1127 "down": (self.showMovies, _("movie list"))
1130 # InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
1134 # Timeshift works the following way:
1135 # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
1136 # - normal playback TUNER unused PLAY enable disable disable
1137 # - user presses "yellow" button. FILE record PAUSE enable disable enable
1138 # - user presess pause again FILE record PLAY enable disable enable
1139 # - user fast forwards FILE record FF enable disable enable
1140 # - end of timeshift buffer reached TUNER record PLAY enable enable disable
1141 # - user backwards FILE record BACK # !! enable disable enable
1145 # - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
1146 # freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
1147 # now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
1148 # - the user can now PVR around
1149 # - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
1150 # the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
1152 # the seek actions will be disabled, but the timeshiftActivateActions will be enabled
1153 # - if the user rewinds, or press pause, timeshift will be activated again
1155 # note that a timeshift can be enabled ("recording") and
1156 # activated (currently time-shifting).
1158 class InfoBarTimeshift:
1160 self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
1162 "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
1163 "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
1165 self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
1167 "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
1168 "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
1169 }, prio=-1) # priority over record
1171 self.timeshift_enabled = 0
1172 self.timeshift_state = 0
1173 self.ts_rewind_timer = eTimer()
1174 self.ts_rewind_timer.callback.append(self.rewindService)
1176 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1178 iPlayableService.evStart: self.__serviceStarted,
1179 iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
1182 def getTimeshift(self):
1183 service = self.session.nav.getCurrentService()
1184 return service and service.timeshift()
1186 def startTimeshift(self):
1187 print "enable timeshift"
1188 ts = self.getTimeshift()
1190 self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
1191 print "no ts interface"
1194 if self.timeshift_enabled:
1195 print "hu, timeshift already enabled?"
1197 if not ts.startTimeshift():
1198 self.timeshift_enabled = 1
1200 # we remove the "relative time" for now.
1201 #self.pvrStateDialog["timeshift"].setRelative(time.time())
1204 #self.setSeekState(self.SEEK_STATE_PAUSE)
1205 self.activateTimeshiftEnd(False)
1207 # enable the "TimeshiftEnableActions", which will override
1208 # the startTimeshift actions
1209 self.__seekableStatusChanged()
1211 print "timeshift failed"
1213 def stopTimeshift(self):
1214 if not self.timeshift_enabled:
1216 print "disable timeshift"
1217 ts = self.getTimeshift()
1220 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
1222 def stopTimeshiftConfirmed(self, confirmed):
1226 ts = self.getTimeshift()
1231 self.timeshift_enabled = 0
1234 self.__seekableStatusChanged()
1236 # activates timeshift, and seeks to (almost) the end
1237 def activateTimeshiftEnd(self, back = True):
1238 ts = self.getTimeshift()
1239 print "activateTimeshiftEnd"
1244 if ts.isTimeshiftActive():
1245 print "!! activate timeshift called - but shouldn't this be a normal pause?"
1249 ts.activateTimeshift() # activate timeshift will automatically pause
1250 self.setSeekState(self.SEEK_STATE_PAUSE)
1253 self.ts_rewind_timer.start(200, 1)
1255 def rewindService(self):
1256 self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
1258 # same as activateTimeshiftEnd, but pauses afterwards.
1259 def activateTimeshiftEndAndPause(self):
1260 print "activateTimeshiftEndAndPause"
1261 #state = self.seekstate
1262 self.activateTimeshiftEnd(False)
1264 def __seekableStatusChanged(self):
1267 # print "self.isSeekable", self.isSeekable()
1268 # print "self.timeshift_enabled", self.timeshift_enabled
1270 # when this service is not seekable, but timeshift
1271 # is enabled, this means we can activate
1273 if not self.isSeekable() and self.timeshift_enabled:
1276 # print "timeshift activate:", enabled
1277 self["TimeshiftActivateActions"].setEnabled(enabled)
1279 def __serviceStarted(self):
1280 self.timeshift_enabled = False
1281 self.__seekableStatusChanged()
1283 from Screens.PiPSetup import PiPSetup
1285 class InfoBarExtensions:
1286 EXTENSION_SINGLE = 0
1292 self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
1294 "extensions": (self.showExtensionSelection, _("view extensions...")),
1295 }, 1) # lower priority
1297 def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
1298 self.list.append((type, extension, key))
1300 def updateExtension(self, extension, key = None):
1301 self.extensionsList.append(extension)
1303 if self.extensionKeys.has_key(key):
1307 for x in self.availableKeys:
1308 if not self.extensionKeys.has_key(x):
1313 self.extensionKeys[key] = len(self.extensionsList) - 1
1315 def updateExtensions(self):
1316 self.extensionsList = []
1317 self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
1318 self.extensionKeys = {}
1320 if x[0] == self.EXTENSION_SINGLE:
1321 self.updateExtension(x[1], x[2])
1324 self.updateExtension(y[0], y[1])
1327 def showExtensionSelection(self):
1328 self.updateExtensions()
1329 extensionsList = self.extensionsList[:]
1332 for x in self.availableKeys:
1333 if self.extensionKeys.has_key(x):
1334 entry = self.extensionKeys[x]
1335 extension = self.extensionsList[entry]
1337 name = str(extension[0]())
1338 list.append((extension[0](), extension))
1340 extensionsList.remove(extension)
1342 extensionsList.remove(extension)
1343 list.extend([(x[0](), x) for x in extensionsList])
1345 keys += [""] * len(extensionsList)
1346 self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
1348 def extensionCallback(self, answer):
1349 if answer is not None:
1352 from Tools.BoundFunction import boundFunction
1355 # depends on InfoBarExtensions
1357 class InfoBarPlugins:
1359 self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
1361 def getPluginName(self, name):
1364 def getPluginList(self):
1366 for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
1367 args = inspect.getargspec(p.__call__)[0]
1368 if len(args) == 1 or len(args) == 2 and isinstance(self, InfoBarChannelSelection):
1369 l.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name))
1370 l.sort(key = lambda e: e[2]) # sort by name
1373 def runPlugin(self, plugin):
1374 if isinstance(self, InfoBarChannelSelection):
1375 plugin(session = self.session, servicelist = self.servicelist)
1377 plugin(session = self.session)
1379 from Components.Task import job_manager
1380 class InfoBarJobman:
1382 self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
1384 def getJobList(self):
1385 return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
1387 def getJobName(self, job):
1388 return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
1390 def showJobView(self, job):
1391 from Screens.TaskView import JobView
1392 job_manager.in_background = False
1393 self.session.openWithCallback(self.JobViewCB, JobView, job)
1395 def JobViewCB(self, in_background):
1396 job_manager.in_background = in_background
1398 # depends on InfoBarExtensions
1402 self.session.pipshown
1404 self.session.pipshown = False
1405 if SystemInfo.get("NumVideoDecoders", 1) > 1:
1407 self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
1408 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1409 self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
1411 self.addExtension((self.getShowHideName, self.showPiP, self.pipShown), "blue")
1412 self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
1415 return self.session.pipshown
1417 def pipHandles0Action(self):
1418 return self.pipShown() and config.usage.pip_zero_button.value != "standard"
1420 def getShowHideName(self):
1421 if self.session.pipshown:
1422 return _("Disable Picture in Picture")
1424 return _("Activate Picture in Picture")
1426 def getSwapName(self):
1427 return _("Swap Services")
1429 def getMoveName(self):
1430 return _("Move Picture in Picture")
1433 if self.session.pipshown:
1434 del self.session.pip
1435 self.session.pipshown = False
1437 self.session.pip = self.session.instantiateDialog(PictureInPicture)
1438 self.session.pip.show()
1439 newservice = self.session.nav.getCurrentlyPlayingServiceReference()
1440 if self.session.pip.playService(newservice):
1441 self.session.pipshown = True
1442 self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
1444 self.session.pipshown = False
1445 del self.session.pip
1446 self.session.nav.playService(newservice)
1449 swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
1450 if self.session.pip.servicePath:
1451 servicepath = self.servicelist.getCurrentServicePath()
1452 ref=servicepath[len(servicepath)-1]
1453 pipref=self.session.pip.getCurrentService()
1454 self.session.pip.playService(swapservice)
1455 self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
1456 if pipref.toString() != ref.toString(): # is a subservice ?
1457 self.session.nav.stopService() # stop portal
1458 self.session.nav.playService(pipref) # start subservice
1459 self.session.pip.servicePath=servicepath
1462 self.session.open(PiPSetup, pip = self.session.pip)
1464 def pipDoHandle0Action(self):
1465 use = config.usage.pip_zero_button.value
1468 elif "swapstop" == use:
1474 from RecordTimer import parseEvent, RecordTimerEntry
1476 class InfoBarInstantRecord:
1477 """Instant Record - handles the instantRecord action in order to
1478 start/stop instant records"""
1480 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
1482 "instantRecord": (self.instantRecord, _("Instant Record...")),
1486 def stopCurrentRecording(self, entry = -1):
1487 if entry is not None and entry != -1:
1488 self.session.nav.RecordTimer.removeEntry(self.recording[entry])
1489 self.recording.remove(self.recording[entry])
1491 def startInstantRecording(self, limitEvent = False):
1492 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
1494 # try to get event info
1497 service = self.session.nav.getCurrentService()
1498 epg = eEPGCache.getInstance()
1499 event = epg.lookupEventTime(serviceref, -1, 0)
1501 info = service.info()
1502 ev = info.getEvent(0)
1508 end = begin + 3600 # dummy
1509 name = "instant record"
1513 if event is not None:
1514 curEvent = parseEvent(event)
1516 description = curEvent[3]
1517 eventid = curEvent[4]
1522 self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
1524 if isinstance(serviceref, eServiceReference):
1525 serviceref = ServiceReference(serviceref)
1527 recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = preferredInstantRecordPath())
1528 recording.dontSave = True
1530 if event is None or limitEvent == False:
1531 recording.autoincrease = True
1532 recording.setAutoincreaseEnd()
1534 simulTimerList = self.session.nav.RecordTimer.record(recording)
1536 if simulTimerList is None: # no conflict
1537 self.recording.append(recording)
1539 if len(simulTimerList) > 1: # with other recording
1540 name = simulTimerList[1].name
1541 name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
1542 print "[TIMER] conflicts with", name_date
1543 recording.autoincrease = True # start with max available length, then increment
1544 if recording.setAutoincreaseEnd():
1545 self.session.nav.RecordTimer.record(recording)
1546 self.recording.append(recording)
1547 self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
1549 self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
1551 self.session.open(MessageBox, _("Couldn't record due to invalid service %s") % serviceref, MessageBox.TYPE_INFO)
1552 recording.autoincrease = False
1554 def isInstantRecordRunning(self):
1555 print "self.recording:", self.recording
1557 for x in self.recording:
1562 def recordQuestionCallback(self, answer):
1563 print "pre:\n", self.recording
1565 if answer is None or answer[1] == "no":
1568 recording = self.recording[:]
1570 if not x in self.session.nav.RecordTimer.timer_list:
1571 self.recording.remove(x)
1572 elif x.dontSave and x.isRunning():
1573 list.append((x, False))
1575 if answer[1] == "changeduration":
1576 if len(self.recording) == 1:
1577 self.changeDuration(0)
1579 self.session.openWithCallback(self.changeDuration, TimerSelection, list)
1580 elif answer[1] == "changeendtime":
1581 if len(self.recording) == 1:
1584 self.session.openWithCallback(self.setEndtime, TimerSelection, list)
1585 elif answer[1] == "stop":
1586 if len(self.recording) == 1:
1587 self.stopCurrentRecording(0)
1589 self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
1590 elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
1591 self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
1592 if answer[1] == "manualduration":
1593 self.changeDuration(len(self.recording)-1)
1594 elif answer[1] == "manualendtime":
1595 self.setEndtime(len(self.recording)-1)
1596 print "after:\n", self.recording
1598 def setEndtime(self, entry):
1599 if entry is not None and entry >= 0:
1600 self.selectedEntry = entry
1601 self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
1602 dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
1603 dlg.setTitle(_("Please change recording endtime"))
1605 def TimeDateInputClosed(self, ret):
1608 localendtime = localtime(ret[1])
1609 print "stopping recording at", strftime("%c", localendtime)
1610 if self.recording[self.selectedEntry].end != ret[1]:
1611 self.recording[self.selectedEntry].autoincrease = False
1612 self.recording[self.selectedEntry].end = ret[1]
1613 self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
1615 def changeDuration(self, entry):
1616 if entry is not None and entry >= 0:
1617 self.selectedEntry = entry
1618 self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
1620 def inputCallback(self, value):
1621 if value is not None:
1622 print "stopping recording after", int(value), "minutes."
1623 entry = self.recording[self.selectedEntry]
1625 entry.autoincrease = False
1626 entry.end = int(time()) + 60 * int(value)
1627 self.session.nav.RecordTimer.timeChanged(entry)
1629 def instantRecord(self):
1630 dir = preferredInstantRecordPath()
1631 if not dir or not fileExists(dir, 'w'):
1632 dir = defaultMoviePath()
1636 # XXX: this message is a little odd as we might be recording to a remote device
1637 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
1640 if self.isInstantRecordRunning():
1641 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1642 title=_("A recording is currently running.\nWhat do you want to do?"), \
1643 list=((_("stop recording"), "stop"), \
1644 (_("add recording (stop after current event)"), "event"), \
1645 (_("add recording (indefinitely)"), "indefinitely"), \
1646 (_("add recording (enter recording duration)"), "manualduration"), \
1647 (_("add recording (enter recording endtime)"), "manualendtime"), \
1648 (_("change recording (duration)"), "changeduration"), \
1649 (_("change recording (endtime)"), "changeendtime"), \
1650 (_("do nothing"), "no")))
1652 self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
1653 title=_("Start recording?"), \
1654 list=((_("add recording (stop after current event)"), "event"), \
1655 (_("add recording (indefinitely)"), "indefinitely"), \
1656 (_("add recording (enter recording duration)"), "manualduration"), \
1657 (_("add recording (enter recording endtime)"), "manualendtime"), \
1658 (_("don't record"), "no")))
1660 from Tools.ISO639 import LanguageCodes
1662 class InfoBarAudioSelection:
1664 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
1666 "audioSelection": (self.audioSelection, _("Audio Options...")),
1669 def audioSelection(self):
1670 from Screens.AudioSelection import AudioSelection
1671 self.session.openWithCallback(self.audioSelected, AudioSelection, infobar=self)
1673 def audioSelected(self, ret=None):
1674 print "[infobar::audioSelected]", ret
1676 class InfoBarSubserviceSelection:
1678 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
1680 "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
1683 self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
1685 "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
1686 "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
1688 self["SubserviceQuickzapAction"].setEnabled(False)
1690 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1692 iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
1697 def checkSubservicesAvail(self):
1698 service = self.session.nav.getCurrentService()
1699 subservices = service and service.subServices()
1700 if not subservices or subservices.getNumberOfSubservices() == 0:
1701 self["SubserviceQuickzapAction"].setEnabled(False)
1703 def nextSubservice(self):
1704 self.changeSubservice(+1)
1706 def prevSubservice(self):
1707 self.changeSubservice(-1)
1709 def changeSubservice(self, direction):
1710 service = self.session.nav.getCurrentService()
1711 subservices = service and service.subServices()
1712 n = subservices and subservices.getNumberOfSubservices()
1715 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1718 if subservices.getSubservice(idx).toString() == ref.toString():
1723 selection += direction
1728 newservice = subservices.getSubservice(selection)
1729 if newservice.valid():
1732 self.session.nav.playService(newservice, False)
1734 def subserviceSelection(self):
1735 service = self.session.nav.getCurrentService()
1736 subservices = service and service.subServices()
1737 self.bouquets = self.servicelist.getBouquetList()
1738 n = subservices and subservices.getNumberOfSubservices()
1741 ref = self.session.nav.getCurrentlyPlayingServiceReference()
1745 i = subservices.getSubservice(idx)
1746 if i.toString() == ref.toString():
1748 tlist.append((i.getName(), i))
1751 if self.bouquets and len(self.bouquets):
1752 keys = ["red", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1753 if config.usage.multibouquet.value:
1754 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1756 tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
1759 tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
1760 keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
1763 self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
1765 def subserviceSelected(self, service):
1767 if not service is None:
1768 if isinstance(service[1], str):
1769 if service[1] == "quickzap":
1770 from Screens.SubservicesQuickzap import SubservicesQuickzap
1771 self.session.open(SubservicesQuickzap, service[2])
1773 self["SubserviceQuickzapAction"].setEnabled(True)
1774 self.session.nav.playService(service[1], False)
1776 def addSubserviceToBouquetCallback(self, service):
1777 if len(service) > 1 and isinstance(service[1], eServiceReference):
1778 self.selectedSubservice = service
1779 if self.bouquets is None:
1782 cnt = len(self.bouquets)
1783 if cnt > 1: # show bouquet list
1784 self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
1785 elif cnt == 1: # add to only one existing bouquet
1786 self.addSubserviceToBouquet(self.bouquets[0][1])
1787 self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
1789 def bouquetSelClosed(self, confirmed):
1791 del self.selectedSubservice
1793 self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
1795 def addSubserviceToBouquet(self, dest):
1796 self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
1798 self.bsel.close(True)
1800 del self.selectedSubservice
1802 class InfoBarAdditionalInfo:
1805 self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
1806 self["TimeshiftPossible"] = self["RecordingPossible"]
1807 self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
1808 self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
1809 self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
1810 self["ExtensionsAvailable"] = Boolean(fixed=1)
1812 class InfoBarNotifications:
1814 self.onExecBegin.append(self.checkNotifications)
1815 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
1816 self.onClose.append(self.__removeNotification)
1818 def __removeNotification(self):
1819 Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
1821 def checkNotificationsIfExecing(self):
1823 self.checkNotifications()
1825 def checkNotifications(self):
1826 notifications = Notifications.notifications
1828 n = notifications[0]
1830 del notifications[0]
1833 if n[3].has_key("onSessionOpenCallback"):
1834 n[3]["onSessionOpenCallback"]()
1835 del n[3]["onSessionOpenCallback"]
1838 dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
1840 dlg = self.session.open(n[1], *n[2], **n[3])
1842 # remember that this notification is currently active
1844 Notifications.current_notifications.append(d)
1845 dlg.onClose.append(boundFunction(self.__notificationClosed, d))
1847 def __notificationClosed(self, d):
1848 Notifications.current_notifications.remove(d)
1850 class InfoBarServiceNotifications:
1852 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1854 iPlayableService.evEnd: self.serviceHasEnded
1857 def serviceHasEnded(self):
1858 print "service end!"
1861 self.setSeekState(self.SEEK_STATE_PLAY)
1865 class InfoBarCueSheetSupport:
1871 ENABLE_RESUME_SUPPORT = False
1873 def __init__(self, actionmap = "InfobarCueSheetActions"):
1874 self["CueSheetActions"] = HelpableActionMap(self, actionmap,
1876 "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
1877 "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
1878 "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
1882 self.is_closing = False
1883 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
1885 iPlayableService.evStart: self.__serviceStarted,
1888 def __serviceStarted(self):
1891 print "new service started! trying to download cuts!"
1892 self.downloadCuesheet()
1894 if self.ENABLE_RESUME_SUPPORT:
1897 for (pts, what) in self.cut_list:
1898 if what == self.CUT_TYPE_LAST:
1901 if last is not None:
1902 self.resume_point = last
1905 if config.usage.on_movie_start.value == "ask":
1906 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?") + "\n" + (_("Resume position at %s") % ("%d:%02d:%02d" % (l/3600, l%3600/60, l%60))), timeout=10)
1907 elif config.usage.on_movie_start.value == "resume":
1908 # TRANSLATORS: The string "Resuming playback" flashes for a moment
1909 # TRANSLATORS: at the start of a movie, when the user has selected
1910 # TRANSLATORS: "Resume from last position" as start behavior.
1911 # TRANSLATORS: The purpose is to notify the user that the movie starts
1912 # TRANSLATORS: in the middle somewhere and not from the beginning.
1913 # TRANSLATORS: (Some translators seem to have interpreted it as a
1914 # TRANSLATORS: question or a choice, but it is a statement.)
1915 Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
1917 def playLastCB(self, answer):
1919 self.doSeek(self.resume_point)
1920 self.hideAfterResume()
1922 def hideAfterResume(self):
1923 if isinstance(self, InfoBarShowHide):
1926 def __getSeekable(self):
1927 service = self.session.nav.getCurrentService()
1930 return service.seek()
1932 def cueGetCurrentPosition(self):
1933 seek = self.__getSeekable()
1936 r = seek.getPlayPosition()
1941 def cueGetEndCutPosition(self):
1944 for cp in self.cut_list:
1945 if cp[1] == self.CUT_TYPE_OUT:
1949 elif cp[1] == self.CUT_TYPE_IN:
1953 def jumpPreviousNextMark(self, cmp, start=False):
1954 current_pos = self.cueGetCurrentPosition()
1955 if current_pos is None:
1957 mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
1958 if mark is not None:
1966 def jumpPreviousMark(self):
1967 # we add 5 seconds, so if the play position is <5s after
1968 # the mark, the mark before will be used
1969 self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
1971 def jumpNextMark(self):
1972 if not self.jumpPreviousNextMark(lambda x: x-90000):
1975 def getNearestCutPoint(self, pts, cmp=abs, start=False):
1982 bestdiff = cmp(0 - pts)
1984 nearest = [0, False]
1985 for cp in self.cut_list:
1986 if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
1988 if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
1989 diff = cmp(cp[0] - pts)
1990 if start and diff >= 0:
1996 if cp[1] == self.CUT_TYPE_IN:
1998 elif cp[1] == self.CUT_TYPE_OUT:
2000 elif cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
2001 diff = cmp(cp[0] - pts)
2002 if instate and diff >= 0 and (nearest is None or bestdiff > diff):
2007 def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
2008 current_pos = self.cueGetCurrentPosition()
2009 if current_pos is None:
2010 print "not seekable"
2013 nearest_cutpoint = self.getNearestCutPoint(current_pos)
2015 if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
2017 return nearest_cutpoint
2019 self.removeMark(nearest_cutpoint)
2020 elif not onlyremove and not onlyreturn:
2021 self.addMark((current_pos, self.CUT_TYPE_MARK))
2026 def addMark(self, point):
2027 insort(self.cut_list, point)
2028 self.uploadCuesheet()
2029 self.showAfterCuesheetOperation()
2031 def removeMark(self, point):
2032 self.cut_list.remove(point)
2033 self.uploadCuesheet()
2034 self.showAfterCuesheetOperation()
2036 def showAfterCuesheetOperation(self):
2037 if isinstance(self, InfoBarShowHide):
2040 def __getCuesheet(self):
2041 service = self.session.nav.getCurrentService()
2044 return service.cueSheet()
2046 def uploadCuesheet(self):
2047 cue = self.__getCuesheet()
2050 print "upload failed, no cuesheet interface"
2052 cue.setCutList(self.cut_list)
2054 def downloadCuesheet(self):
2055 cue = self.__getCuesheet()
2058 print "download failed, no cuesheet interface"
2061 self.cut_list = cue.getCutList()
2063 class InfoBarSummary(Screen):
2065 <screen position="0,0" size="132,64">
2066 <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
2067 <convert type="ClockToText">WithSeconds</convert>
2069 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
2070 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2071 <convert type="ConditionalShowHide">Blink</convert>
2073 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2074 <convert type="ServiceName">Name</convert>
2076 <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
2077 <convert type="EventTime">Progress</convert>
2081 # for picon: (path="piconlcd" will use LCD picons)
2082 # <widget source="session.CurrentService" render="Picon" position="6,0" size="120,64" path="piconlcd" >
2083 # <convert type="ServiceName">Reference</convert>
2086 class InfoBarSummarySupport:
2090 def createSummary(self):
2091 return InfoBarSummary
2093 class InfoBarMoviePlayerSummary(Screen):
2095 <screen position="0,0" size="132,64">
2096 <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
2097 <convert type="ClockToText">WithSeconds</convert>
2099 <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
2100 <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
2101 <convert type="ConditionalShowHide">Blink</convert>
2103 <widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
2104 <convert type="ServiceName">Name</convert>
2106 <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
2107 <convert type="ServicePosition">Position</convert>
2111 class InfoBarMoviePlayerSummarySupport:
2115 def createSummary(self):
2116 return InfoBarMoviePlayerSummary
2118 class InfoBarTeletextPlugin:
2120 self.teletext_plugin = None
2122 for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
2123 self.teletext_plugin = p
2125 if self.teletext_plugin is not None:
2126 self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
2128 "startTeletext": (self.startTeletext, _("View teletext..."))
2131 print "no teletext plugin found!"
2133 def startTeletext(self):
2134 self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
2136 class InfoBarSubtitleSupport(object):
2138 object.__init__(self)
2139 self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
2140 self.__subtitles_enabled = False
2142 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2144 iPlayableService.evEnd: self.__serviceStopped,
2145 iPlayableService.evUpdatedInfo: self.__updatedInfo
2147 self.cached_subtitle_checked = False
2148 self.__selected_subtitle = None
2150 def __serviceStopped(self):
2151 self.cached_subtitle_checked = False
2152 if self.__subtitles_enabled:
2153 self.subtitle_window.hide()
2154 self.__subtitles_enabled = False
2155 self.__selected_subtitle = None
2157 def __updatedInfo(self):
2158 if not self.cached_subtitle_checked:
2159 self.cached_subtitle_checked = True
2160 subtitle = self.getCurrentServiceSubtitle()
2161 self.setSelectedSubtitle(subtitle and subtitle.getCachedSubtitle())
2162 if self.__selected_subtitle:
2163 self.setSubtitlesEnable(True)
2165 def getCurrentServiceSubtitle(self):
2166 service = self.session.nav.getCurrentService()
2167 return service and service.subtitle()
2169 def setSubtitlesEnable(self, enable=True):
2170 subtitle = self.getCurrentServiceSubtitle()
2172 if self.__selected_subtitle:
2173 if subtitle and not self.__subtitles_enabled:
2174 subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
2175 self.subtitle_window.show()
2176 self.__subtitles_enabled = True
2179 subtitle.disableSubtitles(self.subtitle_window.instance)
2180 self.__selected_subtitle = False
2181 self.__subtitles_enabled = False
2182 self.subtitle_window.hide()
2184 def setSelectedSubtitle(self, subtitle):
2185 self.__selected_subtitle = subtitle
2187 subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
2188 selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
2190 class InfoBarServiceErrorPopupSupport:
2192 self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
2194 iPlayableService.evTuneFailed: self.__tuneFailed,
2195 iPlayableService.evStart: self.__serviceStarted
2197 self.__serviceStarted()
2199 def __serviceStarted(self):
2200 self.last_error = None
2201 Notifications.RemovePopup(id = "ZapError")
2203 def __tuneFailed(self):
2204 service = self.session.nav.getCurrentService()
2205 info = service and service.info()
2206 error = info and info.getInfo(iServiceInformation.sDVBState)
2208 if error == self.last_error:
2211 self.last_error = error
2214 eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
2215 eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
2216 eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
2217 eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
2218 eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
2219 eDVBServicePMTHandler.eventNewProgramInfo: None,
2220 eDVBServicePMTHandler.eventTuned: None,
2221 eDVBServicePMTHandler.eventSOF: None,
2222 eDVBServicePMTHandler.eventEOF: None,
2223 eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
2224 }.get(error) #this returns None when the key not exist in the dict
2226 if error is not None:
2227 Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
2229 Notifications.RemovePopup(id = "ZapError")