from Components.ActionMap import ActionMap, HelpableActionMap
from Components.ActionMap import NumberActionMap
from Components.BlinkingPixmap import BlinkingPixmapConditional
-from Components.Clock import Clock
-from Components.EventInfo import EventInfo, EventInfoProgress
from Components.Harddisk import harddiskmanager
from Components.Input import Input
from Components.Label import *
from Components.PluginComponent import plugins
from Components.ProgressBar import *
from Components.ServiceEventTracker import ServiceEventTracker
-from Components.ServiceName import ServiceName
-from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry
-from Components.config import configfile, configsequencearg
+from Components.Sources.CurrentService import CurrentService
+from Components.Sources.EventInfo import EventInfo
+from Components.Sources.RadioText import RadioText
+from Components.Sources.FrontendStatus import FrontendStatus
+from Components.Sources.Boolean import Boolean
+from Components.Sources.Clock import Clock
from Components.TimerList import TimerEntryComponent
-from Components.TunerInfo import TunerInfo
+from Components.config import config, ConfigBoolean
from EpgSelection import EPGSelection
from Plugins.Plugin import PluginDescriptor
from Screens.TimerSelection import TimerSelection
from Screens.PictureInPicture import PictureInPicture
from Screens.SubtitleDisplay import SubtitleDisplay
+from Screens.SleepTimerEdit import SleepTimerEdit
from ServiceReference import ServiceReference
from Tools import Notifications
-from Tools.Directories import *
+from Tools.Directories import SCOPE_HDD, resolveFilename
-#from enigma import eTimer, eDVBVolumecontrol, quitMainloop
-from enigma import *
+from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
+ iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
-import time
-import os
-import bisect
-
-from Components.config import config, currentConfigSelectionElement
+from time import time
+from os import stat as os_stat
+from bisect import insort
# hack alert!
from Menu import MainMenu, mdom
def startHideTimer(self):
if self.__state == self.STATE_SHOWN and not self.__locked:
- self.hideTimer.start(5000, True)
+ idx = config.usage.infobar_timeout.index
+ if idx:
+ self.hideTimer.start(idx*1000, True)
def __onHide(self):
self.__state = self.STATE_HIDDEN
# print "You pressed number " + str(number)
if number == 0:
self.servicelist.recallPrevService()
- self.doShow()
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
else:
self.session.openWithCallback(self.numberEntered, NumberZap, number)
serviceIterator = servicelist.getNext()
if not serviceIterator.valid(): #check end of list
break
- if serviceIterator.flags: #assume normal dvb service have no flags set
- continue
- num -= 1;
+ playable = not (serviceIterator.flags & (eServiceReference.isMarker|eServiceReference.isDirectory))
+ if playable:
+ num -= 1;
if not num: #found service with searched number ?
return serviceIterator, 0
return None, num
bouquet = self.servicelist.bouquet_root
service = None
serviceHandler = eServiceCenter.getInstance()
- if bouquet.toString().find('FROM BOUQUET "bouquets.') == -1: #FIXME HACK
+ if not config.usage.multibouquet.value:
service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
else:
bouquetlist = serviceHandler.list(bouquet)
if not bouquetlist is None:
while number:
- bouquet = self.servicelist.appendDVBTypes(bouquetlist.getNext())
+ bouquet = bouquetlist.getNext()
if not bouquet.valid(): #check end of list
break
- if (bouquet.flags & eServiceReference.flagDirectory) != eServiceReference.flagDirectory:
- continue
- service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
+ if bouquet.flags & eServiceReference.isDirectory:
+ service, number = self.searchNumberHelper(serviceHandler, number, bouquet)
if not service is None:
if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
self.servicelist.clearPath()
self.servicelist.setCurrentSelection(service) #select the service in servicelist
self.servicelist.zap()
-config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1);
+config.misc.initialchannelselection = ConfigBoolean(default = True)
class InfoBarChannelSelection:
""" ChannelSelection - handles the channelSelection dialog and the initial
#instantiate forever
self.servicelist = self.session.instantiateDialog(ChannelSelection)
- if config.misc.initialchannelselection.value == 1:
+ if config.misc.initialchannelselection.value:
self.onShown.append(self.firstRun)
self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
{
- "switchChannelUp": self.switchChannelUp,
- "switchChannelDown": self.switchChannelDown,
+ "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
+ "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
"zapUp": (self.zapUp, _("previous channel")),
"zapDown": (self.zapDown, _("next channel")),
"historyBack": (self.historyBack, _("previous channel in history")),
"historyNext": (self.historyNext, _("next channel in history")),
- "openServiceList": (self.openServiceList, _("open service list")),
+ "openServiceList": (self.openServiceList, _("open servicelist")),
})
def showTvChannelList(self, zap=False):
def firstRun(self):
self.onShown.remove(self.firstRun)
- config.misc.initialchannelselection.value = 0
+ config.misc.initialchannelselection.value = False
config.misc.initialchannelselection.save()
self.switchChannelDown()
self.session.execDialog(self.servicelist)
def zapUp(self):
- if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes":
- if self.servicelist.inBouquet() and self.servicelist.atBegin():
- self.servicelist.prevBouquet()
- self.servicelist.moveUp()
+ if self.servicelist.inBouquet():
+ prev = self.servicelist.getCurrentSelection()
+ if prev:
+ prev = prev.toString()
+ while True:
+ if config.usage.quickzap_bouquet_change.value:
+ if self.servicelist.atBegin():
+ self.servicelist.prevBouquet()
+ self.servicelist.moveUp()
+ cur = self.servicelist.getCurrentSelection()
+ if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
+ break
+ else:
+ self.servicelist.moveUp()
self.servicelist.zap()
- self.doShow()
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
def zapDown(self):
- if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.inBouquet() and self.servicelist.atEnd():
- self.servicelist.nextBouquet()
+ if self.servicelist.inBouquet():
+ prev = self.servicelist.getCurrentSelection()
+ if prev:
+ prev = prev.toString()
+ while True:
+ if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
+ self.servicelist.nextBouquet()
+ else:
+ self.servicelist.moveDown()
+ cur = self.servicelist.getCurrentSelection()
+ if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
+ break
else:
self.servicelist.moveDown()
self.servicelist.zap()
- self.doShow()
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
class InfoBarMenu:
""" Handles a menu action, to open the (main) menu """
def __init__(self):
self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
{
- "mainMenu": (self.mainMenu, "Enter main menu..."),
+ "mainMenu": (self.mainMenu, _("Enter main menu...")),
})
+ self.session.infobar = None
def mainMenu(self):
print "loading mainmenu XML..."
menu = mdom.childNodes[0]
assert menu.tagName == "menu", "root element in menu must be 'menu'!"
- self.session.open(MainMenu, menu, menu.childNodes)
+
+ self.session.infobar = self
+ # so we can access the currently active infobar from screens opened from within the mainmenu
+ # at the moment used from the SubserviceSelection
+
+ self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu, menu.childNodes)
+
+ def mainMenuClosed(self, *val):
+ self.session.infobar = None
class InfoBarSimpleEventView:
""" Opens the Eventview for now/next """
service = servicelist.getNext()
if not service.valid(): #check if end of list
break
- if service.flags: #ignore non playable services
+ if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
continue
services.append(ServiceReference(service))
return services
class InfoBarTuner:
"""provides a snr/agc/ber display"""
def __init__(self):
- self["snr"] = Label()
- self["agc"] = Label()
- self["ber"] = Label()
- 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 updateTunerInfo(self):
- if self.instance.isVisible():
- self["snr_percent"].update()
- self["agc_percent"].update()
- self["ber_count"].update()
- self["snr_progress"].update()
- self["agc_progress"].update()
- self["ber_progress"].update()
+ self["FrontendStatus"] = FrontendStatus(service_source = self.session.nav.getCurrentService)
class InfoBarEvent:
"""provides a current/next event info display"""
def __init__(self):
- self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
- self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
-
- self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
- self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
-
- self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Remaining)
- self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
+ self["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW)
+ self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT)
- self["Now_ProgressBar"] = EventInfoProgress(self.session.nav, EventInfo.Now)
+class InfoBarRadioText:
+ """provides radio (RDS) text info display"""
+ def __init__(self):
+ self["RadioText"] = RadioText(self.session.nav)
class InfoBarServiceName:
def __init__(self):
- self["ServiceName"] = ServiceName(self.session.nav)
+ self["CurrentService"] = CurrentService(self.session.nav)
class InfoBarSeek:
"""handles actions like seeking, pause"""
self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions",
{
- "pauseService": (self.pauseService, "pause"),
- "unPauseService": (self.unPauseService, "continue"),
+ "playpauseService": (self.playpauseService, _("pause")),
+ "pauseService": (self.pauseService, _("pause")),
+ "unPauseService": (self.unPauseService, _("continue")),
- "seekFwd": (self.seekFwd, "skip forward"),
+ "seekFwd": (self.seekFwd, _("skip forward")),
"seekFwdDown": self.seekFwdDown,
"seekFwdUp": self.seekFwdUp,
- "seekBack": (self.seekBack, "skip backward"),
+ "seekBack": (self.seekBack, _("skip backward")),
"seekBackDown": self.seekBackDown,
"seekBackUp": self.seekBackUp,
}, prio=-1)
self.checkSkipShowHideLock()
return True
+
+ def playpauseService(self):
+ if self.seekstate != self.SEEK_STATE_PLAY:
+ self.unPauseService()
+ else:
+ self.pauseService()
def pauseService(self):
if self.seekstate == self.SEEK_STATE_PAUSE:
print "unpause"
if self.seekstate == self.SEEK_STATE_PLAY:
return 0
- self.setSeekState(self.SEEK_STATE_PLAY);
+ self.setSeekState(self.SEEK_STATE_PLAY)
def doSeek(self, seektime):
print "doseek", seektime
def checkSkipShowHideLock(self):
wantlock = self.seekstate != self.SEEK_STATE_PLAY
- if self.lockedBecauseOfSkipping and not wantlock:
- self.unlockShow()
- self.lockedBecauseOfSkipping = False
+ if config.usage.show_infobar_on_zap.value:
+ if self.lockedBecauseOfSkipping and not wantlock:
+ self.unlockShow()
+ self.lockedBecauseOfSkipping = False
- if wantlock and not self.lockedBecauseOfSkipping:
- self.lockShow()
- self.lockedBecauseOfSkipping = True
+ if wantlock and not self.lockedBecauseOfSkipping:
+ self.lockShow()
+ self.lockedBecauseOfSkipping = True
def __evEOF(self):
if self.seekstate != self.SEEK_STATE_PLAY:
if seekable is not None:
seekable.seekRelative(1, diff)
+ def seekAbsolute(self, abs):
+ seekable = self.getSeek()
+ if seekable is not None:
+ seekable.seekTo(abs)
+
from Screens.PVRState import PVRState, TimeshiftState
class InfoBarPVRState:
def __init__(self, screen=PVRState):
self.onPlayStateChanged.append(self.__playStateChanged)
self.pvrStateDialog = self.session.instantiateDialog(screen)
- self.onShow.append(self.__mayShow)
+ self.onShow.append(self._mayShow)
self.onHide.append(self.pvrStateDialog.hide)
-
- def __mayShow(self):
- if self.seekstate != self.SEEK_STATE_PLAY and self.execing:
+
+ def _mayShow(self):
+ if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
self.pvrStateDialog.show()
def __playStateChanged(self, state):
playstateString = state[3]
self.pvrStateDialog["state"].setText(playstateString)
- self.__mayShow()
+ self._mayShow()
class InfoBarTimeshiftState(InfoBarPVRState):
def __init__(self):
InfoBarPVRState.__init__(self, screen=TimeshiftState)
+ def _mayShow(self):
+ if self.execing and self.timeshift_enabled:
+ self.pvrStateDialog.show()
class InfoBarShowMovies:
def __init__(self):
self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
{
- "timeshiftStart": (self.startTimeshift, "start timeshift"), # the "yellow key"
- "timeshiftStop": (self.stopTimeshift, "stop timeshift") # currently undefined :), probably 'TV'
+ "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
+ "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
}, prio=1)
self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
{
if ts is None:
self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
print "no ts interface"
- return
+ return 0;
if self.timeshift_enabled:
print "hu, timeshift already enabled?"
else:
if not ts.startTimeshift():
- import time
self.timeshift_enabled = 1
- self.pvrStateDialog["timeshift"].setRelative(time.time())
-
+
+ # we remove the "relative time" for now.
+ #self.pvrStateDialog["timeshift"].setRelative(time.time())
+
# PAUSE.
self.setSeekState(self.SEEK_STATE_PAUSE)
def stopTimeshift(self):
if not self.timeshift_enabled:
- return
+ return 0
print "disable timeshift"
ts = self.getTimeshift()
if ts is None:
- return
+ return 0
self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
def stopTimeshiftConfirmed(self, confirmed):
from Screens.PiPSetup import PiPSetup
class InfoBarExtensions:
+ EXTENSION_SINGLE = 0
+ EXTENSION_LIST = 1
+
def __init__(self):
- self.pipshown = False
+ self.list = []
self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
{
- "extensions": (self.extensions, "Extensions..."),
+ "extensions": (self.showExtensionSelection, _("view extensions...")),
})
- PIPON = 0
- PIPOFF = 1
- MOVEPIP = 2
- PIPSWAP = 3
- ENABLE_SUBTITLE = 4
+ def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
+ self.list.append((type, extension, key))
+
+ def updateExtension(self, extension, key = None):
+ self.extensionsList.append(extension)
+ if key is not None:
+ if self.extensionKeys.has_key(key):
+ key = None
+
+ if key is None:
+ for x in self.availableKeys:
+ if not self.extensionKeys.has_key(x):
+ key = x
+ break
+
+ if key is not None:
+ self.extensionKeys[key] = len(self.extensionsList) - 1
+
+ def updateExtensions(self):
+ self.extensionsList = []
+ self.availableKeys = [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red", "green", "yellow", "blue" ]
+ self.extensionKeys = {}
+ for x in self.list:
+ if x[0] == self.EXTENSION_SINGLE:
+ self.updateExtension(x[1], x[2])
+ else:
+ for y in x[1]():
+ self.updateExtension(y[0], y[1])
- def extensions(self):
+
+ def showExtensionSelection(self):
+ self.updateExtensions()
+ extensionsList = self.extensionsList[:]
+ keys = []
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))
+ for x in self.availableKeys:
+ if self.extensionKeys.has_key(x):
+ entry = self.extensionKeys[x]
+ extension = self.extensionsList[entry]
+ if extension[2]():
+ name = str(extension[0]())
+ list.append((extension[0](), extension))
+ keys.append(x)
+ extensionsList.remove(extension)
+ else:
+ extensionsList.remove(extension)
+ for x in extensionsList:
+ list.append((x[0](), x))
+ keys += [""] * len(extensionsList)
+ self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
+
+ def extensionCallback(self, answer):
+ if answer is not None:
+ answer[1][1]()
+
+from Tools.BoundFunction import boundFunction
+
+# depends on InfoBarExtensions
+from Components.PluginComponent import plugins
+
+class InfoBarPlugins:
+ def __init__(self):
+ self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
- s = self.getCurrentServiceSubtitle()
- l = s and s.getSubtitleList() or [ ]
+ def getPluginName(self, name):
+ return name
- for x in l:
- list.append(("DEBUG: Enable Subtitles: " + x[0], self.ENABLE_SUBTITLE, x[1]))
+ def getPluginList(self):
+ list = []
+ for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
+ list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
+ return list
+
+ def runPlugin(self, plugin):
+ plugin(session = self.session)
+
+# depends on InfoBarExtensions
+class InfoBarSleepTimer:
+ def __init__(self):
+ self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
- self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list)
+ def available(self):
+ return True
- 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
+ def getSleepTimerName(self):
+ return _("Sleep Timer")
+
+ def showSleepTimerSetup(self):
+ self.session.open(SleepTimerEdit)
+
+# depends on InfoBarExtensions
+class InfoBarPiP:
+ def __init__(self):
+ self.session.pipshown = False
+
+ self.addExtension((self.getShowHideName, self.showPiP, self.available), "blue")
+ self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
+ self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
+
+ def available(self):
+ return True
+
+ def pipShown(self):
+ return self.session.pipshown
+
+ def getShowHideName(self):
+ if self.session.pipshown:
+ return _("Disable Picture in Picture")
+ else:
+ return _("Activate Picture in Picture")
+
+ def getSwapName(self):
+ return _("Swap Services")
+
+ def getMoveName(self):
+ return _("Move Picture in Picture")
+
+ def showPiP(self):
+ if self.session.pipshown:
+ del self.session.pip
+ self.session.pipshown = False
+ else:
+ self.session.pip = self.session.instantiateDialog(PictureInPicture)
+ newservice = self.session.nav.getCurrentlyPlayingServiceReference()
+ if self.session.pip.playService(newservice):
+ self.session.pipshown = True
+ self.session.pip.servicePath = self.servicelist.getCurrentServicePath()
+ else:
+ self.session.pipshown = False
+ del self.session.pip
+ self.session.nav.playService(newservice)
+
+ def swapPiP(self):
+ swapservice = self.session.nav.getCurrentlyPlayingServiceReference()
+ if self.session.pip.servicePath:
+ servicepath = self.servicelist.getCurrentServicePath()
+ ref=servicepath[len(servicepath)-1]
+ pipref=self.session.pip.getCurrentService()
+ self.session.pip.playService(swapservice)
+ self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
+ if pipref.toString() != ref.toString(): # is a subservice ?
+ self.session.nav.stopService() # stop portal
+ self.session.nav.playService(pipref) # start subservice
+ self.session.pip.servicePath=servicepath
+
+ def movePiP(self):
+ self.session.open(PiPSetup, pip = self.session.pip)
from RecordTimer import parseEvent
def __init__(self):
self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
{
- "instantRecord": (self.instantRecord, "Instant Record..."),
+ "instantRecord": (self.instantRecord, _("Instant Record...")),
})
self.recording = []
self["BlinkingPoint"] = BlinkingPixmapConditional()
if entry is not None and entry != -1:
self.session.nav.RecordTimer.removeEntry(self.recording[entry])
self.recording.remove(self.recording[entry])
-
+
def startInstantRecording(self, limitEvent = False):
serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
except:
pass
- begin = time.time()
- end = time.time() + 3600 * 10
+ begin = time()
+ end = time() + 3600 * 10
name = "instant record"
description = ""
eventid = None
def inputCallback(self, value):
if value is not None:
print "stopping recording after", int(value), "minutes."
- self.recording[self.selectedEntry].end = time.time() + 60 * int(value)
+ self.recording[self.selectedEntry].end = time() + 60 * int(value)
self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
def instantRecord(self):
try:
- stat = os.stat(resolveFilename(SCOPE_HDD))
+ stat = os_stat(resolveFilename(SCOPE_HDD))
except:
self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
return
-
+
if self.isInstantRecordRunning():
- self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("A recording is currently running.\nWhat do you want to do?"), list=[(_("stop recording"), "stop"), (_("change recording (duration)"), "changeduration"), (_("add recording (indefinitely)"), "indefinitely"), (_("add recording (stop after current event)"), "event"), (_("add recording (enter recording duration)"), "manualduration"), (_("do nothing"), "no")])
+ self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, \
+ title=_("A recording is currently running.\nWhat do you want to do?"), \
+ list=[(_("stop recording"), "stop"), \
+ (_("change recording (duration)"), "changeduration"), \
+ (_("add recording (indefinitely)"), "indefinitely"), \
+ (_("add recording (stop after current event)"), "event"), \
+ (_("add recording (enter recording duration)"), "manualduration"), \
+ (_("do nothing"), "no")])
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")])
+ 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 Tools.ISO639 import LanguageCodes
def __init__(self):
self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
{
- "audioSelection": (self.audioSelection, "Audio Options..."),
+ "audioSelection": (self.audioSelection, _("Audio Options...")),
})
def audioSelection(self):
service = self.session.nav.getCurrentService()
- audio = service.audioTracks()
+ audio = service and service.audioTracks()
self.audioTracks = audio
- n = audio.getNumberOfTracks()
+ n = audio and audio.getNumberOfTracks() or 0
keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
tlist = []
print "tlist:", tlist
language = i.getLanguage()
description = i.getDescription()
- if len(language) == 3:
- if language in LanguageCodes:
- language = LanguageCodes[language][0]
+ if LanguageCodes.has_key(language):
+ language = LanguageCodes[language][0]
if len(description):
description += " (" + language + ")"
self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
+ self.bsel = None
+
def checkSubservicesAvail(self, ev):
if ev == iPlayableService.evUpdatedEventInfo:
service = self.session.nav.getCurrentService()
if newservice.valid():
del subservices
del service
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
self.session.nav.playService(newservice)
def subserviceSelection(self):
service = self.session.nav.getCurrentService()
subservices = service and service.subServices()
-
+ self.bouquets = self.servicelist.getBouquetList()
n = subservices and subservices.getNumberOfSubservices()
selection = 0
if n and n > 0:
selection = x
tlist.append((i.getName(), i))
- self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection)
+ if self.bouquets and len(self.bouquets):
+ keys = ["red", "green", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+ if config.usage.multibouquet.value:
+ tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to bouquet"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
+ else:
+ tlist = [(_("Quickzap"), "quickzap", service.subServices()), (_("Add to favourites"), "CALLFUNC", self.addSubserviceToBouquetCallback), ("--", "")] + tlist
+ selection += 3
+ else:
+ tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
+ keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+ selection += 2
+
+ self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys)
def subserviceSelected(self, service):
+ del self.bouquets
if not service is None:
- self["SubserviceQuickzapAction"].setEnabled(True)
- self.session.nav.playService(service[1])
+ if isinstance(service[1], str):
+ if service[1] == "quickzap":
+ from Screens.SubservicesQuickzap import SubservicesQuickzap
+ self.session.open(SubservicesQuickzap, service[2])
+ else:
+ self["SubserviceQuickzapAction"].setEnabled(True)
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
+ self.session.nav.playService(service[1])
+
+ def addSubserviceToBouquetCallback(self, service):
+ if len(service) > 1 and isinstance(service[1], eServiceReference):
+ self.selectedSubservice = service
+ if self.bouquets is None:
+ cnt = 0
+ else:
+ cnt = len(self.bouquets)
+ if cnt > 1: # show bouquet list
+ self.bsel = self.session.openWithCallback(self.bouquetSelClosed, BouquetSelector, self.bouquets, self.addSubserviceToBouquet)
+ elif cnt == 1: # add to only one existing bouquet
+ self.addSubserviceToBouquet(self.bouquets[0][1])
+ self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
+
+ def bouquetSelClosed(self, confirmed):
+ self.bsel = None
+ del self.selectedSubservice
+ if confirmed:
+ self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
+
+ def addSubserviceToBouquet(self, dest):
+ self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
+ if self.bsel:
+ self.bsel.close(True)
+ else:
+ del self.selectedSubservice
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()
+ self["NimA"] = Pixmap()
+ self["NimB"] = Pixmap()
+ self["NimA_Active"] = Pixmap()
+ self["NimB_Active"] = Pixmap()
- def showSubServiceIndication(self):
- self["ButtonGreen"].show()
- self["ButtonGreenText"].show()
+ self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
+ self["TimeshiftPossible"] = self["RecordingPossible"]
+ self["ExtensionsAvailable"] = Boolean(fixed=1)
- 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()
+ self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
+ res_mgr = eDVBResourceManager.getInstance()
+ if res_mgr:
+ res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged)
- def checkSubservices(self, service):
- if service.subServices().getNumberOfSubservices() > 0:
- self.showSubServiceIndication()
+ def tunerUseMaskChanged(self, mask):
+ if mask&1:
+ self["NimA_Active"].show()
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()
+ self["NimA_Active"].hide()
+ if mask&2:
+ self["NimB_Active"].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()
+ self["NimB_Active"].hide()
+
+ def checkTunerState(self, service):
+ info = service and service.frontendInfo()
+ feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber)
+ if feNumber is None:
+ self["NimA"].hide()
+ self["NimB"].hide()
+ elif feNumber == 0:
+ self["NimB"].hide()
+ self["NimA"].show()
+ elif feNumber == 1:
+ self["NimA"].hide()
+ self["NimB"].show()
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()
+ if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd:
+ self.checkTunerState(service)
class InfoBarNotifications:
def __init__(self):
def checkNotifications(self):
if len(Notifications.notifications):
n = Notifications.notifications[0]
+
Notifications.notifications = Notifications.notifications[1:]
cb = n[0]
+
+ if n[3].has_key("onSessionOpenCallback"):
+ n[3]["onSessionOpenCallback"]()
+ del n[3]["onSessionOpenCallback"]
+
if cb is not None:
- self.session.openWithCallback(cb, n[1], *n[2], **n[3])
+ dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
else:
- self.session.open(n[1], *n[2], **n[3])
+ dlg = self.session.open(n[1], *n[2], **n[3])
+
+ # remember that this notification is currently active
+ d = (n[4], dlg)
+ Notifications.current_notifications.append(d)
+ dlg.onClose.append(boundFunction(self.__notificationClosed, d))
+
+ def __notificationClosed(self, d):
+ Notifications.current_notifications.remove(d)
class InfoBarServiceNotifications:
def __init__(self):
CUT_TYPE_IN = 0
CUT_TYPE_OUT = 1
CUT_TYPE_MARK = 2
+ CUT_TYPE_LAST = 3
+
+ ENABLE_RESUME_SUPPORT = False
def __init__(self):
self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions",
}, prio=1)
self.cut_list = [ ]
+ self.is_closing = False
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evStart: self.__serviceStarted,
})
def __serviceStarted(self):
+ if self.is_closing:
+ return
print "new service started! trying to download cuts!"
self.downloadCuesheet()
+
+ if self.ENABLE_RESUME_SUPPORT:
+ last = None
+
+ for (pts, what) in self.cut_list:
+ if what == self.CUT_TYPE_LAST:
+ last = pts
+
+ if last is not None:
+ self.resume_point = last
+ Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
+
+ def playLastCB(self, answer):
+ if answer == True:
+ seekable = self.__getSeekable()
+ if seekable is not None:
+ seekable.seekTo(self.resume_point)
def __getSeekable(self):
service = self.session.nav.getCurrentService()
return None
def addMark(self, point):
- bisect.insort(self.cut_list, point)
+ insort(self.cut_list, point)
self.uploadCuesheet()
def removeMark(self, point):
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" />
+ <widget source="CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
+ <convert type="ClockToText">WithSeconds</convert>
+ </widget>
+ <widget source="CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
+ <convert type="ServiceName">Name</convert>
+ </widget>
</screen>"""
def __init__(self, session, parent):
Screen.__init__(self, session)
- self["CurrentService"] = ServiceName(self.session.nav)
- self["Clock"] = Clock()
+ self["CurrentService"] = CurrentService(self.session.nav)
+ self["CurrentTime"] = Clock()
class InfoBarSummarySupport:
def __init__(self):
if self.teletext_plugin is not None:
self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
{
- "startTeletext": (self.startTeletext, "View teletext...")
+ "startTeletext": (self.startTeletext, _("View teletext..."))
})
else:
print "no teletext plugin found!"
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
- iPlayableService.evStart: self.__serviceStarted,
+ iPlayableService.evEnd: self.__serviceStopped,
+ iPlayableService.evUpdatedInfo: self.__updatedInfo
})
+ self.cached_subtitle_checked = False
- def __serviceStarted(self):
- # reenable if it was enabled
- r = self.__subtitles_enabled
+ def __serviceStopped(self):
+ self.subtitle_window.hide()
self.__subtitles_enabled = False
- self.__selected_subtitle = None
- self.setSubtitlesEnable(r)
+ self.cached_subtitle_checked = False
+
+ def __updatedInfo(self):
+ if not self.cached_subtitle_checked:
+ subtitle = self.getCurrentServiceSubtitle()
+ self.cached_subtitle_checked = True
+ if subtitle:
+ self.__selected_subtitle = subtitle.getCachedSubtitle()
+ if self.__selected_subtitle:
+ subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
+ self.subtitle_window.show()
+ self.__subtitles_enabled = True
def getCurrentServiceSubtitle(self):
service = self.session.nav.getCurrentService()
def setSubtitlesEnable(self, enable=True):
subtitle = self.getCurrentServiceSubtitle()
- if enable and self.__selected_subtitle:
+ if enable and self.__selected_subtitle is not None:
if subtitle and not self.__subtitles_enabled:
subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
self.subtitle_window.show()
else:
if subtitle:
subtitle.disableSubtitles(self.subtitle_window.instance)
-
- self.subtitle_window.hide()
self.__subtitles_enabled = False
+ self.subtitle_window.hide()
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
+ self.__selected_subtitle = subtitle
subtitles_enabled = property(lambda self: self.__subtitles_enabled, setSubtitlesEnable)
selected_subtitle = property(lambda self: self.__selected_subtitle, setSelectedSubtitle)
+
+class InfoBarServiceErrorPopupSupport:
+ def __init__(self):
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evTuneFailed: self.__tuneFailed,
+ iPlayableService.evStart: self.__serviceStarted
+ })
+ self.__serviceStarted()
+
+ def __serviceStarted(self):
+ self.last_error = None
+ Notifications.RemovePopup(id = "ZapError")
+
+ def __tuneFailed(self):
+ service = self.session.nav.getCurrentService()
+ info = service and service.info()
+ error = info and info.getInfo(iServiceInformation.sDVBState)
+
+ if error == self.last_error:
+ error = None
+ else:
+ self.last_error = error
+
+ errors = {
+ eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
+ eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
+ eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
+ eDVBServicePMTHandler.eventNoPATEntry: _("Service not found!\n(SID not found in PAT)"),
+ eDVBServicePMTHandler.eventNoPMT: _("Service invalid!\n(Timeout reading PMT)"),
+ eDVBServicePMTHandler.eventNewProgramInfo: None,
+ eDVBServicePMTHandler.eventTuned: None,
+ eDVBServicePMTHandler.eventSOF: None,
+ eDVBServicePMTHandler.eventEOF: None
+ }
+
+ error = errors.get(error) #this returns None when the key not exist in the dict
+
+ if error is not None:
+ Notifications.AddPopup(text = error, type = MessageBox.TYPE_ERROR, timeout = 5, id = "ZapError")
+ else:
+ Notifications.RemovePopup(id = "ZapError")
projects / vuplus_dvbapp / blobdiff