X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/633c730e5feed206333c5174d53c6384c08047b2..f412f2579647e5b4b9857acaa4a1b29ff191533e:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index 99819fae..da0e6d6f 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -16,9 +16,7 @@ from Components.Sources.FrontendStatus import FrontendStatus from Components.Sources.Boolean import Boolean from Components.Sources.Clock import Clock from Components.TimerList import TimerEntryComponent -from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry -from Components.config import configfile, configsequencearg - +from Components.config import config, ConfigBoolean, ConfigClock from EpgSelection import EPGSelection from Plugins.Plugin import PluginDescriptor @@ -32,19 +30,20 @@ from Screens.MinuteInput import MinuteInput from Screens.TimerSelection import TimerSelection from Screens.PictureInPicture import PictureInPicture from Screens.SubtitleDisplay import SubtitleDisplay +from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive +from Screens.SleepTimerEdit import SleepTimerEdit +from Screens.TimeDateInput import TimeDateInput from ServiceReference import ServiceReference from Tools import Notifications -from Tools.Directories import * - -#from enigma import eTimer, eDVBVolumecontrol, quitMainloop -from enigma import * +from Tools.Directories import SCOPE_HDD, resolveFilename -import time -import os -import bisect +from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \ + iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache -from Components.config import config, currentConfigSelectionElement +from time import time, localtime, strftime +from os import stat as os_stat +from bisect import insort # hack alert! from Menu import MainMenu, mdom @@ -67,19 +66,48 @@ class InfoBarShowHide: { "toggleShow": self.toggleShow, "hide": self.hide, + }, 1) # lower prio to make it possible to override ok and cancel.. + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evStart: self.__serviceStarted, + iPlayableService.evUpdatedEventInfo: self.__eventInfoChanged }) self.__state = self.STATE_SHOWN self.__locked = 0 - self.onExecBegin.append(self.show) - self.hideTimer = eTimer() self.hideTimer.timeout.get().append(self.doTimerHide) self.hideTimer.start(5000, True) self.onShow.append(self.__onShow) self.onHide.append(self.__onHide) + self.current_begin_time=0 + + def __eventInfoChanged(self): + if self.execing: + service = self.session.nav.getCurrentService() + old_begin_time = self.current_begin_time + info = service and service.info() + ptr = info and info.getEvent(0) + self.current_begin_time = ptr and ptr.getBeginTime() or 0 + if config.usage.show_infobar_on_event_change.value: + if old_begin_time and old_begin_time != self.current_begin_time: + self.doShow() + + def __serviceStarted(self, force=False): + new = self.servicelist.newServicePlayed() + if self.execing or force: + self.current_begin_time=0 + if config.usage.show_infobar_on_zap.value: + self.doShow() + elif not self.__checkServiceStarted in self.onExecBegin and new: + self.onExecBegin.append(self.__checkServiceStarted) + + def __checkServiceStarted(self): + self.__serviceStarted(True) + self.onExecBegin.remove(self.__checkServiceStarted) def __onShow(self): self.__state = self.STATE_SHOWN @@ -87,7 +115,9 @@ class InfoBarShowHide: def startHideTimer(self): if self.__state == self.STATE_SHOWN and not self.__locked: - self.hideTimer.start(5000, True) + idx = config.usage.infobar_timeout.index + if idx: + self.hideTimer.start(idx*1000, True) def __onHide(self): self.__state = self.STATE_HIDDEN @@ -192,7 +222,6 @@ class InfoBarNumberZap: # print "You pressed number " + str(number) if number == 0: self.servicelist.recallPrevService() - self.doShow() else: self.session.openWithCallback(self.numberEntered, NumberZap, number) @@ -208,9 +237,9 @@ class InfoBarNumberZap: serviceIterator = servicelist.getNext() if not serviceIterator.valid(): #check end of list break - if serviceIterator.flags: #assume normal dvb service have no flags set - continue - num -= 1; + playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory)) + if playable: + num -= 1; if not num: #found service with searched number ? return serviceIterator, 0 return None, num @@ -219,18 +248,17 @@ class InfoBarNumberZap: bouquet = self.servicelist.bouquet_root service = None serviceHandler = eServiceCenter.getInstance() - if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK + if not config.usage.multibouquet.value: service, number = self.searchNumberHelper(serviceHandler, number, bouquet) else: bouquetlist = serviceHandler.list(bouquet) if not bouquetlist is None: while number: - bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext()) + bouquet = bouquetlist.getNext() if not bouquet.valid(): #check end of list break - if (bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory: - continue - service, number = self.searchNumberHelper(serviceHandler, number, bouquet) + if bouquet.flags & eServiceReference.isDirectory: + service, number = self.searchNumberHelper(serviceHandler, number, bouquet) if not service is None: if self.servicelist.getRoot() != bouquet: #already in correct bouquet? self.servicelist.clearPath() @@ -240,7 +268,7 @@ class InfoBarNumberZap: self.servicelist.setCurrentSelection(service) #select the service in servicelist self.servicelist.zap() -config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1); +config.misc.initialchannelselection = ConfigBoolean(default = True) class InfoBarChannelSelection: """ ChannelSelection - handles the channelSelection dialog and the initial @@ -249,7 +277,7 @@ class InfoBarChannelSelection: #instantiate forever self.servicelist = self.session.instantiateDialog(ChannelSelection) - if config.misc.initialchannelselection.value == 1: + if config.misc.initialchannelselection.value: self.onShown.append(self.firstRun) self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection", @@ -277,7 +305,7 @@ class InfoBarChannelSelection: def firstRun(self): self.onShown.remove(self.firstRun) - config.misc.initialchannelselection.value = 0 + config.misc.initialchannelselection.value = False config.misc.initialchannelselection.save() self.switchChannelDown() @@ -299,20 +327,38 @@ class InfoBarChannelSelection: self.session.execDialog(self.servicelist) def zapUp(self): - if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes": - if self.servicelist.inBouquet() and self.servicelist.atBegin(): - self.servicelist.prevBouquet() - self.servicelist.moveUp() + if self.servicelist.inBouquet(): + prev = self.servicelist.getCurrentSelection() + if prev: + prev = prev.toString() + while True: + if config.usage.quickzap_bouquet_change.value: + if self.servicelist.atBegin(): + self.servicelist.prevBouquet() + self.servicelist.moveUp() + cur = self.servicelist.getCurrentSelection() + if not cur or (not (cur.flags & 64)) or cur.toString() == prev: + break + else: + self.servicelist.moveUp() self.servicelist.zap() - self.doShow() def zapDown(self): - if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.inBouquet() and self.servicelist.atEnd(): - self.servicelist.nextBouquet() + if self.servicelist.inBouquet(): + prev = self.servicelist.getCurrentSelection() + if prev: + prev = prev.toString() + while True: + if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd(): + self.servicelist.nextBouquet() + else: + self.servicelist.moveDown() + cur = self.servicelist.getCurrentSelection() + if not cur or (not (cur.flags & 64)) or cur.toString() == prev: + break else: self.servicelist.moveDown() self.servicelist.zap() - self.doShow() class InfoBarMenu: """ Handles a menu action, to open the (main) menu """ @@ -321,12 +367,21 @@ class InfoBarMenu: { "mainMenu": (self.mainMenu, _("Enter main menu...")), }) + self.session.infobar = None def mainMenu(self): print "loading mainmenu XML..." menu = mdom.childNodes[0] assert menu.tagName == "menu", "root element in menu must be 'menu'!" - self.session.open(MainMenu, menu, menu.childNodes) + + self.session.infobar = self + # so we can access the currently active infobar from screens opened from within the mainmenu + # at the moment used from the SubserviceSelection + + self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu, menu.childNodes) + + def mainMenuClosed(self, *val): + self.session.infobar = None class InfoBarSimpleEventView: """ Opens the Eventview for now/next """ @@ -392,7 +447,7 @@ class InfoBarEPG: service = servicelist.getNext() if not service.valid(): #check if end of list break - if service.flags: #ignore non playable services + if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services continue services.append(ServiceReference(service)) return services @@ -508,6 +563,54 @@ class InfoBarEvent: self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW) self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT) +class InfoBarRdsDecoder: + """provides RDS and Rass support/display""" + def __init__(self): + self.rds_display = self.session.instantiateDialog(RdsInfoDisplay) + self.rass_interactive = None + + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evEnd: self.__serviceStopped, + iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged + }) + + self["RdsActions"] = ActionMap(["InfobarRdsActions"], + { + "startRassInteractive": self.startRassInteractive + },-1) + + self["RdsActions"].setEnabled(False) + + self.onLayoutFinish.append(self.rds_display.show) + self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged) + + def RassInteractivePossibilityChanged(self, state): + self["RdsActions"].setEnabled(state) + + def RassSlidePicChanged(self): + if not self.rass_interactive: + service = self.session.nav.getCurrentService() + decoder = service and service.rdsDecoder() + if decoder: + decoder.showRassSlidePicture() + + def __serviceStopped(self): + if self.rass_interactive is not None: + rass_interactive = self.rass_interactive + self.rass_interactive = None + rass_interactive.close() + + def startRassInteractive(self): + self.rds_display.hide() + self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive) + + def RassInteractiveClosed(self, *val): + if self.rass_interactive is not None: + self.rass_interactive = None + self.RassSlidePicChanged() + self.rds_display.show() + class InfoBarServiceName: def __init__(self): self["CurrentService"] = CurrentService(self.session.nav) @@ -533,7 +636,9 @@ class InfoBarSeek: SEEK_STATE_SM_HALF = (0, 0, 2, "/2") SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4") SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8") - + + SEEK_STATE_EOF = (1, 0, 0, "END") + def __init__(self): self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { @@ -550,15 +655,18 @@ class InfoBarSeek: self.screen = screen def action(self, contexts, action): + print "action:", action if action[:5] == "seek:": time = int(action[5:]) self.screen.seekRelative(time * 90000) + self.screen.doShow() return 1 else: return HelpableActionMap.action(self, contexts, action) self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", { + "playpauseService": (self.playpauseService, _("pause")), "pauseService": (self.pauseService, _("pause")), "unPauseService": (self.unPauseService, _("continue")), @@ -571,6 +679,8 @@ class InfoBarSeek: }, prio=-1) # give them a little more priority to win over color buttons + self["SeekActions"].setEnabled(False) + self.seekstate = self.SEEK_STATE_PLAY self.onClose.append(self.delTimer) @@ -585,7 +695,7 @@ class InfoBarSeek: self.onPlayStateChanged = [ ] self.lockedBecauseOfSkipping = False - + def up(self): pass @@ -625,6 +735,7 @@ class InfoBarSeek: def __serviceStarted(self): self.seekstate = self.SEEK_STATE_PLAY + self.__seekableStatusChanged() def setSeekState(self, state): service = self.session.nav.getCurrentService() @@ -635,26 +746,32 @@ class InfoBarSeek: if not self.isSeekable(): if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]: state = self.SEEK_STATE_PLAY - + pauseable = service.pause() if pauseable is None: print "not pauseable." state = self.SEEK_STATE_PLAY - + oldstate = self.seekstate self.seekstate = state - + for i in range(3): if oldstate[i] != self.seekstate[i]: (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i]) for c in self.onPlayStateChanged: c(self.seekstate) - + self.checkSkipShowHideLock() return True + + def playpauseService(self): + if self.seekstate != self.SEEK_STATE_PLAY: + self.unPauseService() + else: + self.pauseService() def pauseService(self): if self.seekstate == self.SEEK_STATE_PAUSE: @@ -672,7 +789,7 @@ class InfoBarSeek: print "unpause" if self.seekstate == self.SEEK_STATE_PLAY: return 0 - self.setSeekState(self.SEEK_STATE_PLAY); + self.setSeekState(self.SEEK_STATE_PLAY) def doSeek(self, seektime): print "doseek", seektime @@ -719,7 +836,8 @@ class InfoBarSeek: self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X, self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF, self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF, - self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER + self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER, + self.SEEK_STATE_EOF: self.SEEK_STATE_EOF, } self.setSeekState(lookup[self.seekstate]) @@ -746,7 +864,8 @@ class InfoBarSeek: self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X, self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER, self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH, - self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE + self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE, + self.SEEK_STATE_EOF: self.SEEK_STATE_BACK_16X, } self.setSeekState(lookup[self.seekstate]) @@ -781,22 +900,28 @@ class InfoBarSeek: def checkSkipShowHideLock(self): wantlock = self.seekstate != self.SEEK_STATE_PLAY - if self.lockedBecauseOfSkipping and not wantlock: - self.unlockShow() - self.lockedBecauseOfSkipping = False + if config.usage.show_infobar_on_zap.value: + if self.lockedBecauseOfSkipping and not wantlock: + self.unlockShow() + self.lockedBecauseOfSkipping = False - if wantlock and not self.lockedBecauseOfSkipping: - self.lockShow() - self.lockedBecauseOfSkipping = True + if wantlock and not self.lockedBecauseOfSkipping: + self.lockShow() + self.lockedBecauseOfSkipping = True def __evEOF(self): - if self.seekstate != self.SEEK_STATE_PLAY: - self.setSeekState(self.SEEK_STATE_PAUSE) - # HACK - #self.getSeek().seekRelative(1, -90000) - self.setSeekState(self.SEEK_STATE_PLAY) + if self.seekstate == self.SEEK_STATE_EOF: + return + if self.seekstate[1] < 0: # SEEK_STATE_BACK_*X + print "end of stream while seeking back, ignoring." + return + + # if we are seeking, we try to end up ~1s before the end, and pause there. + if not self.seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]: + self.setSeekState(self.SEEK_STATE_EOF) + self.seekRelativeToEnd(-90000) else: - self.setSeekState(self.SEEK_STATE_PAUSE) + self.setSeekState(self.SEEK_STATE_EOF) def __evSOF(self): self.setSeekState(self.SEEK_STATE_PLAY) @@ -805,7 +930,26 @@ class InfoBarSeek: def seekRelative(self, diff): seekable = self.getSeek() if seekable is not None: - seekable.seekRelative(1, diff) + print "seekRelative: res:", seekable.seekRelative(1, diff) + else: + print "seek failed!" + + def seekRelativeToEnd(self, diff): + assert diff <= 0, "diff is expected to be negative!" + + # might sound like an evil hack, but: + # if we seekRelativeToEnd(0), we expect to be at the end, which is what we want, + # and we don't get that by passing 0 here (it would seek to begin). + if diff == 0: + diff = -1 + + # relative-to-end seeking is implemented as absolutes seeks with negative time + self.seekAbsolute(diff) + + def seekAbsolute(self, abs): + seekable = self.getSeek() + if seekable is not None: + seekable.seekTo(abs) from Screens.PVRState import PVRState, TimeshiftState @@ -813,22 +957,25 @@ class InfoBarPVRState: def __init__(self, screen=PVRState): self.onPlayStateChanged.append(self.__playStateChanged) self.pvrStateDialog = self.session.instantiateDialog(screen) - self.onShow.append(self.__mayShow) + self.onShow.append(self._mayShow) self.onHide.append(self.pvrStateDialog.hide) - - def __mayShow(self): - if self.seekstate != self.SEEK_STATE_PLAY and self.execing: + + def _mayShow(self): + if self.execing and self.seekstate != self.SEEK_STATE_PLAY: self.pvrStateDialog.show() def __playStateChanged(self, state): playstateString = state[3] self.pvrStateDialog["state"].setText(playstateString) - self.__mayShow() + self._mayShow() class InfoBarTimeshiftState(InfoBarPVRState): def __init__(self): InfoBarPVRState.__init__(self, screen=TimeshiftState) + def _mayShow(self): + if self.execing and self.timeshift_enabled: + self.pvrStateDialog.show() class InfoBarShowMovies: @@ -850,7 +997,7 @@ class InfoBarShowMovies: # Timeshift works the following way: # demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions" # - normal playback TUNER unused PLAY enable disable disable -# - user presses "yellow" button. TUNER record PAUSE enable disable enable +# - user presses "yellow" button. FILE record PAUSE enable disable enable # - user presess pause again FILE record PLAY enable disable enable # - user fast forwards FILE record FF enable disable enable # - end of timeshift buffer reached TUNER record PLAY enable enable disable @@ -880,21 +1027,21 @@ class InfoBarTimeshift: }, prio=1) self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"], { - "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key" - "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "backward key" + "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key" + "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key" }, prio=-1) # priority over record self.timeshift_enabled = 0 self.timeshift_state = 0 - self.ts_pause_timer = eTimer() - self.ts_pause_timer.timeout.get().append(self.pauseService) + self.ts_rewind_timer = eTimer() + self.ts_rewind_timer.timeout.get().append(self.rewindService) self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { iPlayableService.evStart: self.__serviceStarted, iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged }) - + def getTimeshift(self): service = self.session.nav.getCurrentService() return service and service.timeshift() @@ -905,21 +1052,21 @@ class InfoBarTimeshift: if ts is None: self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR) print "no ts interface" - return - + return 0 + if self.timeshift_enabled: print "hu, timeshift already enabled?" else: if not ts.startTimeshift(): - import time self.timeshift_enabled = 1 - + # we remove the "relative time" for now. #self.pvrStateDialog["timeshift"].setRelative(time.time()) - + # PAUSE. - self.setSeekState(self.SEEK_STATE_PAUSE) - + #self.setSeekState(self.SEEK_STATE_PAUSE) + self.activateTimeshiftEnd(False) + # enable the "TimeshiftEnableActions", which will override # the startTimeshift actions self.__seekableStatusChanged() @@ -928,11 +1075,11 @@ class InfoBarTimeshift: def stopTimeshift(self): if not self.timeshift_enabled: - return + return 0 print "disable timeshift" ts = self.getTimeshift() if ts is None: - return + return 0 self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO) def stopTimeshiftConfirmed(self, confirmed): @@ -948,38 +1095,35 @@ class InfoBarTimeshift: # disable actions self.__seekableStatusChanged() - + # activates timeshift, and seeks to (almost) the end - def activateTimeshiftEnd(self): + def activateTimeshiftEnd(self, back = True): ts = self.getTimeshift() - + print "activateTimeshiftEnd" + if ts is None: return - + if ts.isTimeshiftActive(): print "!! activate timeshift called - but shouldn't this be a normal pause?" self.pauseService() else: - self.setSeekState(self.SEEK_STATE_PLAY) - ts.activateTimeshift() - self.seekRelative(0) - + print "play, ..." + ts.activateTimeshift() # activate timeshift will automatically pause + self.setSeekState(self.SEEK_STATE_PAUSE) + self.seekRelativeToEnd(-90000) # seek approx. 1 sec before end + + if back: + self.ts_rewind_timer.start(200, 1) + + def rewindService(self): + self.setSeekState(self.SEEK_STATE_BACK_16X) + # same as activateTimeshiftEnd, but pauses afterwards. def activateTimeshiftEndAndPause(self): - state = self.seekstate - self.activateTimeshiftEnd() - - # well, this is "andPause", but it could be pressed from pause, - # when pausing on the (fake-)"live" picture, so an un-pause - # is perfectly ok. - - print "now, pauseService" - if state == self.SEEK_STATE_PLAY: - print "is PLAYING, start pause timer" - self.ts_pause_timer.start(200, 1) - else: - print "unpause" - self.unPauseService() + print "activateTimeshiftEndAndPause" + #state = self.seekstate + self.activateTimeshiftEnd(False) def __seekableStatusChanged(self): enabled = False @@ -1003,69 +1147,164 @@ class InfoBarTimeshift: from Screens.PiPSetup import PiPSetup class InfoBarExtensions: + EXTENSION_SINGLE = 0 + EXTENSION_LIST = 1 + def __init__(self): - self.session.pipshown = False + self.list = [] self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions", { - "extensions": (self.extensions, _("view extensions...")), + "extensions": (self.showExtensionSelection, _("view extensions...")), }) - PIPON = 0 - PIPOFF = 1 - MOVEPIP = 2 - PIPSWAP = 3 - ENABLE_SUBTITLE = 4 + def addExtension(self, extension, key = None, type = EXTENSION_SINGLE): + self.list.append((type, extension, key)) + + def updateExtension(self, extension, key = None): + self.extensionsList.append(extension) + if key is not None: + if self.extensionKeys.has_key(key): + key = None + + if key is None: + for x in self.availableKeys: + if not self.extensionKeys.has_key(x): + key = x + break - def extensions(self): + if key is not None: + self.extensionKeys[key] = len(self.extensionsList) - 1 + + def updateExtensions(self): + self.extensionsList = [] + self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ] + self.extensionKeys = {} + for x in self.list: + if x[0] == self.EXTENSION_SINGLE: + self.updateExtension(x[1], x[2]) + else: + for y in x[1](): + self.updateExtension(y[0], y[1]) + + + def showExtensionSelection(self): + self.updateExtensions() + extensionsList = self.extensionsList[:] + keys = [] list = [] - if self.session.pipshown == False: - list.append((_("Activate Picture in Picture"), self.PIPON)) - elif self.session.pipshown == True: - list.append((_("Disable Picture in Picture"), self.PIPOFF)) - list.append((_("Move Picture in Picture"), self.MOVEPIP)) - list.append((_("Swap services"), self.PIPSWAP)) + for x in self.availableKeys: + if self.extensionKeys.has_key(x): + entry = self.extensionKeys[x] + extension = self.extensionsList[entry] + if extension[2](): + name = str(extension[0]()) + list.append((extension[0](), extension)) + keys.append(x) + extensionsList.remove(extension) + else: + extensionsList.remove(extension) + for x in extensionsList: + list.append((x[0](), x)) + keys += [""] * len(extensionsList) + self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys) + + def extensionCallback(self, answer): + if answer is not None: + answer[1][1]() + +from Tools.BoundFunction import boundFunction + +# depends on InfoBarExtensions +from Components.PluginComponent import plugins + +class InfoBarPlugins: + def __init__(self): + self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST) - s = self.getCurrentServiceSubtitle() - l = s and s.getSubtitleList() or [ ] + def getPluginName(self, name): + return name - for x in l: - list.append(("DEBUG: Enable Subtitles: " + x[0], self.ENABLE_SUBTITLE, x[1])) + def getPluginList(self): + list = [] + for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU): + list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None)) + return list + + def runPlugin(self, plugin): + plugin(session = self.session) + +# depends on InfoBarExtensions +class InfoBarSleepTimer: + def __init__(self): + self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1") - self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list) + def available(self): + return True - def extensionCallback(self, answer): - if answer is not None: - if answer[1] == self.PIPON: - self.session.pip = self.session.instantiateDialog(PictureInPicture) - newservice = self.session.nav.getCurrentlyPlayingServiceReference() - if self.session.pip.playService(newservice): - self.session.pipshown = True - self.session.pip.servicePath = self.servicelist.getCurrentServicePath() - else: - self.session.pipshown = False - del self.session.pip - self.session.nav.playService(newservice) - elif answer[1] == self.PIPOFF: - del self.session.pip + def getSleepTimerName(self): + return _("Sleep Timer") + + def showSleepTimerSetup(self): + self.session.open(SleepTimerEdit) + +# depends on InfoBarExtensions +class InfoBarPiP: + def __init__(self): + self.session.pipshown = False + + self.addExtension((self.getShowHideName, self.showPiP, self.available), "blue") + self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green") + self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow") + + def available(self): + return True + + def pipShown(self): + return self.session.pipshown + + def getShowHideName(self): + if self.session.pipshown: + return _("Disable Picture in Picture") + else: + return _("Activate Picture in Picture") + + def getSwapName(self): + return _("Swap Services") + + def getMoveName(self): + return _("Move Picture in Picture") + + def showPiP(self): + if self.session.pipshown: + del self.session.pip + self.session.pipshown = False + else: + self.session.pip = self.session.instantiateDialog(PictureInPicture) + newservice = self.session.nav.getCurrentlyPlayingServiceReference() + if self.session.pip.playService(newservice): + self.session.pipshown = True + self.session.pip.servicePath = self.servicelist.getCurrentServicePath() + else: self.session.pipshown = False - elif answer[1] == self.PIPSWAP: - swapservice = self.session.nav.getCurrentlyPlayingServiceReference() - if self.session.pip.servicePath: - servicepath = self.servicelist.getCurrentServicePath() - ref=servicepath[len(servicepath)-1] - pipref=self.session.pip.getCurrentService() - self.session.pip.playService(swapservice) - self.servicelist.setCurrentServicePath(self.session.pip.servicePath) - if pipref.toString() != ref.toString(): # is a subservice ? - self.session.nav.stopService() # stop portal - self.session.nav.playService(pipref) # start subservice - self.session.pip.servicePath=servicepath - elif answer[1] == self.MOVEPIP: - self.session.open(PiPSetup, pip = self.session.pip) - elif answer[1] == self.ENABLE_SUBTITLE: - self.selected_subtitle = answer[2] - self.subtitles_enabled = True + del self.session.pip + self.session.nav.playService(newservice) + + def swapPiP(self): + swapservice = self.session.nav.getCurrentlyPlayingServiceReference() + if self.session.pip.servicePath: + servicepath = self.servicelist.getCurrentServicePath() + ref=servicepath[len(servicepath)-1] + pipref=self.session.pip.getCurrentService() + self.session.pip.playService(swapservice) + self.servicelist.setCurrentServicePath(self.session.pip.servicePath) + if pipref.toString() != ref.toString(): # is a subservice ? + self.session.nav.stopService() # stop portal + self.session.nav.playService(pipref) # start subservice + self.session.pip.servicePath=servicepath + + def movePiP(self): + self.session.open(PiPSetup, pip = self.session.pip) from RecordTimer import parseEvent @@ -1103,8 +1342,8 @@ class InfoBarInstantRecord: except: pass - begin = time.time() - end = time.time() + 3600 * 10 + begin = time() + end = time() + 3600 * 10 name = "instant record" description = "" eventid = None @@ -1154,22 +1393,39 @@ class InfoBarInstantRecord: self.changeDuration(0) else: self.session.openWithCallback(self.changeDuration, TimerSelection, list) + elif answer[1] == "changeendtime": + if len(self.recording) == 1: + self.setEndtime(0) + else: + self.session.openWithCallback(self.setEndTime, TimerSelection, list) elif answer[1] == "stop": if len(self.recording) == 1: self.stopCurrentRecording(0) else: self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list) - if answer[1] == "indefinitely" or answer[1] == "manualduration" or answer[1] == "event": - limitEvent = False - if answer[1] == "event": - limitEvent = True + elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"): + self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False) if answer[1] == "manualduration": - self.selectedEntry = len(self.recording) - self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER) - self.startInstantRecording(limitEvent = limitEvent) - + self.changeDuration(len(self.recording)-1) + elif answer[1] == "manualendtime": + self.setEndtime(len(self.recording)-1) print "after:\n", self.recording + def setEndtime(self, entry): + if entry is not None: + self.selectedEntry = entry + self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end) + dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime) + dlg.setTitle(_("Please change recording endtime")) + + def TimeDateInputClosed(self, ret): + if len(ret) > 1: + if ret[0]: + localendtime = localtime(ret[1]) + print "stopping recording at", strftime("%c", localendtime) + self.recording[self.selectedEntry].end = ret[1] + self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) + def changeDuration(self, entry): if entry is not None: self.selectedEntry = entry @@ -1178,20 +1434,35 @@ class InfoBarInstantRecord: def inputCallback(self, value): if value is not None: print "stopping recording after", int(value), "minutes." - self.recording[self.selectedEntry].end = time.time() + 60 * int(value) + self.recording[self.selectedEntry].end = time() + 60 * int(value) self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry]) def instantRecord(self): try: - stat = os.stat(resolveFilename(SCOPE_HDD)) + stat = os_stat(resolveFilename(SCOPE_HDD)) except: self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR) return - + if self.isInstantRecordRunning(): - self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("A recording is currently running.\nWhat do you want to do?"), list=[(_("stop recording"), "stop"), (_("change recording (duration)"), "changeduration"), (_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"), (_("do nothing"), "no")]) + self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \ + title=_("A recording is currently running.\nWhat do you want to do?"), \ + list=[(_("stop recording"), "stop"), \ + (_("change recording (duration)"), "changeduration"), \ + (_("change recording (endtime)"), "changeendtime"), \ + (_("add recording (indefinitely)"), "indefinitely"), \ + (_("add recording (stop after current event)"), "event"), \ + (_("add recording (enter recording duration)"), "manualduration"), \ + (_("add recording (enter recording endtime)"), "manualendtime"), \ + (_("do nothing"), "no")]) else: - self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")]) + self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \ + title=_("Start recording?"), \ + list=[(_("add recording (indefinitely)"), "indefinitely"), \ + (_("add recording (stop after current event)"), "event"), \ + (_("add recording (enter recording duration)"), "manualduration"), \ + (_("add recording (enter recording endtime)"), "manualendtime"), \ + (_("don't record"), "no")]) from Tools.ISO639 import LanguageCodes @@ -1206,11 +1477,11 @@ class InfoBarAudioSelection: service = self.session.nav.getCurrentService() audio = service and service.audioTracks() self.audioTracks = audio - n = audio and audio.getNumberOfTracks() + n = audio and audio.getNumberOfTracks() or 0 keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n tlist = [] print "tlist:", tlist - if n and n > 0: + if n > 0: self.audioChannel = service.audioChannel() for x in range(n): @@ -1218,9 +1489,8 @@ class InfoBarAudioSelection: language = i.getLanguage() description = i.getDescription() - if len(language) == 3: - if language in LanguageCodes: - language = LanguageCodes[language][0] + if LanguageCodes.has_key(language): + language = LanguageCodes[language][0] if len(description): description += " (" + language + ")" @@ -1281,6 +1551,8 @@ class InfoBarSubserviceSelection: self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events + self.bsel = None + def checkSubservicesAvail(self, ev): if ev == iPlayableService.evUpdatedEventInfo: service = self.session.nav.getCurrentService() @@ -1319,7 +1591,7 @@ class InfoBarSubserviceSelection: def subserviceSelection(self): service = self.session.nav.getCurrentService() subservices = service and service.subServices() - + self.bouquets = self.servicelist.getBouquetList() n = subservices and subservices.getNumberOfSubservices() selection = 0 if n and n > 0: @@ -1331,12 +1603,56 @@ class InfoBarSubserviceSelection: selection = x tlist.append((i.getName(), i)) - self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection) + if self.bouquets and len(self.bouquets): + keys = ["red", "green", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n + if config.usage.multibouquet.value: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist + else: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist + selection += 3 + else: + tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist + keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n + selection += 2 + + self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys) def subserviceSelected(self, service): + del self.bouquets if not service is None: - self["SubserviceQuickzapAction"].setEnabled(True) - self.session.nav.playService(service[1]) + if isinstance(service[1], str): + if service[1] == "quickzap": + from Screens.SubservicesQuickzap import SubservicesQuickzap + self.session.open(SubservicesQuickzap, service[2]) + else: + self["SubserviceQuickzapAction"].setEnabled(True) + self.session.nav.playService(service[1]) + + def addSubserviceToBouquetCallback(self, service): + if len(service) > 1 and isinstance(service[1], eServiceReference): + self.selectedSubservice = service + if self.bouquets is None: + cnt = 0 + else: + cnt = len(self.bouquets) + if cnt > 1: # show bouquet list + self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet) + elif cnt == 1: # add to only one existing bouquet + self.addSubserviceToBouquet(self.bouquets[0][1]) + self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO) + + def bouquetSelClosed(self, confirmed): + self.bsel = None + del self.selectedSubservice + if confirmed: + self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO) + + def addSubserviceToBouquet(self, dest): + self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1]) + if self.bsel: + self.bsel.close(True) + else: + del self.selectedSubservice class InfoBarAdditionalInfo: def __init__(self): @@ -1350,8 +1666,8 @@ class InfoBarAdditionalInfo: self["ExtensionsAvailable"] = Boolean(fixed=1) self.session.nav.event.append(self.gotServiceEvent) # we like to get service events - res_mgr = eDVBResourceManagerPtr() - if eDVBResourceManager.getInstance(res_mgr) == 0: + res_mgr = eDVBResourceManager.getInstance() + if res_mgr: res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged) def tunerUseMaskChanged(self, mask): @@ -1365,7 +1681,7 @@ class InfoBarAdditionalInfo: self["NimB_Active"].hide() def checkTunerState(self, service): - info = service.frontendInfo() + info = service and service.frontendInfo() feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber) if feNumber is None: self["NimA"].hide() @@ -1379,7 +1695,7 @@ class InfoBarAdditionalInfo: def gotServiceEvent(self, ev): service = self.session.nav.getCurrentService() - if ev == iPlayableService.evStart: + if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd: self.checkTunerState(service) class InfoBarNotifications: @@ -1398,12 +1714,26 @@ class InfoBarNotifications: def checkNotifications(self): if len(Notifications.notifications): n = Notifications.notifications[0] + Notifications.notifications = Notifications.notifications[1:] cb = n[0] + + if n[3].has_key("onSessionOpenCallback"): + n[3]["onSessionOpenCallback"]() + del n[3]["onSessionOpenCallback"] + if cb is not None: - self.session.openWithCallback(cb, n[1], *n[2], **n[3]) + dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3]) else: - self.session.open(n[1], *n[2], **n[3]) + dlg = self.session.open(n[1], *n[2], **n[3]) + + # remember that this notification is currently active + d = (n[4], dlg) + Notifications.current_notifications.append(d) + dlg.onClose.append(boundFunction(self.__notificationClosed, d)) + + def __notificationClosed(self, d): + Notifications.current_notifications.remove(d) class InfoBarServiceNotifications: def __init__(self): @@ -1424,6 +1754,9 @@ class InfoBarCueSheetSupport: CUT_TYPE_IN = 0 CUT_TYPE_OUT = 1 CUT_TYPE_MARK = 2 + CUT_TYPE_LAST = 3 + + ENABLE_RESUME_SUPPORT = False def __init__(self): self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions", @@ -1434,14 +1767,34 @@ class InfoBarCueSheetSupport: }, prio=1) self.cut_list = [ ] + self.is_closing = False self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { iPlayableService.evStart: self.__serviceStarted, }) def __serviceStarted(self): + if self.is_closing: + return print "new service started! trying to download cuts!" self.downloadCuesheet() + + if self.ENABLE_RESUME_SUPPORT: + last = None + + for (pts, what) in self.cut_list: + if what == self.CUT_TYPE_LAST: + last = pts + + if last is not None: + self.resume_point = last + Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10) + + def playLastCB(self, answer): + if answer == True: + seekable = self.__getSeekable() + if seekable is not None: + seekable.seekTo(self.resume_point) def __getSeekable(self): service = self.session.nav.getCurrentService() @@ -1511,7 +1864,7 @@ class InfoBarCueSheetSupport: return None def addMark(self, point): - bisect.insort(self.cut_list, point) + insort(self.cut_list, point) self.uploadCuesheet() def removeMark(self, point): @@ -1543,10 +1896,10 @@ class InfoBarCueSheetSupport: class InfoBarSummary(Screen): skin = """ - + WithSeconds - + Name """ @@ -1589,15 +1942,26 @@ class InfoBarSubtitleSupport(object): self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { - iPlayableService.evStart: self.__serviceStarted, + iPlayableService.evEnd: self.__serviceStopped, + iPlayableService.evUpdatedInfo: self.__updatedInfo }) + self.cached_subtitle_checked = False + self.__selected_subtitle = None - def __serviceStarted(self): - # reenable if it was enabled - r = self.__subtitles_enabled + def __serviceStopped(self): + self.subtitle_window.hide() self.__subtitles_enabled = False - self.__selected_subtitle = None - self.setSubtitlesEnable(r) + self.cached_subtitle_checked = False + + def __updatedInfo(self): + if not self.cached_subtitle_checked: + subtitle = self.getCurrentServiceSubtitle() + self.cached_subtitle_checked = True + self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle() + if self.__selected_subtitle: + subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle) + self.subtitle_window.show() + self.__subtitles_enabled = True def getCurrentServiceSubtitle(self): service = self.session.nav.getCurrentService() @@ -1605,7 +1969,7 @@ class InfoBarSubtitleSupport(object): def setSubtitlesEnable(self, enable=True): subtitle = self.getCurrentServiceSubtitle() - if enable and self.__selected_subtitle: + if enable and self.__selected_subtitle is not None: if subtitle and not self.__subtitles_enabled: subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle) self.subtitle_window.show() @@ -1613,17 +1977,53 @@ class InfoBarSubtitleSupport(object): else: if subtitle: subtitle.disableSubtitles(self.subtitle_window.instance) - - self.subtitle_window.hide() self.__subtitles_enabled = False + self.subtitle_window.hide() def setSelectedSubtitle(self, subtitle): - if self.__selected_subtitle != subtitle and self.subtitles_enabled: - # kick - self.__selected_subtitle = subtitle - self.__serviceStarted() - else: - self.__selected_subtitle = subtitle + self.__selected_subtitle = subtitle subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable) selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle) + +class InfoBarServiceErrorPopupSupport: + def __init__(self): + self.__event_tracker = ServiceEventTracker(screen=self, eventmap= + { + iPlayableService.evTuneFailed: self.__tuneFailed, + iPlayableService.evStart: self.__serviceStarted + }) + self.__serviceStarted() + + def __serviceStarted(self): + self.last_error = None + Notifications.RemovePopup(id = "ZapError") + + def __tuneFailed(self): + service = self.session.nav.getCurrentService() + info = service and service.info() + error = info and info.getInfo(iServiceInformation.sDVBState) + + if error == self.last_error: + error = None + else: + self.last_error = error + + errors = { + eDVBServicePMTHandler.eventNoResources: _("No free tuner!"), + eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"), + eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"), + eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"), + eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"), + eDVBServicePMTHandler.eventNewProgramInfo: None, + eDVBServicePMTHandler.eventTuned: None, + eDVBServicePMTHandler.eventSOF: None, + eDVBServicePMTHandler.eventEOF: None + } + + error = errors.get(error) #this returns None when the key not exist in the dict + + if error is not None: + Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError") + else: + Notifications.RemovePopup(id = "ZapError")