1 from Screen import Screen
2 from Components.ActionMap import ActionMap, HelpableActionMap
3 from Components.ActionMap import NumberActionMap
4 from Components.Label import *
5 from Components.ProgressBar import *
6 from Components.config import configfile, configsequencearg
7 from Components.config import config, configElement, ConfigSubsection, configSequence
8 from ChannelSelection import ChannelSelection
10 from Components.Pixmap import Pixmap, PixmapConditional
11 from Components.BlinkingPixmap import BlinkingPixmapConditional
12 from Components.ServiceName import ServiceName
13 from Components.EventInfo import EventInfo
15 from ServiceReference import ServiceReference
16 from EpgSelection import EPGSelection
18 from Screens.MessageBox import MessageBox
19 from Screens.Volume import Volume
20 from Screens.Mute import Mute
21 from Screens.Dish import Dish
22 from Screens.Standby import Standby
23 from Screens.EventView import EventView
24 from Screens.MinuteInput import MinuteInput
25 from Components.Harddisk import harddiskmanager
27 from Tools import Notifications
28 from Tools.Directories import *
30 #from enigma import eTimer, eDVBVolumecontrol, quitMainloop
37 from Menu import MainMenu, mdom
39 class InfoBarVolumeControl:
40 """Volume control, handles volUp, volDown, volMute actions and display
41 a corresponding dialog"""
43 config.audio = ConfigSubsection()
44 config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100)))
46 self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] ,
48 "volumeUp": self.volUp,
49 "volumeDown": self.volDown,
50 "volumeMute": self.volMute,
53 self.volumeDialog = self.session.instantiateDialog(Volume)
54 self.muteDialog = self.session.instantiateDialog(Mute)
56 self.hideVolTimer = eTimer()
57 self.hideVolTimer.timeout.get().append(self.volHide)
59 vol = config.audio.volume.value[0]
60 self.volumeDialog.setValue(vol)
61 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
64 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
65 config.audio.volume.save()
68 if (eDVBVolumecontrol.getInstance().isMuted()):
70 eDVBVolumecontrol.getInstance().volumeUp()
71 self.volumeDialog.instance.show()
72 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
74 self.hideVolTimer.start(3000, True)
77 if (eDVBVolumecontrol.getInstance().isMuted()):
79 eDVBVolumecontrol.getInstance().volumeDown()
80 self.volumeDialog.instance.show()
81 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
83 self.hideVolTimer.start(3000, True)
86 self.volumeDialog.instance.hide()
89 eDVBVolumecontrol.getInstance().volumeToggleMute()
90 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
92 if (eDVBVolumecontrol.getInstance().isMuted()):
93 self.muteDialog.instance.show()
95 self.muteDialog.instance.hide()
99 self.dishDialog = self.session.instantiateDialog(Dish)
100 self.onShown.append(self.dishDialog.instance.hide)
102 class InfoBarShowHide:
103 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
104 fancy animations. """
111 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
113 "toggleShow": self.toggleShow,
117 self.state = self.STATE_SHOWN
119 self.onExecBegin.append(self.show)
120 self.onClose.append(self.delHideTimer)
122 self.hideTimer = eTimer()
123 self.hideTimer.timeout.get().append(self.doTimerHide)
124 self.hideTimer.start(5000, True)
126 def delHideTimer(self):
133 self.state = self.STATE_SHOWN
134 self.hideTimer.start(5000, True)
136 def doTimerHide(self):
137 self.hideTimer.stop()
138 if self.state == self.STATE_SHOWN:
140 self.state = self.STATE_HIDDEN
142 def toggleShow(self):
143 if self.state == self.STATE_SHOWN:
145 #pls check animation support, sorry
147 self.hideTimer.stop()
148 self.state = self.STATE_HIDDEN
149 elif self.state == self.STATE_HIDDEN:
154 self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
155 self.state = self.STATE_SHOWN
158 self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
159 self.state = self.STATE_HIDDEN
161 class NumberZap(Screen):
168 self.close(int(self["number"].getText()))
170 def keyNumberGlobal(self, number):
171 self.Timer.start(3000, True) #reset timer
172 self.field = self.field + str(number)
173 self["number"].setText(self.field)
174 if len(self.field) >= 4:
177 def __init__(self, session, number):
178 Screen.__init__(self, session)
179 self.field = str(number)
181 self["channel"] = Label(_("Channel:"))
183 self["number"] = Label(self.field)
185 self["actions"] = NumberActionMap( [ "SetupActions" ],
189 "1": self.keyNumberGlobal,
190 "2": self.keyNumberGlobal,
191 "3": self.keyNumberGlobal,
192 "4": self.keyNumberGlobal,
193 "5": self.keyNumberGlobal,
194 "6": self.keyNumberGlobal,
195 "7": self.keyNumberGlobal,
196 "8": self.keyNumberGlobal,
197 "9": self.keyNumberGlobal,
198 "0": self.keyNumberGlobal
201 self.Timer = eTimer()
202 self.Timer.timeout.get().append(self.keyOK)
203 self.Timer.start(3000, True)
205 class InfoBarPowerKey:
206 """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
209 self.powerKeyTimer = eTimer()
210 self.powerKeyTimer.timeout.get().append(self.powertimer)
211 self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
213 "powerdown": self.powerdown,
214 "powerup": self.powerup,
215 "discreteStandby": (self.standby, "Go standby"),
216 "discretePowerOff": (self.quit, "Go to deep standby"),
219 def powertimer(self):
220 print "PowerOff - Now!"
224 self.standbyblocked = 0
225 self.powerKeyTimer.start(3000, True)
228 self.powerKeyTimer.stop()
229 if self.standbyblocked == 0:
230 self.standbyblocked = 1
234 self.session.open(Standby, self)
240 class InfoBarNumberZap:
241 """ Handles an initial number for NumberZapping """
243 self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"],
245 "1": self.keyNumberGlobal,
246 "2": self.keyNumberGlobal,
247 "3": self.keyNumberGlobal,
248 "4": self.keyNumberGlobal,
249 "5": self.keyNumberGlobal,
250 "6": self.keyNumberGlobal,
251 "7": self.keyNumberGlobal,
252 "8": self.keyNumberGlobal,
253 "9": self.keyNumberGlobal,
254 "0": self.keyNumberGlobal,
257 def keyNumberGlobal(self, number):
258 # print "You pressed number " + str(number)
260 self.session.nav.zapLast()
264 self.session.openWithCallback(self.numberEntered, NumberZap, number)
266 def numberEntered(self, retval):
267 # print self.servicelist
269 self.zapToNumber(retval)
271 def searchNumberHelper(self, serviceHandler, num, bouquet):
272 servicelist = serviceHandler.list(bouquet)
273 if not servicelist is None:
275 serviceIterator = servicelist.getNext()
276 if not serviceIterator.valid(): #check end of list
278 if serviceIterator.flags: #assume normal dvb service have no flags set
281 if not num: #found service with searched number ?
282 return serviceIterator, 0
285 def zapToNumber(self, number):
286 bouquet = self.servicelist.bouquet_root
288 serviceHandler = eServiceCenter.getInstance()
289 if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
290 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
292 bouquetlist = serviceHandler.list(bouquet)
293 if not bouquetlist is None:
295 bouquet = bouquetlist.getNext()
296 if not bouquet.valid(): #check end of list
298 if ((bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
300 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
301 if not service is None:
302 self.session.nav.playService(service) #play service
303 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
304 self.servicelist.setRoot(bouquet)
305 self.servicelist.setCurrentSelection(service) #select the service in servicelist
307 class InfoBarChannelSelection:
308 """ ChannelSelection - handles the channelSelection dialog and the initial
309 channelChange actions which open the channelSelection dialog """
312 self.servicelist = self.session.instantiateDialog(ChannelSelection)
314 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
316 "switchChannelUp": self.switchChannelUp,
317 "switchChannelDown": self.switchChannelDown,
318 "zapUp": (self.zapUp, _("next channel")),
319 "zapDown": (self.zapDown, _("previous channel")),
322 def switchChannelUp(self):
323 self.servicelist.moveUp()
324 self.session.execDialog(self.servicelist)
326 def switchChannelDown(self):
327 self.servicelist.moveDown()
328 self.session.execDialog(self.servicelist)
331 self.servicelist.moveUp()
332 self.servicelist.zap()
337 self.servicelist.moveDown()
338 self.servicelist.zap()
343 """ Handles a menu action, to open the (main) menu """
345 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
347 "mainMenu": (self.mainMenu, "Enter main menu..."),
351 print "loading mainmenu XML..."
352 menu = mdom.childNodes[0]
353 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
354 self.session.open(MainMenu, menu, menu.childNodes)
357 """ EPG - Opens an EPG list when the showEPGList action fires """
359 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
361 "showEPGList": (self.showEPGList, _("show EPG...")),
364 def showEPGList(self):
365 ref=self.session.nav.getCurrentlyPlayingServiceReference()
366 ptr=eEPGCache.getInstance()
367 if ptr.startTimeQuery(ref) != -1:
368 self.session.open(EPGSelection, ref)
369 else: # try to show now/next
370 print 'no epg for service', ref.toString()
373 service = self.session.nav.getCurrentService()
374 info = service.info()
377 self.epglist.append(ptr)
380 self.epglist.append(ptr)
381 if len(self.epglist) > 0:
382 self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
386 def eventViewCallback(self, setEvent, val): #used for now/next displaying
387 if len(self.epglist) > 1:
388 tmp = self.epglist[0]
389 self.epglist[0]=self.epglist[1]
391 setEvent(self.epglist[0])
396 """provides a snr/agc/ber display"""
398 self["snr"] = Label()
399 self["agc"] = Label()
400 self["ber"] = Label()
401 self["snr_percent"] = Label()
402 self["agc_percent"] = Label()
403 self["ber_count"] = Label()
404 self["snr_progress"] = ProgressBar()
405 self["agc_progress"] = ProgressBar()
406 self["ber_progress"] = ProgressBar()
407 self.timer = eTimer()
408 self.timer.timeout.get().append(self.updateTunerInfo)
409 self.timer.start(1000)
415 return (long)(log(val)/log(2))
418 def updateTunerInfo(self):
419 if self.instance.isVisible():
420 service = self.session.nav.getCurrentService()
424 if service is not None:
425 feinfo = service.frontendStatusInfo()
426 if feinfo is not None:
427 ber=feinfo.getFrontendInfo(iFrontendStatusInformation.bitErrorRate)
428 snr=feinfo.getFrontendInfo(iFrontendStatusInformation.signalPower)*100/65536
429 agc=feinfo.getFrontendInfo(iFrontendStatusInformation.signalQuality)*100/65536
430 self["snr_percent"].setText("%d%%"%(snr))
431 self["agc_percent"].setText("%d%%"%(agc))
432 self["ber_count"].setText("%d"%(ber))
433 self["snr_progress"].setValue(snr)
434 self["agc_progress"].setValue(agc)
435 self["ber_progress"].setValue(self.calc(ber))
438 """provides a current/next event info display"""
440 self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
441 self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
443 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
444 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
446 self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
447 self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
449 class InfoBarServiceName:
451 self["ServiceName"] = ServiceName(self.session.nav)
455 # ispause, isff, issm, skip
456 SEEK_STATE_PLAY = (0, 0, 0, 0)
457 SEEK_STATE_PAUSE = (1, 0, 0, 0)
458 SEEK_STATE_FF_2X = (0, 2, 0, 0)
459 SEEK_STATE_FF_4X = (0, 4, 0, 0)
460 SEEK_STATE_FF_8X = (0, 8, 0, 0)
461 SEEK_STATE_FF_32X = (0, 4, 0, 32)
462 SEEK_STATE_FF_64X = (0, 4, 0, 64)
463 SEEK_STATE_FF_128X = (0, 4, 0, 128)
465 SEEK_STATE_BACK_4X = (0, 0, 0, -4)
466 SEEK_STATE_BACK_32X = (0, 0, 0, -32)
467 SEEK_STATE_BACK_64X = (0, 0, 0, -64)
468 SEEK_STATE_BACK_128X = (0, 0, 0, -128)
470 SEEK_STATE_SM_HALF = (0, 0, 2, 0)
471 SEEK_STATE_SM_QUARTER = (0, 0, 4, 0)
472 SEEK_STATE_SM_EIGHTH = (0, 0, 8, 0)
474 """handles PVR specific actions like seeking, pause"""
476 self["PVRActions"] = HelpableActionMap(self, "InfobarPVRActions",
478 "pauseService": (self.pauseService, "pause"),
479 "unPauseService": (self.unPauseService, "continue"),
481 "seekFwd": (self.seekFwd, "skip forward"),
482 "seekFwdUp": (self.seekFwdUp, "skip forward"),
483 "seekBack": (self.seekBack, "skip backward"),
484 "seekBackUp": (self.seekBackUp, "skip backward"),
486 "up": (self.showMovies, "movie list"),
487 "down": (self.showMovies, "movie list")
490 self.seekstate = self.SEEK_STATE_PLAY
491 self.seekTimer = eTimer()
492 self.seekTimer.timeout.get().append(self.seekTimerFired)
493 self.skipinterval = 500 # 500ms skip interval
494 self.onClose.append(self.delSeekTimer)
496 self.fwdtimer = False
497 self.fwdKeyTimer = eTimer()
498 self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire)
500 self.rwdtimer = False
501 self.rwdKeyTimer = eTimer()
502 self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
510 def delSeekTimer(self):
513 def seekTimerFired(self):
514 self.seekbase += self.skipmode * self.skipinterval
516 # check if we bounced against the beginning of the file
517 if self.seekbase < 0:
519 self.setSeekState(self.SEEK_STATE_PLAY)
521 self.doSeek(self.seekbase)
523 def setSeekState(self, state):
524 oldstate = self.seekstate
526 self.seekstate = state
528 service = self.session.nav.getCurrentService()
532 pauseable = service.pause()
535 if oldstate[i] != self.seekstate[i]:
536 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion, self.setSkipMode)[i](self.seekstate[i])
538 def setSkipMode(self, skipmode):
539 self.skipmode = skipmode
541 self.seekTimer.stop()
543 self.seekTimer.start(500)
545 service = self.session.nav.getCurrentService()
549 seekable = service.seek()
554 seekable.setTrickmode(1)
556 seekable.setTrickmode(0)
558 self.seekbase = seekable.getPlayPosition()[1] / 90
560 def pauseService(self):
561 if (self.seekstate == self.SEEK_STATE_PAUSE):
562 self.unPauseService()
564 self.setSeekState(self.SEEK_STATE_PAUSE);
566 def unPauseService(self):
567 self.setSeekState(self.SEEK_STATE_PLAY);
569 def doSeek(self, seektime):
570 service = self.session.nav.getCurrentService()
574 seekable = service.seek()
577 seekable.seekTo(90 * seektime)
580 print "start fwd timer"
582 self.fwdKeyTimer.start(500)
585 print "start rewind timer"
587 self.rwdKeyTimer.start(500)
591 self.fwdKeyTimer.stop()
592 self.fwdtimer = False
594 self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
595 self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
596 self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
597 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
598 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
599 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
600 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
601 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
602 self.SEEK_STATE_BACK_4X: self.SEEK_STATE_PLAY,
603 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_4X,
604 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
605 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
606 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
607 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
608 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
610 self.setSeekState(lookup[self.seekstate]);
612 def seekBackUp(self):
614 self.rwdKeyTimer.stop()
615 self.rwdtimer = False
618 self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_4X,
619 self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
620 self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
621 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
622 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
623 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
624 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
625 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
626 self.SEEK_STATE_BACK_4X: self.SEEK_STATE_BACK_32X,
627 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
628 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
629 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
630 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
631 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
632 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
634 self.setSeekState(lookup[self.seekstate]);
636 def fwdTimerFire(self):
637 print "Display seek fwd"
638 self.fwdKeyTimer.stop()
639 self.fwdtimer = False
640 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
642 def fwdSeekTo(self, minutes):
643 print "Seek", minutes, "minutes forward"
645 service = self.session.nav.getCurrentService()
648 seekable = service.seek()
651 seekable.seekRelative(1, minutes * 60 * 90000)
653 def rwdTimerFire(self):
654 self.rwdKeyTimer.stop()
655 self.rwdtimer = False
656 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
658 def rwdSeekTo(self, minutes):
659 self.fwdSeekTo(0 - minutes)
661 from RecordTimer import parseEvent
663 class InfoBarInstantRecord:
664 """Instant Record - handles the instantRecord action in order to
665 start/stop instant records"""
667 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
669 "instantRecord": (self.instantRecord, "Instant Record..."),
671 self.recording = None
673 self["BlinkingPoint"] = BlinkingPixmapConditional()
674 self.onShown.append(self["BlinkingPoint"].hideWidget)
675 self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
677 def stopCurrentRecording(self):
678 self.session.nav.RecordTimer.removeEntry(self.recording)
679 self.recording = None
681 def startInstantRecording(self):
682 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
684 # try to get event info
687 service = self.session.nav.getCurrentService()
688 info = service.info()
689 ev = info.getEvent(0)
694 if event is not None:
695 data = parseEvent(event)
696 data = (data[0], data[1] + 3600 * 10, data[2], data[3], data[4])
698 data = (time.time(), time.time() + 3600 * 10, "instant record", "", None)
700 # fix me, description.
701 self.recording = self.session.nav.recordWithTimer(serviceref, *data)
702 self.recording.dontSave = True
704 #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
706 def isInstantRecordRunning(self):
707 if self.recording != None:
708 if self.recording.isRunning():
712 def recordQuestionCallback(self, answer):
716 if self.isInstantRecordRunning():
717 self.stopCurrentRecording()
719 self.startInstantRecording()
721 def instantRecord(self):
723 stat = os.stat(resolveFilename(SCOPE_HDD))
725 self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
728 if self.isInstantRecordRunning():
729 self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?"))
731 self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?"))
733 from Screens.AudioSelection import AudioSelection
735 class InfoBarAudioSelection:
737 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
739 "audioSelection": (self.audioSelection, "Audio Options..."),
742 def audioSelection(self):
743 service = self.session.nav.getCurrentService()
744 audio = service.audioTracks()
745 n = audio.getNumberOfTracks()
747 self.session.open(AudioSelection, audio)
749 from Screens.SubserviceSelection import SubserviceSelection
751 class InfoBarSubserviceSelection:
753 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
755 "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
758 def subserviceSelection(self):
759 service = self.session.nav.getCurrentService()
760 subservices = service.subServices()
761 n = subservices.getNumberOfSubservices()
763 self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
765 def subserviceSelected(self, service):
766 if not service is None:
767 self.session.nav.playService(service)
769 class InfoBarAdditionalInfo:
771 self["DolbyActive"] = Pixmap()
772 self["CryptActive"] = Pixmap()
773 self["FormatActive"] = Pixmap()
775 self["ButtonRed"] = PixmapConditional(withTimer = False)
776 self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
777 self.onShown.append(self["ButtonRed"].update)
778 self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False)
779 self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
780 self.onShown.append(self["ButtonRedText"].update)
782 self["ButtonGreen"] = Pixmap()
783 self["ButtonGreenText"] = Label(_("Subservices"))
785 self["ButtonYellow"] = PixmapConditional(withTimer = False)
786 self["ButtonYellow"].setConnect(lambda: False)
788 self["ButtonBlue"] = PixmapConditional(withTimer = False)
789 self["ButtonBlue"].setConnect(lambda: False)
791 self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
793 def hideSubServiceIndication(self):
794 self["ButtonGreen"].hideWidget()
795 self["ButtonGreenText"].hide()
797 def showSubServiceIndication(self):
798 self["ButtonGreen"].showWidget()
799 self["ButtonGreenText"].show()
801 def checkFormat(self, service):
802 info = service.info()
804 aspect = info.getInfo(iServiceInformation.sAspect)
805 if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]:
806 self["FormatActive"].showWidget()
808 self["FormatActive"].hideWidget()
810 def checkSubservices(self, service):
811 if service.subServices().getNumberOfSubservices() > 0:
812 self.showSubServiceIndication()
814 self.hideSubServiceIndication()
816 def checkDolby(self, service):
818 audio = service.audioTracks()
819 if audio is not None:
820 n = audio.getNumberOfTracks()
822 i = audio.getTrackInfo(x)
823 description = i.getDescription();
824 if description.find("AC3") != -1 or description.find("DTS") != -1:
828 self["DolbyActive"].showWidget()
830 self["DolbyActive"].hideWidget()
832 def checkCrypted(self, service):
833 info = service.info()
835 if info.getInfo(iServiceInformation.sIsCrypted) > 0:
836 self["CryptActive"].showWidget()
838 self["CryptActive"].hideWidget()
840 def gotServiceEvent(self, ev):
841 service = self.session.nav.getCurrentService()
842 if ev == pNavigation.evUpdatedEventInfo:
843 self.checkSubservices(service)
844 self.checkFormat(service)
845 elif ev == pNavigation.evUpdatedInfo:
846 self.checkCrypted(service)
847 self.checkDolby(service)
848 elif ev == pNavigation.evStopService:
849 self.hideSubServiceIndication()
850 self["CryptActive"].hideWidget()
851 self["DolbyActive"].hideWidget()
852 self["FormatActive"].hideWidget()
854 class InfoBarNotifications:
856 self.onExecBegin.append(self.checkNotifications)
857 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
859 def checkNotificationsIfExecing(self):
861 self.checkNotifications()
863 def checkNotifications(self):
864 if len(Notifications.notifications):
865 n = Notifications.notifications[0]
866 Notifications.notifications = Notifications.notifications[1:]
870 self.session.openWithCallback(cb, *n[1:])
872 self.session.open(*n[1:])