X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/b29744104c479d3da5cd6ff7d9945947e7a1362d..a6c8570901e20b1230d770d9c23e628e0311c6be:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index 8d436013..7a7eb8ff 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -4,21 +4,25 @@ from Components.ActionMap import NumberActionMap from Components.Label import * from Components.ProgressBar import * from Components.config import configfile, configsequencearg -from Components.config import config, configElement, ConfigSubsection, configSequence +from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean from ChannelSelection import ChannelSelection, BouquetSelector from Components.Pixmap import Pixmap, PixmapConditional from Components.BlinkingPixmap import BlinkingPixmapConditional from Components.ServiceName import ServiceName from Components.EventInfo import EventInfo, EventInfoProgress +from Components.Clock import Clock +from Components.Input import Input from ServiceReference import ServiceReference from EpgSelection import EPGSelection from Screens.MessageBox import MessageBox +from Screens.ChoiceBox import ChoiceBox +from Screens.InputBox import InputBox from Screens.Dish import Dish from Screens.Standby import Standby -from Screens.EventView import EventViewEPGSelect +from Screens.EventView import EventViewEPGSelect, EventViewSimple from Screens.MinuteInput import MinuteInput from Components.Harddisk import harddiskmanager @@ -265,23 +269,34 @@ class InfoBarNumberZap: self.servicelist.setCurrentSelection(service) #select the service in servicelist self.servicelist.zap() +config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1); + class InfoBarChannelSelection: """ ChannelSelection - handles the channelSelection dialog and the initial channelChange actions which open the channelSelection dialog """ def __init__(self): #instantiate forever self.servicelist = self.session.instantiateDialog(ChannelSelection) + + if config.misc.initialchannelselection.value == 1: + self.onShown.append(self.firstRun) self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection", { "switchChannelUp": self.switchChannelUp, "switchChannelDown": self.switchChannelDown, - "zapUp": (self.zapUp, _("next channel")), - "zapDown": (self.zapDown, _("previous channel")), + "zapUp": (self.zapUp, _("previous channel")), + "zapDown": (self.zapDown, _("next channel")), "historyBack": (self.historyBack, _("previous channel in history")), "historyNext": (self.historyNext, _("next channel in history")) }) + def firstRun(self): + self.onShown.remove(self.firstRun) + config.misc.initialchannelselection.value = 0 + config.misc.initialchannelselection.save() + self.switchChannelDown() + def historyBack(self): self.servicelist.historyBack() @@ -326,6 +341,35 @@ class InfoBarMenu: assert menu.tagName == "menu", "root element in menu must be 'menu'!" self.session.open(MainMenu, menu, menu.childNodes) +class InfoBarSimpleEventView: + """ Opens the Eventview for now/next """ + def __init__(self): + self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", + { + "showEventInfo": (self.openEventView, _("show event details")), + }) + + def openEventView(self): + self.epglist = [ ] + service = self.session.nav.getCurrentService() + ref = self.session.nav.getCurrentlyPlayingServiceReference() + info = service.info() + ptr=info.getEvent(0) + if ptr: + self.epglist.append(ptr) + ptr=info.getEvent(1) + if ptr: + self.epglist.append(ptr) + if len(self.epglist) > 0: + self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback) + + def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying + if len(self.epglist) > 1: + tmp = self.epglist[0] + self.epglist[0]=self.epglist[1] + self.epglist[1]=tmp + setEvent(self.epglist[0]) + class InfoBarEPG: """ EPG - Opens an EPG list when the showEPGList action fires """ def __init__(self): @@ -511,15 +555,31 @@ class InfoBarSeek: iPlayableService.evEOF: self.__evEOF, iPlayableService.evSOF: self.__evSOF, }) - self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions", + + class InfoBarSeekActionMap(HelpableActionMap): + def __init__(self, screen, *args, **kwargs): + HelpableActionMap.__init__(self, screen, *args, **kwargs) + self.screen = screen + + def action(self, contexts, action): + if action[:5] == "seek:": + time = int(action[5:]) + self.screen.seekRelative(time * 90000) + return 1 + else: + return HelpableActionMap.action(self, contexts, action) + + self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions", { "pauseService": (self.pauseService, "pause"), "unPauseService": (self.unPauseService, "continue"), "seekFwd": (self.seekFwd, "skip forward"), - "seekFwdUp": (self.seekFwdUp, "skip forward"), + "seekFwdDown": self.seekFwdDown, + "seekFwdUp": self.seekFwdUp, "seekBack": (self.seekBack, "skip backward"), - "seekBackUp": (self.seekBackUp, "skip backward"), + "seekBackDown": self.seekBackDown, + "seekBackUp": self.seekBackUp, }, prio=-1) # give them a little more priority to win over color buttons @@ -636,12 +696,12 @@ class InfoBarSeek: seekable.seekTo(90 * seektime) - def seekFwd(self): + def seekFwdDown(self): print "start fwd timer" self.fwdtimer = True self.fwdKeyTimer.start(1000) - def seekBack(self): + def seekBackDown(self): print "start rewind timer" self.rwdtimer = True self.rwdKeyTimer.start(1000) @@ -651,50 +711,60 @@ class InfoBarSeek: if self.fwdtimer: self.fwdKeyTimer.stop() self.fwdtimer = False - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH, - self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X, - self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X, - self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X, - self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X, - self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X, - self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X, - self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X, - 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.setSeekState(lookup[self.seekstate]); + self.seekFwd() + + def seekFwd(self): + lookup = { + self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X, + self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH, + self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X, + self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X, + self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X, + self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X, + self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X, + self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X, + self.SEEK_STATE_BACK_16X: self.SEEK_STATE_PLAY, + self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X, + self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X, + 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.setSeekState(lookup[self.seekstate]) def seekBackUp(self): print "seekBackUp" if self.rwdtimer: self.rwdKeyTimer.stop() self.rwdtimer = False + self.seekBack() - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE, - self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY, - self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X, - self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X, - self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X, - self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X, - self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X, - self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X, - 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.setSeekState(lookup[self.seekstate]); + def seekBack(self): + lookup = { + self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X, + self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE, + self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY, + self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X, + self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X, + self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X, + self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X, + self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X, + self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X, + self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X, + self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X, + 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.setSeekState(lookup[self.seekstate]) + if self.seekstate == self.SEEK_STATE_PAUSE: + seekable = self.getSeek() + if seekable is not None: + seekable.seekRelative(-1, 3) + def fwdTimerFire(self): print "Display seek fwd" self.fwdKeyTimer.stop() @@ -733,7 +803,7 @@ class InfoBarSeek: if self.seekstate != self.SEEK_STATE_PLAY: self.setSeekState(self.SEEK_STATE_PAUSE) # HACK - self.getSeek().seekRelative(1, -90000) + #self.getSeek().seekRelative(1, -90000) self.setSeekState(self.SEEK_STATE_PLAY) else: self.setSeekState(self.SEEK_STATE_PAUSE) @@ -745,14 +815,14 @@ class InfoBarSeek: def seekRelative(self, diff): seekable = self.getSeek() if seekable is not None: - seekable.seekRelative(0, diff) + seekable.seekRelative(1, diff) -from Screens.PVRState import PVRState +from Screens.PVRState import PVRState, TimeshiftState class InfoBarPVRState: - def __init__(self): + def __init__(self, screen=PVRState): self.onPlayStateChanged.append(self.__playStateChanged) - self.pvrStateDialog = self.session.instantiateDialog(PVRState) + self.pvrStateDialog = self.session.instantiateDialog(screen) self.onShow.append(self.__mayShow) self.onHide.append(self.pvrStateDialog.hide) @@ -765,6 +835,11 @@ class InfoBarPVRState: self.pvrStateDialog["state"].setText(playstateString) self.__mayShow() +class InfoBarTimeshiftState(InfoBarPVRState): + def __init__(self): + InfoBarPVRState.__init__(self, screen=TimeshiftState) + + class InfoBarShowMovies: # i don't really like this class. @@ -826,6 +901,7 @@ class InfoBarTimeshift: self.__event_tracker = ServiceEventTracker(screen=self, eventmap= { + iPlayableService.evStart: self.__serviceStarted, iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged }) @@ -845,7 +921,9 @@ class InfoBarTimeshift: print "hu, timeshift already enabled?" else: if not ts.startTimeshift(): + import time self.timeshift_enabled = 1 + self.pvrStateDialog["timeshift"].setRelative(time.time()) # PAUSE. self.setSeekState(self.SEEK_STATE_PAUSE) @@ -926,6 +1004,10 @@ class InfoBarTimeshift: print "timeshift activate:", enabled self["TimeshiftActivateActions"].setEnabled(enabled) + def __serviceStarted(self): + self.timeshift_enabled = False + self.__seekableStatusChanged() + from RecordTimer import parseEvent class InfoBarInstantRecord: @@ -938,36 +1020,48 @@ class InfoBarInstantRecord: }) self.recording = None self["BlinkingPoint"] = BlinkingPixmapConditional() - self.onLayoutFinish.append(self["BlinkingPoint"].hideWidget) + self["BlinkingPoint"].hide() self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording) def stopCurrentRecording(self): self.session.nav.RecordTimer.removeEntry(self.recording) self.recording = None - def startInstantRecording(self): + def startInstantRecording(self, limitEvent = False): serviceref = self.session.nav.getCurrentlyPlayingServiceReference() # try to get event info event = None try: service = self.session.nav.getCurrentService() - info = service.info() - ev = info.getEvent(0) - event = ev + epg = eEPGCache.getInstance() + event = epg.lookupEventTime(serviceref, -1, 0) + if event is None: + info = service.info() + ev = info.getEvent(0) + event = ev except: pass + + begin = time.time() + end = time.time() + 3600 * 10 + name = "instant record" + description = "" + eventid = None if event is not None: - data = parseEvent(event) - begin = time.time() - end = begin + 3600 * 10 - - data = (begin, end, data[2], data[3], data[4]) + curEvent = parseEvent(event) + name = curEvent[2] + description = curEvent[3] + eventid = curEvent[4] + if limitEvent: + end = curEvent[1] else: - data = (time.time(), time.time() + 3600 * 10, "instant record", "", None) + if limitEvent: + self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO) + + data = (begin, end, name, description, eventid) - # fix me, description. self.recording = self.session.nav.recordWithTimer(serviceref, *data) self.recording.dontSave = True @@ -980,13 +1074,28 @@ class InfoBarInstantRecord: return False def recordQuestionCallback(self, answer): - if answer == False: + if answer is None or answer[1] == "no": return if self.isInstantRecordRunning(): - self.stopCurrentRecording() + if answer[1] == "manualduration": + self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER) + else: + self.stopCurrentRecording() else: - self.startInstantRecording() + limitEvent = False + if answer[1] == "event": + limitEvent = True + if answer[1] == "manualduration": + 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) + + def inputCallback(self, value): + if value is not None: + print "stopping recording after", int(value), "minutes." + if self.recording is not None: + self.recording.end = time.time() + 60 * int(value) + self.session.nav.RecordTimer.timeChanged(self.recording) def instantRecord(self): try: @@ -996,9 +1105,11 @@ class InfoBarInstantRecord: return if self.isInstantRecordRunning(): - self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?")) + self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("A recording is currently running.\nWhat do you want to do?"), list=[(_("stop recording"), "yes"), (_("enter recording duration"), "manualduration"), (_("do nothing"), "no")]) +# self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?")) else: - self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?")) + self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("record indefinitely"), "indefinitely"), (_("stop after current event"), "event"), (_("enter recording duration"), "manualduration"),(_("don't record"), "no")]) + #self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?")) from Screens.AudioSelection import AudioSelection @@ -1069,11 +1180,11 @@ class InfoBarAdditionalInfo: self.session.nav.event.append(self.gotServiceEvent) # we like to get service events def hideSubServiceIndication(self): - self["ButtonGreen"].hideWidget() + self["ButtonGreen"].hide() self["ButtonGreenText"].hide() def showSubServiceIndication(self): - self["ButtonGreen"].showWidget() + self["ButtonGreen"].show() self["ButtonGreenText"].show() def checkFormat(self, service): @@ -1081,9 +1192,9 @@ class InfoBarAdditionalInfo: if info is not None: aspect = info.getInfo(iServiceInformation.sAspect) if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]: - self["FormatActive"].showWidget() + self["FormatActive"].show() else: - self["FormatActive"].hideWidget() + self["FormatActive"].hide() def checkSubservices(self, service): if service.subServices().getNumberOfSubservices() > 0: @@ -1104,17 +1215,17 @@ class InfoBarAdditionalInfo: dolby = True break if dolby: - self["DolbyActive"].showWidget() + self["DolbyActive"].show() else: - self["DolbyActive"].hideWidget() + self["DolbyActive"].hide() def checkCrypted(self, service): info = service.info() if info is not None: if info.getInfo(iServiceInformation.sIsCrypted) > 0: - self["CryptActive"].showWidget() + self["CryptActive"].show() else: - self["CryptActive"].hideWidget() + self["CryptActive"].hide() def gotServiceEvent(self, ev): service = self.session.nav.getCurrentService() @@ -1126,9 +1237,9 @@ class InfoBarAdditionalInfo: self.checkDolby(service) elif ev == iPlayableService.evEnd: self.hideSubServiceIndication() - self["CryptActive"].hideWidget() - self["DolbyActive"].hideWidget() - self["FormatActive"].hideWidget() + self["CryptActive"].hide() + self["DolbyActive"].hide() + self["FormatActive"].hide() class InfoBarNotifications: def __init__(self): @@ -1194,7 +1305,7 @@ class InfoBarCueSheetSupport: return None return service.seek() - def __getCurrentPosition(self): + def cueGetCurrentPosition(self): seek = self.__getSeekable() if seek is None: return None @@ -1204,7 +1315,7 @@ class InfoBarCueSheetSupport: return long(r[1]) def jumpPreviousNextMark(self, cmp, alternative=None): - current_pos = self.__getCurrentPosition() + current_pos = self.cueGetCurrentPosition() if current_pos is None: return mark = self.getNearestCutPoint(current_pos, cmp=cmp) @@ -1220,13 +1331,11 @@ class InfoBarCueSheetSupport: seekable.seekTo(pts) def jumpPreviousMark(self): - print "jumpPreviousMark" # we add 2 seconds, so if the play position is <2s after # the mark, the mark before will be used self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0) def jumpNextMark(self): - print "jumpNextMark" self.jumpPreviousNextMark(lambda x: x) def getNearestCutPoint(self, pts, cmp=abs): @@ -1238,23 +1347,31 @@ class InfoBarCueSheetSupport: nearest = cp return nearest - def toggleMark(self): - print "toggleMark" - current_pos = self.__getCurrentPosition() + def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False): + current_pos = self.cueGetCurrentPosition() if current_pos is None: print "not seekable" return - print "current position: ", current_pos - nearest_cutpoint = self.getNearestCutPoint(current_pos) - print "nearest_cutpoint: ", nearest_cutpoint - if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < 5*90000: - self.cut_list.remove(nearest_cutpoint) - else: - bisect.insort(self.cut_list, (current_pos, self.CUT_TYPE_MARK)) + if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance: + if onlyreturn: + return nearest_cutpoint + if not onlyadd: + self.removeMark(nearest_cutpoint) + elif not onlyremove and not onlyreturn: + self.addMark((current_pos, self.CUT_TYPE_MARK)) + if onlyreturn: + return None + + def addMark(self, point): + bisect.insort(self.cut_list, point) + self.uploadCuesheet() + + def removeMark(self, point): + self.cut_list.remove(point) self.uploadCuesheet() def __getCuesheet(self): @@ -1279,4 +1396,21 @@ class InfoBarCueSheetSupport: return self.cut_list = cue.getCutList() - print "cuts:", self.cut_list +class InfoBarSummary(Screen): + skin = """ + + + + """ + + def __init__(self, session, parent): + Screen.__init__(self, session) + self["CurrentService"] = ServiceName(self.session.nav) + self["Clock"] = Clock() + +class InfoBarSummarySupport: + def __init__(self): + pass + + def createSummary(self): + return InfoBarSummary