X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/3be2d2d8f0250000c2b5300266abf3776844643e..4edd37a9d5b4370ef0ed4c055ebf1b654a52c73f:/lib/python/Screens/InfoBarGenerics.py diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py index 58abce15..921dd587 100644 --- a/lib/python/Screens/InfoBarGenerics.py +++ b/lib/python/Screens/InfoBarGenerics.py @@ -5,7 +5,7 @@ from Components.Label import * from Components.ProgressBar import * from Components.config import configfile, configsequencearg from Components.config import config, configElement, ConfigSubsection, configSequence -from ChannelSelection import ChannelSelection +from ChannelSelection import ChannelSelection, BouquetSelector from Components.Pixmap import Pixmap, PixmapConditional from Components.BlinkingPixmap import BlinkingPixmapConditional @@ -21,9 +21,11 @@ from Screens.Mute import Mute from Screens.Dish import Dish from Screens.Standby import Standby from Screens.EventView import EventView +from Screens.MinuteInput import MinuteInput from Components.Harddisk import harddiskmanager from Tools import Notifications +from Tools.Directories import * #from enigma import eTimer, eDVBVolumecontrol, quitMainloop from enigma import * @@ -39,7 +41,7 @@ class InfoBarVolumeControl: a corresponding dialog""" def __init__(self): config.audio = ConfigSubsection() - config.audio.volume = configElement("config.audio.volume", configSequence, [5], configsequencearg.get("INTEGER", (0, 100))) + config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100))) self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] , { @@ -69,7 +71,7 @@ class InfoBarVolumeControl: self.volumeDialog.instance.show() self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume()) self.volSave() - self.hideVolTimer.start(3000) + self.hideVolTimer.start(3000, True) def volDown(self): if (eDVBVolumecontrol.getInstance().isMuted()): @@ -78,7 +80,7 @@ class InfoBarVolumeControl: self.volumeDialog.instance.show() self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume()) self.volSave() - self.hideVolTimer.start(3000) + self.hideVolTimer.start(3000, True) def volHide(self): self.volumeDialog.instance.hide() @@ -119,7 +121,7 @@ class InfoBarShowHide: self.hideTimer = eTimer() self.hideTimer.timeout.get().append(self.doTimerHide) - self.hideTimer.start(5000) + self.hideTimer.start(5000, True) def delHideTimer(self): del self.hideTimer @@ -129,8 +131,7 @@ class InfoBarShowHide: def show(self): self.state = self.STATE_SHOWN - self.hideTimer.stop() - self.hideTimer.start(5000) + self.hideTimer.start(5000, True) def doTimerHide(self): self.hideTimer.stop() @@ -167,7 +168,7 @@ class NumberZap(Screen): self.close(int(self["number"].getText())) def keyNumberGlobal(self, number): - self.Timer.start(3000) #reset timer + self.Timer.start(3000, True) #reset timer self.field = self.field + str(number) self["number"].setText(self.field) if len(self.field) >= 4: @@ -199,7 +200,7 @@ class NumberZap(Screen): self.Timer = eTimer() self.Timer.timeout.get().append(self.keyOK) - self.Timer.start(3000) + self.Timer.start(3000, True) class InfoBarPowerKey: """ PowerKey stuff - handles the powerkey press and powerkey release actions""" @@ -221,7 +222,7 @@ class InfoBarPowerKey: def powerdown(self): self.standbyblocked = 0 - self.powerKeyTimer.start(3000) + self.powerKeyTimer.start(3000, True) def powerup(self): self.powerKeyTimer.stop() @@ -255,7 +256,12 @@ class InfoBarNumberZap: def keyNumberGlobal(self, number): # print "You pressed number " + str(number) - self.session.openWithCallback(self.numberEntered, NumberZap, number) + if number == 0: + self.session.nav.zapLast() + self.instance.show() + self.show() + else: + self.session.openWithCallback(self.numberEntered, NumberZap, number) def numberEntered(self, retval): # print self.servicelist @@ -286,7 +292,7 @@ class InfoBarNumberZap: bouquetlist = serviceHandler.list(bouquet) if not bouquetlist is None: while number: - bouquet = bouquetlist.getNext() + bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext()) if not bouquet.valid(): #check end of list break if ((bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory): @@ -356,7 +362,67 @@ class InfoBarEPG: }) def showEPGList(self): + bouquets = self.servicelist.getBouquetList() + if bouquets is None: + cnt = 0 + else: + cnt = len(bouquets) + if cnt > 1: # show bouquet list + self.session.open(BouquetSelector, bouquets, self.openBouquetEPG) + elif cnt == 1: # add to only one existing bouquet + self.openBouquetEPG(bouquets[0][1]) + else: #no bouquets so we open single epg + self.openSingleEPGSelector(self.session.nav.getCurrentlyPlayingServiceReference()) + + def bouquetEPGCallback(self, info): + if info: + self.openSingleServiceEPG() + + def singleEPGCallback(self, info): + if info: + self.showEPGList() + + def openEventView(self): + try: + self.epglist = [ ] + service = self.session.nav.getCurrentService() + 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(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback) + except: + pass + + def openSingleServiceEPG(self): ref=self.session.nav.getCurrentlyPlayingServiceReference() + ptr=eEPGCache.getInstance() + if ptr.startTimeQuery(ref) != -1: + self.session.openWithCallback(self.singleEPGCallback, EPGSelection, ref) + else: # try to show now/next + print 'no epg for service', ref.toString() + + + def openBouquetEPG(self, bouquet): + ptr=eEPGCache.getInstance() + services = [ ] + servicelist = eServiceCenter.getInstance().list(bouquet) + if not servicelist is None: + while True: + service = servicelist.getNext() + if not service.valid(): #check if end of list + break + if service.flags: #ignore non playable services + continue + services.append(ServiceReference(service)) + if len(services): + self.session.openWithCallback(self.bouquetEPGCallback, EPGSelection, services) + + def openSingleEPGSelector(self, ref): ptr=eEPGCache.getInstance() if ptr.startTimeQuery(ref) != -1: self.session.open(EPGSelection, ref) @@ -377,7 +443,7 @@ class InfoBarEPG: except: pass - def eventViewCallback(self, setEvent, val): #used for now/next displaying + 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] @@ -400,7 +466,7 @@ class InfoBarTuner: self["ber_progress"] = ProgressBar() self.timer = eTimer() self.timer.timeout.get().append(self.updateTunerInfo) - self.timer.start(500) + self.timer.start(1000) def calc(self,val): if not val: @@ -452,12 +518,18 @@ class InfoBarPVR: SEEK_STATE_FF_2X = (0, 2, 0, 0) SEEK_STATE_FF_4X = (0, 4, 0, 0) SEEK_STATE_FF_8X = (0, 8, 0, 0) - SEEK_STATE_FF_32X = (0, 0, 0, 32) - SEEK_STATE_FF_64X = (0, 0, 0, 64) + SEEK_STATE_FF_32X = (0, 4, 0, 32) + SEEK_STATE_FF_64X = (0, 4, 0, 64) + SEEK_STATE_FF_128X = (0, 4, 0, 128) SEEK_STATE_BACK_4X = (0, 0, 0, -4) SEEK_STATE_BACK_32X = (0, 0, 0, -32) SEEK_STATE_BACK_64X = (0, 0, 0, -64) + SEEK_STATE_BACK_128X = (0, 0, 0, -128) + + SEEK_STATE_SM_HALF = (0, 0, 2, 0) + SEEK_STATE_SM_QUARTER = (0, 0, 4, 0) + SEEK_STATE_SM_EIGHTH = (0, 0, 8, 0) """handles PVR specific actions like seeking, pause""" def __init__(self): @@ -467,20 +539,47 @@ class InfoBarPVR: "unPauseService": (self.unPauseService, "continue"), "seekFwd": (self.seekFwd, "skip forward"), + "seekFwdUp": (self.seekFwdUp, "skip forward"), "seekBack": (self.seekBack, "skip backward"), + "seekBackUp": (self.seekBackUp, "skip backward"), + + "movieList": (self.showMovies, "movie list"), + "up": (self.showMovies, "movie list"), + "down": (self.showMovies, "movie list") }) self.seekstate = self.SEEK_STATE_PLAY self.seekTimer = eTimer() self.seekTimer.timeout.get().append(self.seekTimerFired) self.skipinterval = 500 # 500ms skip interval + self.onClose.append(self.delSeekTimer) + + self.fwdtimer = False + self.fwdKeyTimer = eTimer() + self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire) + + self.rwdtimer = False + self.rwdKeyTimer = eTimer() + self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire) + + def up(self): + pass + + def down(self): + pass + + def delSeekTimer(self): + del self.seekTimer def seekTimerFired(self): - print "skip", self.skipmode - if self.skipmode > 0: - self.doSeek(+1, self.skipmode * self.skipinterval) - else: - self.doSeek(-1, -self.skipmode * self.skipinterval) + self.seekbase += self.skipmode * self.skipinterval + + # check if we bounced against the beginning of the file + if self.seekbase < 0: + self.seekbase = 0; + self.setSeekState(self.SEEK_STATE_PLAY) + + self.doSeek(self.seekbase) def setSeekState(self, state): oldstate = self.seekstate @@ -492,7 +591,6 @@ class InfoBarPVR: return pauseable = service.pause() - print "newstate: ", self.seekstate for i in range(4): if oldstate[i] != self.seekstate[i]: @@ -504,14 +602,32 @@ class InfoBarPVR: self.seekTimer.stop() else: self.seekTimer.start(500) + + service = self.session.nav.getCurrentService() + if service is None: + return + + seekable = service.seek() + if seekable is None: + return + + if skipmode: + seekable.setTrickmode(1) + else: + seekable.setTrickmode(0) + + self.seekbase = seekable.getPlayPosition()[1] / 90 def pauseService(self): - self.setSeekState(self.SEEK_STATE_PAUSE); + if (self.seekstate == self.SEEK_STATE_PAUSE): + self.unPauseService() + else: + self.setSeekState(self.SEEK_STATE_PAUSE); def unPauseService(self): self.setSeekState(self.SEEK_STATE_PLAY); - def doSeek(self, dir, seektime): + def doSeek(self, seektime): service = self.session.nav.getCurrentService() if service is None: return @@ -519,37 +635,91 @@ class InfoBarPVR: seekable = service.seek() if seekable is None: return - seekable.seekRelative(dir, 90 * seektime) + seekable.seekTo(90 * seektime) def seekFwd(self): - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_PLAY, - 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_64X, - self.SEEK_STATE_BACK_4X: self.SEEK_STATE_PLAY, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_4X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X - } - self.setSeekState(lookup[self.seekstate]); - + print "start fwd timer" + self.fwdtimer = True + self.fwdKeyTimer.start(500) + def seekBack(self): - lookup = { - self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_4X, - self.SEEK_STATE_PAUSE: self.SEEK_STATE_BACK_4X, - 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_BACK_4X: self.SEEK_STATE_BACK_32X, - self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X, - self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_64X - } - self.setSeekState(lookup[self.seekstate]); + print "start rewind timer" + self.rwdtimer = True + self.rwdKeyTimer.start(500) + + def seekFwdUp(self): + 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_4X: self.SEEK_STATE_PLAY, + self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_4X, + 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): + if self.rwdtimer: + self.rwdKeyTimer.stop() + self.rwdtimer = False + + lookup = { + self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_4X, + 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_4X: 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 fwdTimerFire(self): + print "Display seek fwd" + self.fwdKeyTimer.stop() + self.fwdtimer = False + self.session.openWithCallback(self.fwdSeekTo, MinuteInput) + + def fwdSeekTo(self, minutes): + print "Seek", minutes, "minutes forward" + if minutes != 0: + service = self.session.nav.getCurrentService() + if service is None: + return + seekable = service.seek() + if seekable is None: + return + seekable.seekRelative(1, minutes * 60 * 90000) + + def rwdTimerFire(self): + self.rwdKeyTimer.stop() + self.rwdtimer = False + self.session.openWithCallback(self.rwdSeekTo, MinuteInput) + + def rwdSeekTo(self, minutes): + self.fwdSeekTo(0 - minutes) + +from RecordTimer import parseEvent class InfoBarInstantRecord: """Instant Record - handles the instantRecord action in order to @@ -571,19 +741,25 @@ class InfoBarInstantRecord: def startInstantRecording(self): serviceref = self.session.nav.getCurrentlyPlayingServiceReference() - + # try to get event info - epg = None + event = None try: service = self.session.nav.getCurrentService() info = service.info() ev = info.getEvent(0) - epg = ev + event = ev except: pass + if event is not None: + data = parseEvent(event) + data = (data[0], data[1] + 3600 * 10, data[2], data[3], data[4]) + else: + data = (time.time(), time.time() + 3600 * 10, "instant record", "", None) + # fix me, description. - self.recording = self.session.nav.recordWithTimer(time.time(), time.time() + 3600, serviceref, epg, "instant record") + self.recording = self.session.nav.recordWithTimer(serviceref, *data) self.recording.dontSave = True #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning()) @@ -605,9 +781,9 @@ class InfoBarInstantRecord: def instantRecord(self): try: - stat = os.stat("/hdd/movies") + stat = os.stat(resolveFilename(SCOPE_HDD)) except: - self.session.open(MessageBox, "No HDD found!") + self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR) return if self.isInstantRecordRunning(): @@ -653,17 +829,9 @@ class InfoBarSubserviceSelection: class InfoBarAdditionalInfo: def __init__(self): - self["DolbyActive"] = PixmapConditional() - # TODO: get the info from c++ somehow - self["DolbyActive"].setConnect(lambda: False) - - self["CryptActive"] = PixmapConditional() - # TODO: get the info from c++ somehow - self["CryptActive"].setConnect(lambda: False) - - self["FormatActive"] = PixmapConditional() - # TODO: get the info from c++ somehow - self["FormatActive"].setConnect(lambda: False) + self["DolbyActive"] = Pixmap() + self["CryptActive"] = Pixmap() + self["FormatActive"] = Pixmap() self["ButtonRed"] = PixmapConditional(withTimer = False) self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0) @@ -671,18 +839,79 @@ class InfoBarAdditionalInfo: self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False) self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0) self.onShown.append(self["ButtonRedText"].update) - - self["ButtonGreen"] = PixmapConditional() - self["ButtonGreen"].setConnect(lambda: self.session.nav.getCurrentService().subServices().getNumberOfSubservices() > 0) - self["ButtonGreenText"] = LabelConditional(text = _("Subservices")) - self["ButtonGreenText"].setConnect(lambda: self.session.nav.getCurrentService().subServices().getNumberOfSubservices() > 0) - self["ButtonYellow"] = PixmapConditional() + self["ButtonGreen"] = Pixmap() + self["ButtonGreenText"] = Label(_("Subservices")) + + self["ButtonYellow"] = PixmapConditional(withTimer = False) self["ButtonYellow"].setConnect(lambda: False) - self["ButtonBlue"] = PixmapConditional() + self["ButtonBlue"] = PixmapConditional(withTimer = False) self["ButtonBlue"].setConnect(lambda: False) + self.session.nav.event.append(self.gotServiceEvent) # we like to get service events + + def hideSubServiceIndication(self): + self["ButtonGreen"].hideWidget() + self["ButtonGreenText"].hide() + + def showSubServiceIndication(self): + self["ButtonGreen"].showWidget() + self["ButtonGreenText"].show() + + def checkFormat(self, service): + info = service.info() + if info is not None: + aspect = info.getInfo(iServiceInformation.sAspect) + if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]: + self["FormatActive"].showWidget() + else: + self["FormatActive"].hideWidget() + + def checkSubservices(self, service): + if service.subServices().getNumberOfSubservices() > 0: + self.showSubServiceIndication() + else: + self.hideSubServiceIndication() + + def checkDolby(self, service): + dolby = False + audio = service.audioTracks() + if audio is not None: + n = audio.getNumberOfTracks() + for x in range(n): + i = audio.getTrackInfo(x) + description = i.getDescription(); + if description.find("AC3") != -1 or description.find("DTS") != -1: + dolby = True + break + if dolby: + self["DolbyActive"].showWidget() + else: + self["DolbyActive"].hideWidget() + + def checkCrypted(self, service): + info = service.info() + if info is not None: + if info.getInfo(iServiceInformation.sIsCrypted) > 0: + self["CryptActive"].showWidget() + else: + self["CryptActive"].hideWidget() + + def gotServiceEvent(self, ev): + service = self.session.nav.getCurrentService() + if ev == pNavigation.evUpdatedEventInfo: + self.checkSubservices(service) + self.checkFormat(service) + elif ev == pNavigation.evUpdatedInfo: + self.checkCrypted(service) + self.checkDolby(service) + elif ev == pNavigation.evStopService: + self.hideSubServiceIndication() + self["CryptActive"].hideWidget() + self["DolbyActive"].hideWidget() + self["FormatActive"].hideWidget() + class InfoBarNotifications: def __init__(self): self.onExecBegin.append(self.checkNotifications)