+# self.audioChannel = service.audioChannel()
+# config.audio.audiochannel = configElement_nonSave("config.audio.audiochannel", configSelection, self.audioChannel.getCurrentChannel(), (("left", _("Left >")), ("stereo", _("< Stereo >")), ("right", _("< Right"))))
+ tlist = []
+ for x in range(n):
+ i = audio.getTrackInfo(x)
+ language = i.getLanguage()
+ description = i.getDescription();
+
+ if len(language) == 3:
+ if language in LanguageCodes:
+ language = LanguageCodes[language][0]
+
+ if len(description):
+ description += " (" + language + ")"
+ else:
+ description = language
+
+ tlist.append((description, x))
+
+ selectedAudio = tlist[0][1]
+ tlist.sort(lambda x,y : cmp(x[0], y[0]))
+
+# tlist.insert(0, getConfigListEntry(_("Audio Channel"), config.audio.audiochannel))
+
+ selection = 0
+ for x in tlist:
+ if x[1] != selectedAudio:
+ selection += 1
+ else:
+ break
+
+ self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection)
+ else:
+ del self.audioTracks
+
+ def audioSelected(self, audio):
+ if audio is not None:
+ self.audioTracks.selectTrack(audio[1])
+ del self.audioTracks
+# del self.audioChannel
+# del config.audio.audiochannel
+
+class InfoBarSubserviceSelection:
+ def __init__(self):
+ self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
+ {
+ "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
+ })
+
+ self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
+ {
+ "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
+ "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
+ }, -1)
+ self["SubserviceQuickzapAction"].setEnabled(False)
+
+ self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
+
+ def checkSubservicesAvail(self, ev):
+ if ev == iPlayableService.evUpdatedEventInfo:
+ service = self.session.nav.getCurrentService()
+ subservices = service.subServices()
+ if subservices.getNumberOfSubservices() == 0:
+ self["SubserviceQuickzapAction"].setEnabled(False)
+
+ def nextSubservice(self):
+ self.changeSubservice(+1)
+
+ def prevSubservice(self):
+ self.changeSubservice(-1)
+
+ def changeSubservice(self, direction):
+ service = self.session.nav.getCurrentService()
+ subservices = service.subServices()
+ n = subservices.getNumberOfSubservices()
+ if n > 0:
+ selection = -1
+ ref = self.session.nav.getCurrentlyPlayingServiceReference()
+ for x in range(n):
+ if subservices.getSubservice(x).toString() == ref.toString():
+ selection = x
+ if selection != -1:
+ selection += direction
+ if selection >= n:
+ selection=0
+ elif selection < 0:
+ selection=n-1
+ newservice = subservices.getSubservice(selection)
+ if newservice.valid():
+ del subservices
+ del service
+ self.session.nav.playService(newservice)
+
+ def subserviceSelection(self):
+ service = self.session.nav.getCurrentService()
+ subservices = service.subServices()
+
+ n = subservices.getNumberOfSubservices()
+ selection = 0
+ if n > 0:
+ ref = self.session.nav.getCurrentlyPlayingServiceReference()
+ tlist = []
+ for x in range(n):
+ i = subservices.getSubservice(x)
+ if i.toString() == ref.toString():
+ selection = x
+ tlist.append((i.getName(), i))
+
+ self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection)
+
+ def subserviceSelected(self, service):
+ if not service is None:
+ self["SubserviceQuickzapAction"].setEnabled(True)
+ self.session.nav.playService(service[1])
+
+class InfoBarAdditionalInfo:
+ def __init__(self):
+ self["DolbyActive"] = Pixmap()
+ self["CryptActive"] = Pixmap()
+ self["FormatActive"] = Pixmap()
+
+ self["ButtonRed"] = PixmapConditional(withTimer = False)
+ self["ButtonRed"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
+ self.onLayoutFinish.append(self["ButtonRed"].update)
+ self["ButtonRedText"] = LabelConditional(text = _("Record"), withTimer = False)
+ self["ButtonRedText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
+ self.onLayoutFinish.append(self["ButtonRedText"].update)
+
+ self["ButtonGreen"] = Pixmap()
+ self["ButtonGreenText"] = Label(_("Subservices"))
+
+ self["ButtonYellow"] = PixmapConditional(withTimer = False)
+ self["ButtonYellow"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
+ self["ButtonYellowText"] = LabelConditional(text = _("Timeshifting"), withTimer = False)
+ self["ButtonYellowText"].setConnect(lambda: harddiskmanager.HDDCount() > 0)
+ self.onLayoutFinish.append(self["ButtonYellow"].update)
+ self.onLayoutFinish.append(self["ButtonYellowText"].update)
+
+ self["ButtonBlue"] = PixmapConditional(withTimer = False)
+ self["ButtonBlue"].setConnect(lambda: True)
+ self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)
+ self["ButtonBlueText"].setConnect(lambda: True)
+ self.onLayoutFinish.append(self["ButtonBlue"].update)
+ self.onLayoutFinish.append(self["ButtonBlueText"].update)
+
+ self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
+
+ def hideSubServiceIndication(self):
+ self["ButtonGreen"].hide()
+ self["ButtonGreenText"].hide()
+
+ def showSubServiceIndication(self):
+ self["ButtonGreen"].show()
+ 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"].show()
+ else:
+ self["FormatActive"].hide()
+
+ def checkSubservices(self, service):
+ if service.subServices().getNumberOfSubservices() > 0:
+ self.showSubServiceIndication()
+ else:
+ self.hideSubServiceIndication()
+
+ def checkDolby(self, service):
+ # FIXME
+ 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"].show()
+ else:
+ self["DolbyActive"].hide()
+
+ def checkCrypted(self, service):
+ info = service.info()
+ if info is not None:
+ if info.getInfo(iServiceInformation.sIsCrypted) > 0:
+ self["CryptActive"].show()
+ else:
+ self["CryptActive"].hide()
+
+ def gotServiceEvent(self, ev):
+ service = self.session.nav.getCurrentService()
+ if ev == iPlayableService.evUpdatedEventInfo:
+ self.checkSubservices(service)
+ self.checkFormat(service)
+ elif ev == iPlayableService.evUpdatedInfo:
+ self.checkCrypted(service)
+ self.checkDolby(service)
+ elif ev == iPlayableService.evEnd:
+ self.hideSubServiceIndication()
+ self["CryptActive"].hide()
+ self["DolbyActive"].hide()
+ self["FormatActive"].hide()
+
+class InfoBarNotifications:
+ def __init__(self):
+ self.onExecBegin.append(self.checkNotifications)
+ Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
+
+ def checkNotificationsIfExecing(self):
+ try:
+ if self.execing:
+ self.checkNotifications()
+ except:
+ print "******************************* A SEVERE ERROR HAPPENED... Someone who understands the code... please fix :) *******"
+
+ def checkNotifications(self):
+ if len(Notifications.notifications):
+ n = Notifications.notifications[0]
+ Notifications.notifications = Notifications.notifications[1:]
+ print "open",n
+ cb = n[0]
+ if cb is not None:
+ self.session.openWithCallback(cb, n[1], *n[2], **n[3])
+ else:
+ self.session.open(n[1], *n[2], **n[3])
+
+class InfoBarServiceNotifications:
+ def __init__(self):
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evEnd: self.serviceHasEnded
+ })
+
+ def serviceHasEnded(self):
+ print "service end!"
+
+ try:
+ self.setSeekState(self.SEEK_STATE_PLAY)
+ except:
+ pass
+
+class InfoBarCueSheetSupport:
+ CUT_TYPE_IN = 0
+ CUT_TYPE_OUT = 1
+ CUT_TYPE_MARK = 2
+
+ def __init__(self):
+ self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions",
+ {
+ "jumpPreviousMark": (self.jumpPreviousMark, "jump to next marked position"),
+ "jumpNextMark": (self.jumpNextMark, "jump to previous marked position"),
+ "toggleMark": (self.toggleMark, "toggle a cut mark at the current position")
+ }, prio=1)
+
+ self.cut_list = [ ]
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evStart: self.__serviceStarted,
+ })
+
+ def __serviceStarted(self):
+ print "new service started! trying to download cuts!"
+ self.downloadCuesheet()
+
+ def __getSeekable(self):
+ service = self.session.nav.getCurrentService()
+ if service is None:
+ return None
+ return service.seek()
+
+ def cueGetCurrentPosition(self):
+ seek = self.__getSeekable()
+ if seek is None:
+ return None
+ r = seek.getPlayPosition()
+ if r[0]:
+ return None
+ return long(r[1])
+
+ def jumpPreviousNextMark(self, cmp, alternative=None):
+ current_pos = self.cueGetCurrentPosition()
+ if current_pos is None:
+ return
+ mark = self.getNearestCutPoint(current_pos, cmp=cmp)
+ if mark is not None:
+ pts = mark[0]
+ elif alternative is not None:
+ pts = alternative
+ else:
+ return
+
+ seekable = self.__getSeekable()
+ if seekable is not None:
+ seekable.seekTo(pts)
+
+ def jumpPreviousMark(self):
+ # 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):
+ self.jumpPreviousNextMark(lambda x: x)
+
+ def getNearestCutPoint(self, pts, cmp=abs):
+ # can be optimized
+ nearest = None
+ for cp in self.cut_list:
+ diff = cmp(cp[0] - pts)
+ if diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
+ nearest = cp
+ return nearest
+
+ 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
+
+ nearest_cutpoint = self.getNearestCutPoint(current_pos)
+
+ 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):
+ service = self.session.nav.getCurrentService()
+ if service is None:
+ return None
+ return service.cueSheet()
+
+ def uploadCuesheet(self):
+ cue = self.__getCuesheet()
+
+ if cue is None:
+ print "upload failed, no cuesheet interface"
+ return
+ cue.setCutList(self.cut_list)
+
+ def downloadCuesheet(self):
+ cue = self.__getCuesheet()
+
+ if cue is None:
+ print "upload failed, no cuesheet interface"
+ return
+ self.cut_list = cue.getCutList()
+
+class InfoBarSummary(Screen):
+ skin = """
+ <screen position="0,0" size="132,64">
+ <widget name="Clock" position="50,46" size="82,18" font="Regular;16" />
+ <widget name="CurrentService" position="0,4" size="132,42" font="Regular;18" />
+ </screen>"""
+
+ 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
+
+class InfoBarTeletextPlugin:
+ def __init__(self):
+ self.teletext_plugin = None
+
+ for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
+ self.teletext_plugin = p
+
+ if self.teletext_plugin is not None:
+ self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
+ {
+ "startTeletext": (self.startTeletext, "View teletext...")
+ })
+ else:
+ print "no teletext plugin found!"
+
+ def startTeletext(self):
+ self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())