from Components.ProgressBar import *
from Components.ServiceEventTracker import ServiceEventTracker
from Components.ServiceName import ServiceName
-from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean
+from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry
from Components.config import configfile, configsequencearg
from Components.TimerList import TimerEntryComponent
from Components.TunerInfo import TunerInfo
from Screens.MessageBox import MessageBox
from Screens.MinuteInput import MinuteInput
from Screens.TimerSelection import TimerSelection
+from Screens.PictureInPicture import PictureInPicture
+from Screens.SubtitleDisplay import SubtitleDisplay
from ServiceReference import ServiceReference
from Tools import Notifications
"zapUp": (self.zapUp, _("previous channel")),
"zapDown": (self.zapDown, _("next channel")),
"historyBack": (self.historyBack, _("previous channel in history")),
- "historyNext": (self.historyNext, _("next channel in history"))
+ "historyNext": (self.historyNext, _("next channel in history")),
+ "openServiceList": (self.openServiceList, _("open service list")),
})
def firstRun(self):
config.misc.initialchannelselection.value = 0
config.misc.initialchannelselection.save()
self.switchChannelDown()
-
+
def historyBack(self):
self.servicelist.historyBack()
def switchChannelDown(self):
self.servicelist.moveDown()
self.session.execDialog(self.servicelist)
+
+ def openServiceList(self):
+ self.session.execDialog(self.servicelist)
def zapUp(self):
if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes":
class InfoBarEPG:
""" EPG - Opens an EPG list when the showEPGList action fires """
def __init__(self):
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
+ })
+
+ self.is_now_next = False
+ self.dlg_stack = [ ]
+ self.bouquetSel = None
+ self.eventView = None
self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
"showEventInfo": (self.openEventView, _("show EPG...")),
self.servicelist.setCurrentSelection(service) #select the service in servicelist
self.servicelist.zap()
- def openBouquetEPG(self, bouquet, withCallback=True):
- ptr=eEPGCache.getInstance()
+ def getBouquetServices(self, bouquet):
services = [ ]
servicelist = eServiceCenter.getInstance().list(bouquet)
if not servicelist is None:
if service.flags: #ignore non playable services
continue
services.append(ServiceReference(service))
+ return services
+
+ def openBouquetEPG(self, bouquet, withCallback=True):
+ services = self.getBouquetServices(bouquet)
if len(services):
self.epg_bouquet = bouquet
if withCallback:
- self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService)
+ self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
else:
- self.session.open(EPGSelection, services, self.zapToService)
+ self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
- def closed(self, ret):
+ def changeBouquetCB(self, direction, epg):
+ if self.bouquetSel:
+ if direction > 0:
+ self.bouquetSel.down()
+ else:
+ self.bouquetSel.up()
+ bouquet = self.bouquetSel.getCurrent()
+ services = self.getBouquetServices(bouquet)
+ if len(services):
+ self.epg_bouquet = bouquet
+ epg.setServices(services)
+
+ def closed(self, ret=False):
+ closedScreen = self.dlg_stack.pop()
+ if self.bouquetSel and closedScreen == self.bouquetSel:
+ self.bouquetSel = None
+ elif self.eventView and closedScreen == self.eventView:
+ self.eventView = None
if ret:
- self.close(ret)
+ dlgs=len(self.dlg_stack)
+ if dlgs > 0:
+ self.dlg_stack[dlgs-1].close(dlgs > 1)
def openMultiServiceEPG(self, withCallback=True):
bouquets = self.servicelist.getBouquetList()
cnt = len(bouquets)
if cnt > 1: # show bouquet list
if withCallback:
- self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG)
+ self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
+ self.dlg_stack.append(self.bouquetSel)
else:
- self.session.open(BouquetSelector, bouquets, self.openBouquetEPG)
+ self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
elif cnt == 1:
self.openBouquetEPG(bouquets[0][1], withCallback)
def openSingleServiceEPG(self):
ref=self.session.nav.getCurrentlyPlayingServiceReference()
- ptr=eEPGCache.getInstance()
- self.session.openWithCallback(self.closed, EPGSelection, ref)
+ self.session.open(EPGSelection, ref)
- def openEventView(self):
+ def openSimilarList(self, eventid, refstr):
+ self.session.open(EPGSelection, refstr, None, eventid)
+
+ def getNowNext(self):
self.epglist = [ ]
service = self.session.nav.getCurrentService()
- ref = self.session.nav.getCurrentlyPlayingServiceReference()
- info = service.info()
- ptr=info.getEvent(0)
+ info = service and service.info()
+ ptr = info and info.getEvent(0)
if ptr:
self.epglist.append(ptr)
- ptr=info.getEvent(1)
+ ptr = info and info.getEvent(1)
if ptr:
self.epglist.append(ptr)
+
+ def __evEventInfoChanged(self):
+ if self.is_now_next and len(self.dlg_stack) == 1:
+ self.getNowNext()
+ assert self.eventView
+ if len(self.epglist):
+ self.eventView.setEvent(self.epglist[0])
+
+ def openEventView(self):
+ ref = self.session.nav.getCurrentlyPlayingServiceReference()
+ self.getNowNext()
if len(self.epglist) == 0:
+ self.is_now_next = False
epg = eEPGCache.getInstance()
- ptr = epg.lookupEventTime(ref, -1)
+ ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
if ptr:
self.epglist.append(ptr)
ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
if ptr:
self.epglist.append(ptr)
+ else:
+ self.is_now_next = True
if len(self.epglist) > 0:
- self.session.open(EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG)
+ self.eventView = self.session.openWithCallback(self.closed, EventViewEPGSelect, self.epglist[0], ServiceReference(ref), self.eventViewCallback, self.openSingleServiceEPG, self.openMultiServiceEPG, self.openSimilarList)
+ self.dlg_stack.append(self.eventView)
else:
print "no epg for the service avail.. so we show multiepg instead of eventinfo"
self.openMultiServiceEPG(False)
self["snr"] = Label()
self["agc"] = Label()
self["ber"] = Label()
- self["snr_percent"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, self.session.nav.getCurrentService)
- self["agc_percent"] = TunerInfo(TunerInfo.AGC_PERCENTAGE, self.session.nav.getCurrentService)
- self["ber_count"] = TunerInfo(TunerInfo.BER_VALUE, self.session.nav.getCurrentService)
- self["snr_progress"] = TunerInfo(TunerInfo.SNR_BAR, self.session.nav.getCurrentService)
- self["agc_progress"] = TunerInfo(TunerInfo.AGC_BAR, self.session.nav.getCurrentService)
- self["ber_progress"] = TunerInfo(TunerInfo.BER_BAR, self.session.nav.getCurrentService)
+ self["snr_percent"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, servicefkt = self.session.nav.getCurrentService)
+ self["agc_percent"] = TunerInfo(TunerInfo.AGC_PERCENTAGE, servicefkt = self.session.nav.getCurrentService)
+ self["ber_count"] = TunerInfo(TunerInfo.BER_VALUE, servicefkt = self.session.nav.getCurrentService)
+ self["snr_progress"] = TunerInfo(TunerInfo.SNR_BAR, servicefkt = self.session.nav.getCurrentService)
+ self["agc_progress"] = TunerInfo(TunerInfo.AGC_BAR, servicefkt = self.session.nav.getCurrentService)
+ self["ber_progress"] = TunerInfo(TunerInfo.BER_BAR, servicefkt = self.session.nav.getCurrentService)
self.timer = eTimer()
self.timer.timeout.get().append(self.updateTunerInfo)
self.timer.start(1000)
def getSeek(self):
service = self.session.nav.getCurrentService()
if service is None:
- return False
+ return None
seek = service.seek()
def unPauseService(self):
print "unpause"
+ if self.seekstate == self.SEEK_STATE_PLAY:
+ return 0
self.setSeekState(self.SEEK_STATE_PLAY);
def doSeek(self, seektime):
def getTimeshift(self):
service = self.session.nav.getCurrentService()
- return service.timeshift()
+ return service and service.timeshift()
def startTimeshift(self):
print "enable timeshift"
self.timeshift_enabled = False
self.__seekableStatusChanged()
+from Screens.PiPSetup import PiPSetup
+
+class InfoBarExtensions:
+ def __init__(self):
+ self.pipshown = False
+
+ self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
+ {
+ "extensions": (self.extensions, "Extensions..."),
+ })
+
+ PIPON = 0
+ PIPOFF = 1
+ MOVEPIP = 2
+ PIPSWAP = 3
+ ENABLE_SUBTITLE = 4
+
+ def extensions(self):
+ list = []
+ if self.pipshown == False:
+ list.append((_("Activate Picture in Picture"), self.PIPON))
+ elif self.pipshown == True:
+ list.append((_("Disable Picture in Picture"), self.PIPOFF))
+ list.append((_("Move Picture in Picture"), self.MOVEPIP))
+ list.append((_("Swap services"), self.PIPSWAP))
+
+ s = self.getCurrentServiceSubtitle()
+ l = s and s.getSubtitleList() or [ ]
+
+ for x in l:
+ list.append(("DEBUG: Enable Subtitles: " + x[0], self.ENABLE_SUBTITLE, x[1]))
+
+ self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list)
+
+ def extensionCallback(self, answer):
+ if answer is not None:
+ if answer[1] == self.PIPON:
+ self.pip = self.session.instantiateDialog(PictureInPicture)
+
+ newservice = self.session.nav.getCurrentlyPlayingServiceReference()
+
+ if self.pip.playService(newservice):
+ self.pipshown = True
+ else:
+ self.pipshown = False
+ del self.pip
+ self.session.nav.playService(newservice)
+ elif answer[1] == self.PIPOFF:
+ del self.pip
+ self.pipshown = False
+ elif answer[1] == self.PIPSWAP:
+ swapservice = self.pip.getCurrentService()
+ self.pip.playService(self.session.nav.getCurrentlyPlayingServiceReference())
+ self.session.nav.playService(swapservice)
+
+ elif answer[1] == self.MOVEPIP:
+ self.session.open(PiPSetup, pip = self.pip)
+ elif answer[1] == self.ENABLE_SUBTITLE:
+ self.selected_subtitle = answer[2]
+ self.subtitles_enabled = True
+
from RecordTimer import parseEvent
class InfoBarInstantRecord:
return False
def recordQuestionCallback(self, answer):
+ print "pre:\n", self.recording
+
if answer is None or answer[1] == "no":
return
list = []
- for x in self.recording:
- if x.dontSave:
+ recording = self.recording[:]
+ for x in recording:
+ if not x in self.session.nav.RecordTimer.timer_list:
+ self.recording.remove(x)
+ elif x.dontSave and x.isRunning():
list.append(TimerEntryComponent(x, False))
if answer[1] == "changeduration":
if answer[1] == "event":
limitEvent = True
if answer[1] == "manualduration":
+ self.selectedEntry = len(self.recording)
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)
+
+ print "after:\n", self.recording
def changeDuration(self, entry):
if entry is not None:
else:
self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"),(_("don't record"), "no")])
-from Screens.AudioSelection import AudioSelection
+from Tools.ISO639 import LanguageCodes
class InfoBarAudioSelection:
def __init__(self):
def audioSelection(self):
service = self.session.nav.getCurrentService()
audio = service.audioTracks()
+ self.audioTracks = audio
n = audio.getNumberOfTracks()
+ keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+ tlist = []
+ print "tlist:", tlist
if n > 0:
- self.session.open(AudioSelection, audio)
+ self.audioChannel = service.audioChannel()
+
+ 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]))
+
+ selection = 2
+ for x in tlist:
+ if x[1] != selectedAudio:
+ selection += 1
+ else:
+ break
+
+ tlist = [([_("Left"), _("Stereo"), _("Right")][self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
+ self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys)
+ else:
+ del self.audioTracks
+
+ def audioSelected(self, audio):
+ if audio is not None:
+ if isinstance(audio[1], str):
+ if audio[1] == "mode":
+ keys = ["red", "green", "yellow"]
+ selection = self.audioChannel.getCurrentChannel()
+ tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
+ self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys)
+ else:
+ del self.audioChannel
+ if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
+ self.audioTracks.selectTrack(audio[1])
+ else:
+ del self.audioChannel
+ del self.audioTracks
-from Screens.SubserviceSelection import SubserviceSelection
+ def modeSelected(self, mode):
+ if mode is not None:
+ self.audioChannel.selectChannel(mode[1])
+ del self.audioChannel
class InfoBarSubserviceSelection:
def __init__(self):
self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
{
- "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
+ "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 and service.subServices()
+ if not subservices or 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 and service.subServices()
+ n = subservices and subservices.getNumberOfSubservices()
+ if n and 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()
- if n > 0:
- self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
+ subservices = service and service.subServices()
+
+ n = subservices and subservices.getNumberOfSubservices()
+ selection = 0
+ if n and 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.session.nav.playService(service)
+ self["SubserviceQuickzapAction"].setEnabled(True)
+ self.session.nav.playService(service[1])
class InfoBarAdditionalInfo:
def __init__(self):
self.onLayoutFinish.append(self["ButtonYellowText"].update)
self["ButtonBlue"] = PixmapConditional(withTimer = False)
- self["ButtonBlue"].setConnect(lambda: False)
+ self["ButtonBlue"].setConnect(lambda: True)
self["ButtonBlueText"] = LabelConditional(text = _("Extensions"), withTimer = False)
- self["ButtonBlueText"].setConnect(lambda: False)
+ self["ButtonBlueText"].setConnect(lambda: True)
self.onLayoutFinish.append(self["ButtonBlue"].update)
self.onLayoutFinish.append(self["ButtonBlueText"].update)
def __init__(self):
self.onExecBegin.append(self.checkNotifications)
Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
+ self.onClose.append(self.__removeNotification)
+
+ def __removeNotification(self):
+ Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
def checkNotificationsIfExecing(self):
if self.execing:
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:])
+ self.session.openWithCallback(cb, n[1], *n[2], **n[3])
else:
- self.session.open(*n[1:])
+ self.session.open(n[1], *n[2], **n[3])
class InfoBarServiceNotifications:
def __init__(self):
def startTeletext(self):
self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
+
+class InfoBarSubtitleSupport(object):
+ def __init__(self):
+ object.__init__(self)
+ self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
+ self.__subtitles_enabled = False
+
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evStart: self.__serviceStarted,
+ })
+
+ def __serviceStarted(self):
+ # reenable if it was enabled
+ r = self.__subtitles_enabled
+ self.__subtitles_enabled = False
+ self.__selected_subtitle = None
+ self.setSubtitlesEnable(r)
+
+ def getCurrentServiceSubtitle(self):
+ service = self.session.nav.getCurrentService()
+ return service and service.subtitle()
+
+ def setSubtitlesEnable(self, enable=True):
+ subtitle = self.getCurrentServiceSubtitle()
+ if enable and self.__selected_subtitle:
+ if subtitle and not self.__subtitles_enabled:
+ subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
+ self.subtitle_window.show()
+ self.__subtitles_enabled = True
+ else:
+ if subtitle:
+ subtitle.disableSubtitles(self.subtitle_window.instance)
+
+ self.subtitle_window.hide()
+ self.__subtitles_enabled = False
+
+ def setSelectedSubtitle(self, subtitle):
+ if self.__selected_subtitle != subtitle and self.subtitles_enabled:
+ # kick
+ self.__selected_subtitle = subtitle
+ self.__serviceStarted()
+ else:
+ self.__selected_subtitle = subtitle
+
+ subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
+ selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)