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
29 #from enigma import eTimer, eDVBVolumecontrol, quitMainloop
36 from Menu import MainMenu, mdom
38 class InfoBarVolumeControl:
39 """Volume control, handles volUp, volDown, volMute actions and display
40 a corresponding dialog"""
42 config.audio = ConfigSubsection()
43 config.audio.volume = configElement("config.audio.volume", configSequence, [100], configsequencearg.get("INTEGER", (0, 100)))
45 self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] ,
47 "volumeUp": self.volUp,
48 "volumeDown": self.volDown,
49 "volumeMute": self.volMute,
52 self.volumeDialog = self.session.instantiateDialog(Volume)
53 self.muteDialog = self.session.instantiateDialog(Mute)
55 self.hideVolTimer = eTimer()
56 self.hideVolTimer.timeout.get().append(self.volHide)
58 vol = config.audio.volume.value[0]
59 self.volumeDialog.setValue(vol)
60 eDVBVolumecontrol.getInstance().setVolume(vol, vol)
63 config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
64 config.audio.volume.save()
67 if (eDVBVolumecontrol.getInstance().isMuted()):
69 eDVBVolumecontrol.getInstance().volumeUp()
70 self.volumeDialog.instance.show()
71 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
73 self.hideVolTimer.start(3000, True)
76 if (eDVBVolumecontrol.getInstance().isMuted()):
78 eDVBVolumecontrol.getInstance().volumeDown()
79 self.volumeDialog.instance.show()
80 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
82 self.hideVolTimer.start(3000, True)
85 self.volumeDialog.instance.hide()
88 eDVBVolumecontrol.getInstance().volumeToggleMute()
89 self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
91 if (eDVBVolumecontrol.getInstance().isMuted()):
92 self.muteDialog.instance.show()
94 self.muteDialog.instance.hide()
98 self.dishDialog = self.session.instantiateDialog(Dish)
99 self.onShown.append(self.dishDialog.instance.hide)
101 class InfoBarShowHide:
102 """ InfoBar show/hide control, accepts toggleShow and hide actions, might start
103 fancy animations. """
110 self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
112 "toggleShow": self.toggleShow,
116 self.state = self.STATE_SHOWN
118 self.onExecBegin.append(self.show)
119 self.onClose.append(self.delHideTimer)
121 self.hideTimer = eTimer()
122 self.hideTimer.timeout.get().append(self.doTimerHide)
123 self.hideTimer.start(5000, True)
125 def delHideTimer(self):
132 self.state = self.STATE_SHOWN
133 self.hideTimer.start(5000, True)
135 def doTimerHide(self):
136 self.hideTimer.stop()
137 if self.state == self.STATE_SHOWN:
139 self.state = self.STATE_HIDDEN
141 def toggleShow(self):
142 if self.state == self.STATE_SHOWN:
144 #pls check animation support, sorry
146 self.hideTimer.stop()
147 self.state = self.STATE_HIDDEN
148 elif self.state == self.STATE_HIDDEN:
153 self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
154 self.state = self.STATE_SHOWN
157 self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
158 self.state = self.STATE_HIDDEN
160 class NumberZap(Screen):
167 self.close(int(self["number"].getText()))
169 def keyNumberGlobal(self, number):
170 self.Timer.start(3000, True) #reset timer
171 self.field = self.field + str(number)
172 self["number"].setText(self.field)
173 if len(self.field) >= 4:
176 def __init__(self, session, number):
177 Screen.__init__(self, session)
178 self.field = str(number)
180 self["channel"] = Label(_("Channel:"))
182 self["number"] = Label(self.field)
184 self["actions"] = NumberActionMap( [ "SetupActions" ],
188 "1": self.keyNumberGlobal,
189 "2": self.keyNumberGlobal,
190 "3": self.keyNumberGlobal,
191 "4": self.keyNumberGlobal,
192 "5": self.keyNumberGlobal,
193 "6": self.keyNumberGlobal,
194 "7": self.keyNumberGlobal,
195 "8": self.keyNumberGlobal,
196 "9": self.keyNumberGlobal,
197 "0": self.keyNumberGlobal
200 self.Timer = eTimer()
201 self.Timer.timeout.get().append(self.keyOK)
202 self.Timer.start(3000, True)
204 class InfoBarPowerKey:
205 """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
208 self.powerKeyTimer = eTimer()
209 self.powerKeyTimer.timeout.get().append(self.powertimer)
210 self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
212 "powerdown": self.powerdown,
213 "powerup": self.powerup,
214 "discreteStandby": (self.standby, "Go standby"),
215 "discretePowerOff": (self.quit, "Go to deep standby"),
218 def powertimer(self):
219 print "PowerOff - Now!"
223 self.standbyblocked = 0
224 self.powerKeyTimer.start(3000, True)
227 self.powerKeyTimer.stop()
228 if self.standbyblocked == 0:
229 self.standbyblocked = 1
233 self.session.open(Standby, self)
239 class InfoBarNumberZap:
240 """ Handles an initial number for NumberZapping """
242 self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"],
244 "1": self.keyNumberGlobal,
245 "2": self.keyNumberGlobal,
246 "3": self.keyNumberGlobal,
247 "4": self.keyNumberGlobal,
248 "5": self.keyNumberGlobal,
249 "6": self.keyNumberGlobal,
250 "7": self.keyNumberGlobal,
251 "8": self.keyNumberGlobal,
252 "9": self.keyNumberGlobal,
253 "0": self.keyNumberGlobal,
256 def keyNumberGlobal(self, number):
257 # print "You pressed number " + str(number)
259 self.session.nav.zapLast()
263 self.session.openWithCallback(self.numberEntered, NumberZap, number)
265 def numberEntered(self, retval):
266 # print self.servicelist
268 self.zapToNumber(retval)
270 def searchNumberHelper(self, serviceHandler, num, bouquet):
271 servicelist = serviceHandler.list(bouquet)
272 if not servicelist is None:
274 serviceIterator = servicelist.getNext()
275 if not serviceIterator.valid(): #check end of list
277 if serviceIterator.flags: #assume normal dvb service have no flags set
280 if not num: #found service with searched number ?
281 return serviceIterator, 0
284 def zapToNumber(self, number):
285 bouquet = self.servicelist.bouquet_root
287 serviceHandler = eServiceCenter.getInstance()
288 if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
289 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
291 bouquetlist = serviceHandler.list(bouquet)
292 if not bouquetlist is None:
294 bouquet = bouquetlist.getNext()
295 if not bouquet.valid(): #check end of list
297 if ((bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory):
299 service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
300 if not service is None:
301 self.session.nav.playService(service) #play service
302 if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
303 self.servicelist.setRoot(bouquet)
304 self.servicelist.setCurrentSelection(service) #select the service in servicelist
306 class InfoBarChannelSelection:
307 """ ChannelSelection - handles the channelSelection dialog and the initial
308 channelChange actions which open the channelSelection dialog """
311 self.servicelist = self.session.instantiateDialog(ChannelSelection)
313 self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
315 "switchChannelUp": self.switchChannelUp,
316 "switchChannelDown": self.switchChannelDown,
317 "zapUp": (self.zapUp, _("next channel")),
318 "zapDown": (self.zapDown, _("previous channel")),
321 def switchChannelUp(self):
322 self.servicelist.moveUp()
323 self.session.execDialog(self.servicelist)
325 def switchChannelDown(self):
326 self.servicelist.moveDown()
327 self.session.execDialog(self.servicelist)
330 self.servicelist.moveUp()
331 self.servicelist.zap()
336 self.servicelist.moveDown()
337 self.servicelist.zap()
342 """ Handles a menu action, to open the (main) menu """
344 self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
346 "mainMenu": (self.mainMenu, "Enter main menu..."),
350 print "loading mainmenu XML..."
351 menu = mdom.childNodes[0]
352 assert menu.tagName == "menu", "root element in menu must be 'menu'!"
353 self.session.open(MainMenu, menu, menu.childNodes)
356 """ EPG - Opens an EPG list when the showEPGList action fires """
358 self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
360 "showEPGList": (self.showEPGList, _("show EPG...")),
363 def showEPGList(self):
364 ref=self.session.nav.getCurrentlyPlayingServiceReference()
365 ptr=eEPGCache.getInstance()
366 if ptr.startTimeQuery(ref) != -1:
367 self.session.open(EPGSelection, ref)
368 else: # try to show now/next
369 print 'no epg for service', ref.toString()
372 service = self.session.nav.getCurrentService()
373 info = service.info()
376 self.epglist.append(ptr)
379 self.epglist.append(ptr)
380 if len(self.epglist) > 0:
381 self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
385 def eventViewCallback(self, setEvent, val): #used for now/next displaying
386 if len(self.epglist) > 1:
387 tmp = self.epglist[0]
388 self.epglist[0]=self.epglist[1]
390 setEvent(self.epglist[0])
395 """provides a snr/agc/ber display"""
397 self["snr"] = Label()
398 self["agc"] = Label()
399 self["ber"] = Label()
400 self["snr_percent"] = Label()
401 self["agc_percent"] = Label()
402 self["ber_count"] = Label()
403 self["snr_progress"] = ProgressBar()
404 self["agc_progress"] = ProgressBar()
405 self["ber_progress"] = ProgressBar()
406 self.timer = eTimer()
407 self.timer.timeout.get().append(self.updateTunerInfo)
408 self.timer.start(1000)
414 return (long)(log(val)/log(2))
417 def updateTunerInfo(self):
418 if self.instance.isVisible():
419 service = self.session.nav.getCurrentService()
423 if service is not None:
424 feinfo = service.frontendStatusInfo()
425 if feinfo is not None:
426 ber=feinfo.getFrontendInfo(iFrontendStatusInformation.bitErrorRate)
427 snr=feinfo.getFrontendInfo(iFrontendStatusInformation.signalPower)*100/65536
428 agc=feinfo.getFrontendInfo(iFrontendStatusInformation.signalQuality)*100/65536
429 self["snr_percent"].setText("%d%%"%(snr))
430 self["agc_percent"].setText("%d%%"%(agc))
431 self["ber_count"].setText("%d"%(ber))
432 self["snr_progress"].setValue(snr)
433 self["agc_progress"].setValue(agc)
434 self["ber_progress"].setValue(self.calc(ber))
437 """provides a current/next event info display"""
439 self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
440 self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
442 self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
443 self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
445 self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
446 self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
448 class InfoBarServiceName:
450 self["ServiceName"] = ServiceName(self.session.nav)
454 # ispause, isff, issm, skip
455 SEEK_STATE_PLAY = (0, 0, 0, 0)
456 SEEK_STATE_PAUSE = (1, 0, 0, 0)
457 SEEK_STATE_FF_2X = (0, 2, 0, 0)
458 SEEK_STATE_FF_4X = (0, 4, 0, 0)
459 SEEK_STATE_FF_8X = (0, 8, 0, 0)
460 SEEK_STATE_FF_32X = (0, 4, 0, 32)
461 SEEK_STATE_FF_64X = (0, 4, 0, 64)
462 SEEK_STATE_FF_128X = (0, 4, 0, 128)
464 SEEK_STATE_BACK_4X = (0, 0, 0, -4)
465 SEEK_STATE_BACK_32X = (0, 0, 0, -32)
466 SEEK_STATE_BACK_64X = (0, 0, 0, -64)
467 SEEK_STATE_BACK_128X = (0, 0, 0, -128)
469 SEEK_STATE_SM_HALF = (0, 0, 2, 0)
470 SEEK_STATE_SM_QUARTER = (0, 0, 4, 0)
471 SEEK_STATE_SM_EIGHTH = (0, 0, 8, 0)
473 """handles PVR specific actions like seeking, pause"""
475 self["PVRActions"] = HelpableActionMap(self, "InfobarPVRActions",
477 "pauseService": (self.pauseService, "pause"),
478 "unPauseService": (self.unPauseService, "continue"),
480 "seekFwd": (self.seekFwd, "skip forward"),
481 "seekFwdUp": (self.seekFwdUp, "skip forward"),
482 "seekBack": (self.seekBack, "skip backward"),
483 "seekBackUp": (self.seekBackUp, "skip backward"),
485 "up": (self.showMovies, "movie list"),
486 "down": (self.showMovies, "movie list")
489 self.seekstate = self.SEEK_STATE_PLAY
490 self.seekTimer = eTimer()
491 self.seekTimer.timeout.get().append(self.seekTimerFired)
492 self.skipinterval = 500 # 500ms skip interval
493 self.onClose.append(self.delSeekTimer)
495 self.fwdtimer = False
496 self.fwdKeyTimer = eTimer()
497 self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire)
499 self.rwdtimer = False
500 self.rwdKeyTimer = eTimer()
501 self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
509 def delSeekTimer(self):
512 def seekTimerFired(self):
513 self.seekbase += self.skipmode * self.skipinterval
515 # check if we bounced against the beginning of the file
516 if self.seekbase < 0:
518 self.setSeekState(self.SEEK_STATE_PLAY)
520 self.doSeek(self.seekbase)
522 def setSeekState(self, state):
523 oldstate = self.seekstate
525 self.seekstate = state
527 service = self.session.nav.getCurrentService()
531 pauseable = service.pause()
534 if oldstate[i] != self.seekstate[i]:
535 (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion, self.setSkipMode)[i](self.seekstate[i])
537 def setSkipMode(self, skipmode):
538 self.skipmode = skipmode
540 self.seekTimer.stop()
542 self.seekTimer.start(500)
544 service = self.session.nav.getCurrentService()
548 seekable = service.seek()
553 seekable.setTrickmode(1)
555 seekable.setTrickmode(0)
557 self.seekbase = seekable.getPlayPosition()[1] / 90
559 def pauseService(self):
560 if (self.seekstate == self.SEEK_STATE_PAUSE):
561 self.unPauseService()
563 self.setSeekState(self.SEEK_STATE_PAUSE);
565 def unPauseService(self):
566 self.setSeekState(self.SEEK_STATE_PLAY);
568 def doSeek(self, seektime):
569 service = self.session.nav.getCurrentService()
573 seekable = service.seek()
576 seekable.seekTo(90 * seektime)
579 print "start fwd timer"
581 self.fwdKeyTimer.start(500)
584 print "start rewind timer"
586 self.rwdKeyTimer.start(500)
590 self.fwdKeyTimer.stop()
591 self.fwdtimer = False
593 self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
594 self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
595 self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
596 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
597 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_32X,
598 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_64X,
599 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
600 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
601 self.SEEK_STATE_BACK_4X: self.SEEK_STATE_PLAY,
602 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_4X,
603 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
604 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
605 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
606 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
607 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
609 self.setSeekState(lookup[self.seekstate]);
611 def seekBackUp(self):
613 self.rwdKeyTimer.stop()
614 self.rwdtimer = False
617 self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_4X,
618 self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
619 self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
620 self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
621 self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
622 self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_8X,
623 self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
624 self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
625 self.SEEK_STATE_BACK_4X: self.SEEK_STATE_BACK_32X,
626 self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_64X,
627 self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
628 self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
629 self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
630 self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
631 self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
633 self.setSeekState(lookup[self.seekstate]);
635 def fwdTimerFire(self):
636 print "Display seek fwd"
637 self.fwdKeyTimer.stop()
638 self.fwdtimer = False
639 self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
641 def fwdSeekTo(self, minutes):
642 print "Seek", minutes, "minutes forward"
643 service = self.session.nav.getCurrentService()
646 seekable = service.seek()
649 seekable.seekRelative(1, minutes * 60 * 90000)
651 def rwdTimerFire(self):
652 self.rwdKeyTimer.stop()
653 self.rwdtimer = False
654 self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
656 def rwdSeekTo(self, minutes):
657 self.fwdSeekTo(0 - minutes)
659 from RecordTimer import parseEvent
661 class InfoBarInstantRecord:
662 """Instant Record - handles the instantRecord action in order to
663 start/stop instant records"""
665 self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
667 "instantRecord": (self.instantRecord, "Instant Record..."),
669 self.recording = None
671 self["BlinkingPoint"] = BlinkingPixmapConditional()
672 self.onShown.append(self["BlinkingPoint"].hideWidget)
673 self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
675 def stopCurrentRecording(self):
676 self.session.nav.RecordTimer.removeEntry(self.recording)
677 self.recording = None
679 def startInstantRecording(self):
680 serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
682 # try to get event info
685 service = self.session.nav.getCurrentService()
686 info = service.info()
687 ev = info.getEvent(0)
692 if event is not None:
693 data = parseEvent(event)
694 data = (data[0], data[1] + 3600 * 10, data[2], data[3], data[4])
696 data = (time.time(), time.time() + 3600 * 10, "instant record", "", None)
698 # fix me, description.
699 self.recording = self.session.nav.recordWithTimer(serviceref, *data)
700 self.recording.dontSave = True
702 #self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
704 def isInstantRecordRunning(self):
705 if self.recording != None:
706 if self.recording.isRunning():
710 def recordQuestionCallback(self, answer):
714 if self.isInstantRecordRunning():
715 self.stopCurrentRecording()
717 self.startInstantRecording()
719 def instantRecord(self):
721 stat = os.stat("/hdd/movies")
723 self.session.open(MessageBox, "No HDD found!", MessageBox.TYPE_ERROR)
726 if self.isInstantRecordRunning():
727 self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?"))
729 self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?"))
731 from Screens.AudioSelection import AudioSelection
733 class InfoBarAudioSelection:
735 self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
737 "audioSelection": (self.audioSelection, "Audio Options..."),
740 def audioSelection(self):
741 service = self.session.nav.getCurrentService()
742 audio = service.audioTracks()
743 n = audio.getNumberOfTracks()
745 self.session.open(AudioSelection, audio)
747 from Screens.SubserviceSelection import SubserviceSelection
749 class InfoBarSubserviceSelection:
751 self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
753 "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
756 def subserviceSelection(self):
757 service = self.session.nav.getCurrentService()
758 subservices = service.subServices()
759 n = subservices.getNumberOfSubservices()
761 self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
763 def subserviceSelected(self, service):
764 if not service is None:
765 self.session.nav.playService(service)
767 class InfoBarAdditionalInfo:
769 self["DolbyActive"] = Pixmap()
770 self["CryptActive"] = Pixmap()
771 self["FormatActive"] = Pixmap()
773 self["ButtonRed"] = PixmapConditional(withTimer = False)
774 self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
775 self.onShown.append(self["ButtonRed"].update)
776 self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False)
777 self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
778 self.onShown.append(self["ButtonRedText"].update)
780 self["ButtonGreen"] = Pixmap()
781 self["ButtonGreenText"] = Label(_("Subservices"))
783 self["ButtonYellow"] = PixmapConditional(withTimer = False)
784 self["ButtonYellow"].setConnect(lambda: False)
786 self["ButtonBlue"] = PixmapConditional(withTimer = False)
787 self["ButtonBlue"].setConnect(lambda: False)
789 self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
791 def hideSubServiceIndication(self):
792 self["ButtonGreen"].hideWidget()
793 self["ButtonGreenText"].hide()
795 def showSubServiceIndication(self):
796 self["ButtonGreen"].showWidget()
797 self["ButtonGreenText"].show()
799 def checkFormat(self, service):
800 info = service.info()
802 aspect = info.getInfo(iServiceInformation.sAspect)
803 if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]:
804 self["FormatActive"].showWidget()
806 self["FormatActive"].hideWidget()
808 def checkSubservices(self, service):
809 if service.subServices().getNumberOfSubservices() > 0:
810 self.showSubServiceIndication()
812 self.hideSubServiceIndication()
814 def checkDolby(self, service):
816 audio = service.audioTracks()
817 if audio is not None:
818 n = audio.getNumberOfTracks()
820 i = audio.getTrackInfo(x)
821 description = i.getDescription();
822 if description.find("AC3") != -1 or description.find("DTS") != -1:
826 self["DolbyActive"].showWidget()
828 self["DolbyActive"].hideWidget()
830 def checkCrypted(self, service):
831 info = service.info()
833 if info.getInfo(iServiceInformation.sIsCrypted) > 0:
834 self["CryptActive"].showWidget()
836 self["CryptActive"].hideWidget()
838 def gotServiceEvent(self, ev):
839 service = self.session.nav.getCurrentService()
840 if ev == pNavigation.evUpdatedEventInfo:
841 self.checkSubservices(service)
842 self.checkFormat(service)
843 elif ev == pNavigation.evUpdatedInfo:
844 self.checkCrypted(service)
845 self.checkDolby(service)
846 elif ev == pNavigation.evStopService:
847 self.hideSubServiceIndication()
848 self["CryptActive"].hideWidget()
849 self["DolbyActive"].hideWidget()
850 self["FormatActive"].hideWidget()
852 class InfoBarNotifications:
854 self.onExecBegin.append(self.checkNotifications)
855 Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
857 def checkNotificationsIfExecing(self):
859 self.checkNotifications()
861 def checkNotifications(self):
862 if len(Notifications.notifications):
863 n = Notifications.notifications[0]
864 Notifications.notifications = Notifications.notifications[1:]
868 self.session.openWithCallback(cb, *n[1:])
870 self.session.open(*n[1:])