from Components.ActionMap import ActionMap, HelpableActionMap
from Components.ActionMap import NumberActionMap
-from Components.BlinkingPixmap import BlinkingPixmapConditional
from Components.Harddisk import harddiskmanager
from Components.Input import Input
from Components.Label import Label
-from Components.Pixmap import Pixmap
from Components.PluginComponent import plugins
from Components.ServiceEventTracker import ServiceEventTracker
-from Components.Sources.Source import ObsoleteSource
from Components.Sources.Boolean import Boolean
from Components.config import config, ConfigBoolean, ConfigClock
from Components.SystemInfo import SystemInfo
from Screens.PictureInPicture import PictureInPicture
from Screens.SubtitleDisplay import SubtitleDisplay
from Screens.RdsDisplay import RdsInfoDisplay, RassInteractive
-from Screens.SleepTimerEdit import SleepTimerEdit
from Screens.TimeDateInput import TimeDateInput
from ServiceReference import ServiceReference
from Tools import Notifications
-from Tools.Directories import SCOPE_HDD, resolveFilename
+from Tools.Directories import SCOPE_HDD, resolveFilename, fileExists
from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
- iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
+ iPlayableService, eServiceReference, eEPGCache
from time import time, localtime, strftime
from os import stat as os_stat
from bisect import insort
+from RecordTimer import RecordTimerEntry, RecordTimer
+
# hack alert!
from Menu import MainMenu, mdom
def mainMenu(self):
print "loading mainmenu XML..."
- menu = mdom.childNodes[0]
- assert menu.tagName == "menu", "root element in menu must be 'menu'!"
+ menu = mdom.getroot()
+ assert menu.tag == "menu", "root element in menu must be 'menu'!"
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)
+ self.session.openWithCallback(self.mainMenuClosed, MainMenu, menu)
def mainMenuClosed(self, *val):
self.session.infobar = None
self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
"showEventInfo": (self.openEventView, _("show event details")),
+ "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
})
+ def showEventInfoWhenNotVisible(self):
+ if self.shown:
+ self.openEventView()
+ else:
+ self.toggleShow()
+ return 1
+
def openEventView(self):
- self.epglist = [ ]
+ epglist = [ ]
+ self.epglist = epglist
service = self.session.nav.getCurrentService()
ref = self.session.nav.getCurrentlyPlayingServiceReference()
info = service.info()
ptr=info.getEvent(0)
if ptr:
- self.epglist.append(ptr)
+ epglist.append(ptr)
ptr=info.getEvent(1)
if ptr:
- self.epglist.append(ptr)
- if len(self.epglist) > 0:
- self.session.open(EventViewSimple, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
+ epglist.append(ptr)
+ if epglist:
+ self.session.open(EventViewSimple, epglist[0], ServiceReference(ref), self.eventViewCallback)
def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
- if len(self.epglist) > 1:
- tmp = self.epglist[0]
- self.epglist[0]=self.epglist[1]
- self.epglist[1]=tmp
- setEvent(self.epglist[0])
+ epglist = self.epglist
+ if len(epglist) > 1:
+ tmp = epglist[0]
+ epglist[0] = epglist[1]
+ epglist[1] = tmp
+ setEvent(epglist[0])
+
+class SimpleServicelist:
+ def __init__(self, services):
+ self.services = services
+ self.length = len(services)
+ self.current = 0
+
+ def selectService(self, service):
+ if not self.length:
+ self.current = -1
+ return False
+ else:
+ self.current = 0
+ while self.services[self.current].ref != service:
+ self.current += 1
+ if self.current >= self.length:
+ return False
+ return True
+
+ def nextService(self):
+ if not self.length:
+ return
+ if self.current+1 < self.length:
+ self.current += 1
+ else:
+ self.current = 0
+
+ def prevService(self):
+ if not self.length:
+ return
+ if self.current-1 > -1:
+ self.current -= 1
+ else:
+ self.current = self.length - 1
+
+ def currentService(self):
+ if not self.length or self.current >= self.length:
+ return None
+ return self.services[self.current]
class InfoBarEPG:
""" EPG - Opens an EPG list when the showEPGList action fires """
self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
"showEventInfo": (self.openEventView, _("show EPG...")),
- "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
+ "showEventInfoPlugin": (self.showEventInfoPlugins, _("show single service EPG...")),
"showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
})
def openBouquetEPG(self, bouquet, withCallback=True):
services = self.getBouquetServices(bouquet)
- if len(services):
+ if services:
self.epg_bouquet = bouquet
if withCallback:
self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
self.bouquetSel.up()
bouquet = self.bouquetSel.getCurrent()
services = self.getBouquetServices(bouquet)
- if len(services):
+ if services:
self.epg_bouquet = bouquet
epg.setServices(services)
elif cnt == 1:
self.openBouquetEPG(bouquets[0][1], withCallback)
+ def changeServiceCB(self, direction, epg):
+ if self.serviceSel:
+ if direction > 0:
+ self.serviceSel.nextService()
+ else:
+ self.serviceSel.prevService()
+ epg.setService(self.serviceSel.currentService())
+
+ def SingleServiceEPGClosed(self, ret=False):
+ self.serviceSel = None
+
def openSingleServiceEPG(self):
ref=self.session.nav.getCurrentlyPlayingServiceReference()
- self.session.open(EPGSelection, ref)
+ if ref:
+ if self.servicelist.getMutableList() is not None: # bouquet in channellist
+ current_path = self.servicelist.getRoot()
+ services = self.getBouquetServices(current_path)
+ self.serviceSel = SimpleServicelist(services)
+ if self.serviceSel.selectService(ref):
+ self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref, serviceChangeCB = self.changeServiceCB)
+ else:
+ self.session.openWithCallback(self.SingleServiceEPGClosed, EPGSelection, ref)
+ else:
+ self.session.open(EPGSelection, ref)
+
+ def showEventInfoPlugins(self):
+ list = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO)]
+
+ if list:
+ list.append((_("show single service EPG..."), self.openSingleServiceEPG))
+ self.session.openWithCallback(self.EventInfoPluginChosen, ChoiceBox, title=_("Please choose an extension..."), list = list, skin_name = "EPGExtensionsList")
+ else:
+ self.openSingleServiceEPG()
+
+ def runPlugin(self, plugin):
+ plugin(session = self.session, servicelist = self.servicelist)
+
+ def EventInfoPluginChosen(self, answer):
+ if answer is not None:
+ answer[1]()
def openSimilarList(self, eventid, refstr):
self.session.open(EPGSelection, refstr, None, eventid)
def getNowNext(self):
- self.epglist = [ ]
+ epglist = [ ]
service = self.session.nav.getCurrentService()
info = service and service.info()
ptr = info and info.getEvent(0)
if ptr:
- self.epglist.append(ptr)
+ epglist.append(ptr)
ptr = info and info.getEvent(1)
if ptr:
- self.epglist.append(ptr)
+ epglist.append(ptr)
+ self.epglist = epglist
def __evEventInfoChanged(self):
if self.is_now_next and len(self.dlg_stack) == 1:
self.getNowNext()
assert self.eventView
- if len(self.epglist):
+ if self.epglist:
self.eventView.setEvent(self.epglist[0])
def openEventView(self):
ref = self.session.nav.getCurrentlyPlayingServiceReference()
self.getNowNext()
- if len(self.epglist) == 0:
+ epglist = self.epglist
+ if not epglist:
self.is_now_next = False
epg = eEPGCache.getInstance()
ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
if ptr:
- self.epglist.append(ptr)
+ epglist.append(ptr)
ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
if ptr:
- self.epglist.append(ptr)
+ epglist.append(ptr)
else:
self.is_now_next = True
- if len(self.epglist) > 0:
+ if epglist:
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:
self.openMultiServiceEPG(False)
def eventViewCallback(self, setEvent, setService, val): #used for now/next displaying
- if len(self.epglist) > 1:
- tmp = self.epglist[0]
- self.epglist[0]=self.epglist[1]
- self.epglist[1]=tmp
- setEvent(self.epglist[0])
-
-class InfoBarTuner:
- """provides a snr/agc/ber display"""
- def __init__(self):
- self["FrontendStatus"] = ObsoleteSource(new_source = "session.FrontendStatus", removal_date = "2008-01")
-
-class InfoBarEvent:
- """provides a current/next event info display"""
- def __init__(self):
- self["Event_Now"] = ObsoleteSource(new_source = "session.Event_Now", removal_date = "2008-01")
- self["Event_Next"] = ObsoleteSource(new_source = "session.Event_Next", removal_date = "2008-01")
+ epglist = self.epglist
+ if len(epglist) > 1:
+ tmp = epglist[0]
+ epglist[0]=epglist[1]
+ epglist[1]=tmp
+ setEvent(epglist[0])
class InfoBarRdsDecoder:
"""provides RDS and Rass support/display"""
self.RassSlidePicChanged()
self.rds_display.show()
-class InfoBarServiceName:
- def __init__(self):
- self["CurrentService"] = ObsoleteSource(new_source = "session.CurrentService", removal_date = "2008-01")
-
class InfoBarSeek:
"""handles actions like seeking, pause"""
SEEK_STATE_PAUSE = (1, 0, 0, "||")
SEEK_STATE_EOF = (1, 0, 0, "END")
- def __init__(self, actionmap = "InfobarSeekActions"):
+ def __init__(self, actionmap = "InfobarSeekActions", useSeekBackHack=True):
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
iPlayableService.evEOF: self.__evEOF,
iPlayableService.evSOF: self.__evSOF,
})
- self.eofState = 0
- self.eofTimer = eTimer()
- self.eofTimer.timeout.get().append(self.doEof)
- self.eofInhibitTimer = eTimer()
- self.eofInhibitTimer.timeout.get().append(self.inhibitEof)
-# self.minSpeedBackward = 16
+ self.minSpeedBackward = useSeekBackHack and 16 or 0
class InfoBarSeekActionMap(HelpableActionMap):
def __init__(self, screen, *args, **kwargs):
return 1
elif action[:8] == "seekdef:":
key = int(action[8:])
- time = [-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
+ time = (-config.seek.selfdefined_13.value, False, config.seek.selfdefined_13.value,
-config.seek.selfdefined_46.value, False, config.seek.selfdefined_46.value,
- -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value][key-1]
+ -config.seek.selfdefined_79.value, False, config.seek.selfdefined_79.value)[key-1]
self.screen.doSeekRelative(time * 90000)
return 1
else:
def makeStateBackward(self, n):
minspeed = config.seek.stepwise_minspeed.value
repeat = int(config.seek.stepwise_repeat.value)
-# if n < self.minSpeedBackward:
-# r = (self.minSpeedBackward - 1)/ n + 1
-# if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
-# r = max(r, repeat)
-# return (0, -n * r, r, "<< %dx" % n)
-# el
- if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
+ if self.minSpeedBackward and n < self.minSpeedBackward:
+ r = (self.minSpeedBackward - 1)/ n + 1
+ if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
+ r = max(r, repeat)
+ return (0, -n * r, r, "<< %dx" % n)
+ elif minspeed != "Never" and n >= int(minspeed) and repeat > 1:
return (0, -n * repeat, repeat, "<< %dx" % n)
else:
return (0, -n, 0, "<< %dx" % n)
return False
def getLower(self, n, lst):
- lst = lst+[]
+ lst = lst[:]
lst.reverse()
for x in lst:
if x < n:
return True
def __seekableStatusChanged(self):
- print "seekable status changed!"
+# print "seekable status changed!"
if not self.isSeekable():
self["SeekActions"].setEnabled(False)
- print "not seekable, return to play"
+# print "not seekable, return to play"
self.setSeekState(self.SEEK_STATE_PLAY)
else:
self["SeekActions"].setEnabled(True)
- print "seekable"
+# print "seekable"
def __serviceStarted(self):
self.seekstate = self.SEEK_STATE_PLAY
self.__seekableStatusChanged()
- if self.eofState != 0:
- self.eofTimer.stop()
- self.eofState = 0
def setSeekState(self, state):
service = self.session.nav.getCurrentService()
return False
if not self.isSeekable():
- if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
+ if state not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE):
state = self.SEEK_STATE_PLAY
pauseable = service.pause()
print "not pauseable."
state = self.SEEK_STATE_PLAY
- oldstate = self.seekstate
self.seekstate = state
- for i in range(3):
- if oldstate[i] != self.seekstate[i]:
- (self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
+ if pauseable is not None:
+ if self.seekstate[0]:
+ print "resolved to PAUSE"
+ pauseable.pause()
+ elif self.seekstate[1]:
+ print "resolved to FAST FORWARD"
+ pauseable.setFastForward(self.seekstate[1])
+ elif self.seekstate[2]:
+ print "resolved to SLOW MOTION"
+ pauseable.setSlowMotion(self.seekstate[2])
+ else:
+ print "resolved to PLAY"
+ pauseable.unpause()
for c in self.onPlayStateChanged:
c(self.seekstate)
seekable = self.getSeek()
if seekable is None:
return
- prevstate = self.seekstate
- if self.eofState == 1:
- self.eofState = 2
- self.inhibitEof()
- if self.seekstate == self.SEEK_STATE_EOF:
- if prevstate == self.SEEK_STATE_PAUSE:
- self.setSeekState(self.SEEK_STATE_PAUSE)
- else:
- self.setSeekState(self.SEEK_STATE_PLAY)
- self.eofInhibitTimer.start(200, True)
seekable.seekTo(pts)
def doSeekRelative(self, pts):
if seekable is None:
return
prevstate = self.seekstate
- if self.eofState == 1:
- self.eofState = 2
- self.inhibitEof()
+
if self.seekstate == self.SEEK_STATE_EOF:
if prevstate == self.SEEK_STATE_PAUSE:
self.setSeekState(self.SEEK_STATE_PAUSE)
else:
self.setSeekState(self.SEEK_STATE_PLAY)
- self.eofInhibitTimer.start(200, True)
seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
self.showAfterSeek()
self.setSeekState(self.makeStateSlowMotion(speed))
def seekBack(self):
- if self.seekstate == self.SEEK_STATE_PLAY:
+ seekstate = self.seekstate
+ if seekstate == self.SEEK_STATE_PLAY:
self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
- elif self.seekstate == self.SEEK_STATE_EOF:
+ elif seekstate == self.SEEK_STATE_EOF:
self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
self.doSeekRelative(-6)
- elif self.seekstate == self.SEEK_STATE_PAUSE:
+ elif seekstate == self.SEEK_STATE_PAUSE:
self.doSeekRelative(-3)
- elif self.isStateForward(self.seekstate):
- speed = self.seekstate[1]
- if self.seekstate[2]:
- speed /= self.seekstate[2]
+ elif self.isStateForward(seekstate):
+ speed = seekstate[1]
+ if seekstate[2]:
+ speed /= seekstate[2]
speed = self.getLower(speed, config.seek.speeds_forward.value)
if speed:
self.setSeekState(self.makeStateForward(speed))
else:
self.setSeekState(self.SEEK_STATE_PLAY)
- elif self.isStateBackward(self.seekstate):
- speed = -self.seekstate[1]
- if self.seekstate[2]:
- speed /= self.seekstate[2]
+ elif self.isStateBackward(seekstate):
+ speed = -seekstate[1]
+ if seekstate[2]:
+ speed /= seekstate[2]
speed = self.getHigher(speed, config.seek.speeds_backward.value) or config.seek.speeds_backward.value[-1]
self.setSeekState(self.makeStateBackward(speed))
- elif self.isStateSlowMotion(self.seekstate):
- speed = self.getHigher(self.seekstate[2], config.seek.speeds_slowmotion.value)
+ elif self.isStateSlowMotion(seekstate):
+ speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
if speed:
self.setSeekState(self.makeStateSlowMotion(speed))
else:
return False
def __evEOF(self):
- if self.eofState == 0 and self.seekstate != self.SEEK_STATE_EOF:
- self.eofState = 1
- time = self.calcRemainingTime()
- if not time:
- time = 3000 # Failed to calc, use default
- elif time == 0:
- time = 300 # Passed end, shortest wait
- elif time > 15000:
- self.eofState = -2 # Too long, block eof
- time = 15000
- else:
- time += 1000 # Add margin
- self.eofTimer.start(time, True)
-
- def inhibitEof(self):
- if self.eofState >= 1:
- self.eofState = -self.eofState
- self.eofTimer.stop()
- self.doEof()
-
- def doEof(self):
if self.seekstate == self.SEEK_STATE_EOF:
return
- if self.eofState == -2 or self.isStateBackward(self.seekstate):
- self.eofState = 0
- return
- # if we are seeking, we try to end up ~1s before the end, and pause there.
- eofstate = self.eofState
+ # if we are seeking forward, we try to end up ~1s before the end, and pause there.
seekstate = self.seekstate
- self.eofState = 0
- if not self.seekstate == self.SEEK_STATE_PAUSE:
+ if self.seekstate != self.SEEK_STATE_PAUSE:
self.setSeekState(self.SEEK_STATE_EOF)
- if eofstate == -1 or not seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
+
+ if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
seekable = self.getSeek()
if seekable is not None:
seekable.seekTo(-1)
- if eofstate == 1 and seekstate == self.SEEK_STATE_PLAY:
+ if seekstate == self.SEEK_STATE_PLAY: # regular EOF
self.doEofInternal(True)
else:
self.doEofInternal(False)
from Screens.PVRState import PVRState, TimeshiftState
class InfoBarPVRState:
- def __init__(self, screen=PVRState):
+ def __init__(self, screen=PVRState, force_show = False):
self.onPlayStateChanged.append(self.__playStateChanged)
self.pvrStateDialog = self.session.instantiateDialog(screen)
self.onShow.append(self._mayShow)
self.onHide.append(self.pvrStateDialog.hide)
+ self.force_show = force_show
def _mayShow(self):
if self.execing and self.seekstate != self.SEEK_STATE_PLAY:
def __playStateChanged(self, state):
playstateString = state[3]
self.pvrStateDialog["state"].setText(playstateString)
- self._mayShow()
+
+ # if we return into "PLAY" state, ensure that the dialog gets hidden if there will be no infobar displayed
+ if not config.usage.show_infobar_on_skip.value and self.seekstate == self.SEEK_STATE_PLAY and not self.force_show:
+ self.pvrStateDialog.hide()
+ else:
+ self._mayShow()
+
class InfoBarTimeshiftState(InfoBarPVRState):
def __init__(self):
- InfoBarPVRState.__init__(self, screen=TimeshiftState)
+ InfoBarPVRState.__init__(self, screen=TimeshiftState, force_show = True)
def _mayShow(self):
- if self.execing and self.timeshift_enabled:
+ if self.execing and self.timeshift_enabled and self.seekstate != self.SEEK_STATE_PLAY:
self.pvrStateDialog.show()
class InfoBarShowMovies:
def __seekableStatusChanged(self):
enabled = False
- print "self.isSeekable", self.isSeekable()
- print "self.timeshift_enabled", self.timeshift_enabled
+# print "self.isSeekable", self.isSeekable()
+# print "self.timeshift_enabled", self.timeshift_enabled
# when this service is not seekable, but timeshift
# is enabled, this means we can activate
if not self.isSeekable() and self.timeshift_enabled:
enabled = True
- print "timeshift activate:", enabled
+# print "timeshift activate:", enabled
self["TimeshiftActivateActions"].setEnabled(enabled)
def __serviceStarted(self):
self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
{
"extensions": (self.showExtensionSelection, _("view extensions...")),
- })
+ }, 1) # lower priority
def addExtension(self, extension, key = None, type = EXTENSION_SINGLE):
self.list.append((type, extension, key))
extensionsList.remove(extension)
else:
extensionsList.remove(extension)
- for x in extensionsList:
- list.append((x[0](), x))
+ list.extend([(x[0](), x) for x in extensionsList])
+
keys += [""] * len(extensionsList)
- self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
+ self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys, skin_name = "ExtensionsList")
def extensionCallback(self, answer):
if answer is not None:
from Tools.BoundFunction import boundFunction
# depends on InfoBarExtensions
-from Components.PluginComponent import plugins
class InfoBarPlugins:
def __init__(self):
return name
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))
+ list = [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None, p.name) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
+ list.sort(key = lambda e: e[2]) # sort by name
return list
def runPlugin(self, plugin):
- plugin(session = self.session, servicelist = self.servicelist)
+ if isinstance(self, InfoBarChannelSelection):
+ plugin(session = self.session, servicelist = self.servicelist)
+ else:
+ plugin(session = self.session)
-# depends on InfoBarExtensions
-class InfoBarSleepTimer:
+from Components.Task import job_manager
+class InfoBarJobman:
def __init__(self):
- self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
+ self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
- def available(self):
- return True
+ def getJobList(self):
+ return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
- def getSleepTimerName(self):
- return _("Sleep Timer")
+ def getJobName(self, job):
+ return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
- def showSleepTimerSetup(self):
- self.session.open(SleepTimerEdit)
+ def showJobView(self, job):
+ from Screens.TaskView import JobView
+ job_manager.in_background = False
+ self.session.openWithCallback(self.JobViewCB, JobView, job)
+
+ def JobViewCB(self, in_background):
+ job_manager.in_background = in_background
# depends on InfoBarExtensions
class InfoBarPiP:
def __init__(self):
- self.session.pipshown = False
+ try:
+ self.session.pipshown
+ except:
+ self.session.pipshown = False
if SystemInfo.get("NumVideoDecoders", 1) > 1:
- 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 SystemInfo.get("NumVideoDecoders", 1) > 1
+ if (self.allowPiP):
+ self.addExtension((self.getShowHideName, self.showPiP, lambda: True), "blue")
+ self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
+ self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "yellow")
+ else:
+ self.addExtension((self.getShowHideName, self.showPiP, self.pipShown), "blue")
+ self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "green")
def pipShown(self):
return self.session.pipshown
elif "stop" == use:
self.showPiP()
-from RecordTimer import parseEvent
+from RecordTimer import parseEvent, RecordTimerEntry
class InfoBarInstantRecord:
"""Instant Record - handles the instantRecord action in order to
"instantRecord": (self.instantRecord, _("Instant Record...")),
})
self.recording = []
-#### DEPRECATED CODE ####
- self["BlinkingPoint"] = BlinkingPixmapConditional()
- self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
- self["BlinkingPoint"].deprecationInfo = (
- "session.RecordState source, Pixmap renderer and "
- "ConditionalShowHide/Blink Converter", "2008-02")
-#########################
def stopCurrentRecording(self, entry = -1):
if entry is not None and entry != -1:
except:
pass
- begin = time()
- end = time() + 3600 * 10
+ begin = int(time())
+ end = begin + 3600 # dummy
name = "instant record"
description = ""
eventid = None
if limitEvent:
self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
- data = (begin, end, name, description, eventid)
+ if isinstance(serviceref, eServiceReference):
+ serviceref = ServiceReference(serviceref)
- recording = self.session.nav.recordWithTimer(serviceref, *data)
+ recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
recording.dontSave = True
- self.recording.append(recording)
-
-#### DEPRECATED CODE ####
- self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
-#########################
+
+ if event is None or limitEvent == False:
+ recording.autoincrease = True
+ if recording.setAutoincreaseEnd():
+ self.session.nav.RecordTimer.record(recording)
+ self.recording.append(recording)
+ else:
+ simulTimerList = self.session.nav.RecordTimer.record(recording)
+ if simulTimerList is not None: # conflict with other recording
+ name = simulTimerList[1].name
+ name_date = ' '.join((name, strftime('%c', localtime(simulTimerList[1].begin))))
+ print "[TIMER] conflicts with", name_date
+ recording.autoincrease = True # start with max available length, then increment
+ if recording.setAutoincreaseEnd():
+ self.session.nav.RecordTimer.record(recording)
+ self.recording.append(recording)
+ self.session.open(MessageBox, _("Record time limited due to conflicting timer %s") % name_date, MessageBox.TYPE_INFO)
+ else:
+ self.session.open(MessageBox, _("Couldn't record due to conflicting timer %s") % name, MessageBox.TYPE_INFO)
+ recording.autoincrease = False
+ else:
+ self.recording.append(recording)
def isInstantRecordRunning(self):
print "self.recording:", self.recording
- if len(self.recording) > 0:
+ if self.recording:
for x in self.recording:
if x.isRunning():
return True
print "after:\n", self.recording
def setEndtime(self, entry):
- if entry is not None:
+ if entry is not None and entry >= 0:
self.selectedEntry = entry
self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
if ret[0]:
localendtime = localtime(ret[1])
print "stopping recording at", strftime("%c", localendtime)
+ if self.recording[self.selectedEntry].end != ret[1]:
+ self.recording[self.selectedEntry].autoincrease = False
self.recording[self.selectedEntry].end = ret[1]
self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
def changeDuration(self, entry):
- if entry is not None:
+ if entry is not None and entry >= 0:
self.selectedEntry = entry
self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
def inputCallback(self, value):
if value is not None:
print "stopping recording after", int(value), "minutes."
- self.recording[self.selectedEntry].end = time() + 60 * int(value)
- self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
+ entry = self.recording[self.selectedEntry]
+ if int(value) != 0:
+ entry.autoincrease = False
+ entry.end = int(time()) + 60 * int(value)
+ self.session.nav.RecordTimer.timeChanged(entry)
def instantRecord(self):
+ dir = config.movielist.last_videodir.value
+ if not fileExists(dir, 'w'):
+ dir = resolveFilename(SCOPE_HDD)
try:
- stat = os_stat(resolveFilename(SCOPE_HDD))
+ stat = os_stat(dir)
except:
+ # XXX: this message is a little odd as we might be recording to a remote device
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"), \
- (_("change recording (endtime)"), "changeendtime"), \
- (_("add recording (indefinitely)"), "indefinitely"), \
+ list=((_("stop recording"), "stop"), \
(_("add recording (stop after current event)"), "event"), \
+ (_("add recording (indefinitely)"), "indefinitely"), \
(_("add recording (enter recording duration)"), "manualduration"), \
(_("add recording (enter recording endtime)"), "manualendtime"), \
- (_("do nothing"), "no")])
+ (_("change recording (duration)"), "changeduration"), \
+ (_("change recording (endtime)"), "changeendtime"), \
+ (_("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"), \
+ list=((_("add recording (stop after current event)"), "event"), \
+ (_("add recording (indefinitely)"), "indefinitely"), \
(_("add recording (enter recording duration)"), "manualduration"), \
(_("add recording (enter recording endtime)"), "manualendtime"), \
- (_("don't record"), "no")])
+ (_("don't record"), "no")))
from Tools.ISO639 import LanguageCodes
def audioSelection(self):
service = self.session.nav.getCurrentService()
- audio = service and service.audioTracks()
- self.audioTracks = audio
+ self.audioTracks = audio = service and service.audioTracks()
n = audio and audio.getNumberOfTracks() or 0
- keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
tlist = []
if n > 0:
self.audioChannel = service.audioChannel()
- for x in range(n):
- i = audio.getTrackInfo(x)
- language = i.getLanguage()
+ idx = 0
+ while idx < n:
+ cnt = 0
+ i = audio.getTrackInfo(idx)
+ languages = i.getLanguage().split('/')
description = i.getDescription()
+ language = ""
- if LanguageCodes.has_key(language):
- language = LanguageCodes[language][0]
+ for lang in languages:
+ if cnt:
+ language += ' / '
+ if LanguageCodes.has_key(lang):
+ language += LanguageCodes[lang][0]
+ else:
+ language += lang
+ cnt += 1
if len(description):
description += " (" + language + ")"
else:
description = language
- tlist.append((description, x))
+ tlist.append((description, idx))
+ idx += 1
- selectedAudio = audio.getCurrentTrack()
tlist.sort(key=lambda x: x[0])
- selection = 2
+ selectedAudio = self.audioTracks.getCurrentTrack()
+
+ selection = 0
+
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)
+ if SystemInfo["CanDownmixAC3"]:
+ tlist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
+ ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"),
+ ("--", "")] + tlist
+ keys = [ "red", "green", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+ selection += 3
+ else:
+ tlist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode"), ("--", "")] + tlist
+ keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+ selection += 2
+ self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = tlist, selection = selection, keys = keys, skin_name = "AudioTrackSelection")
else:
del self.audioTracks
+ def changeAC3Downmix(self, arg):
+ choicelist = self.session.current_dialog["list"]
+ list = choicelist.list
+ t = list[0][1]
+ list[0][1]=(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
+ _("AC3 downmix") + " - " + (_("On"), _("Off"))[config.av.downmix_ac3.value and 1 or 0])
+ choicelist.setList(list)
+ if config.av.downmix_ac3.value:
+ config.av.downmix_ac3.value = False
+ else:
+ config.av.downmix_ac3.value = True
+ config.av.downmix_ac3.save()
+
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)
+ tlist = ((_("left"), 0), (_("stereo"), 1), (_("right"), 2))
+ self.session.openWithCallback(self.modeSelected, ChoiceBox, title=_("Select audio mode"), list = tlist, selection = selection, keys = keys, skin_name ="AudioModeSelection")
else:
del self.audioChannel
if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
}, -1)
self["SubserviceQuickzapAction"].setEnabled(False)
- self.session.nav.event.append(self.checkSubservicesAvail) # we like to get service events
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evUpdatedEventInfo: self.checkSubservicesAvail
+ })
self.bsel = None
- 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 checkSubservicesAvail(self):
+ 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)
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
+ idx = 0
+ while idx < n:
+ if subservices.getSubservice(idx).toString() == ref.toString():
+ selection = idx
+ break
+ idx += 1
if selection != -1:
selection += direction
if selection >= n:
if newservice.valid():
del subservices
del service
- self.session.nav.playService(newservice)
+ self.session.nav.playService(newservice, False)
def subserviceSelection(self):
service = self.session.nav.getCurrentService()
if n and n > 0:
ref = self.session.nav.getCurrentlyPlayingServiceReference()
tlist = []
- for x in range(n):
- i = subservices.getSubservice(x)
+ idx = 0
+ while idx < n:
+ i = subservices.getSubservice(idx)
if i.toString() == ref.toString():
- selection = x
+ selection = idx
tlist.append((i.getName(), i))
+ idx += 1
if self.bouquets and len(self.bouquets):
- keys = ["red", "green", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+ keys = ["red", "blue", "", "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:
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)
+ self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice..."), list = tlist, selection = selection, keys = keys, skin_name = "SubserviceSelection")
def subserviceSelected(self, service):
del self.bouquets
self.session.open(SubservicesQuickzap, service[2])
else:
self["SubserviceQuickzapAction"].setEnabled(True)
- self.session.nav.playService(service[1])
+ self.session.nav.playService(service[1], False)
def addSubserviceToBouquetCallback(self, service):
if len(service) > 1 and isinstance(service[1], eServiceReference):
class InfoBarAdditionalInfo:
def __init__(self):
- self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
+ self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0 and config.misc.rcused.value == 1)
self["TimeshiftPossible"] = self["RecordingPossible"]
+ self["ShowTimeshiftOnYellow"] = Boolean(fixed=(not config.misc.rcused.value == 0))
+ self["ShowAudioOnYellow"] = Boolean(fixed=config.misc.rcused.value == 0)
+ self["ShowRecordOnRed"] = Boolean(fixed=config.misc.rcused.value == 1)
self["ExtensionsAvailable"] = Boolean(fixed=1)
-######### DEPRECATED CODE ##########
- self["NimA"] = Pixmap()
- self["NimA"].deprecationInfo = (
- "session.TunerInfo source, Pixmap renderer, TunerInfo/UseMask Converter"
- ", ValueBitTest(1) Converter and ConditionalShowHide Converter", "2008-02")
- self["NimB"] = Pixmap()
- self["NimB"].deprecationInfo = (
- "session.TunerInfo source, Pixmap renderer, TunerInfo/UseMask Converter"
- ", ValueBitTest(2) Converter and ConditionalShowHide Converter", "2008-02")
- self["NimA_Active"] = Pixmap()
- self["NimA_Active"].deprecationInfo = (
- "session.FrontendInfo source, Pixmap renderer, FrontendInfo/NUMBER Converter"
- ", ValueRange(1,1) Converter and ConditionalShowHide Converter", "2008-02")
- self["NimB_Active"] = Pixmap()
- self["NimB_Active"].deprecationInfo = (
- "session.FrontendInfo source, Pixmap renderer, FrontendInfo/NUMBER Converter"
- ", ValueRange(1,1) Converter and ConditionalShowHide Converter", "2008-02")
-
- res_mgr = eDVBResourceManager.getInstance()
- if res_mgr:
- res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged)
-
- self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
-
- def tunerUseMaskChanged(self, mask):
- if mask&1:
- self["NimA_Active"].show()
- else:
- self["NimA_Active"].hide()
- if mask&2:
- self["NimB_Active"].show()
- else:
- 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.evUpdatedInfo or ev == iPlayableService.evEnd:
- self.checkTunerState(service)
-####################################
-
class InfoBarNotifications:
def __init__(self):
self.onExecBegin.append(self.checkNotifications)
self.checkNotifications()
def checkNotifications(self):
- if len(Notifications.notifications):
- n = Notifications.notifications[0]
+ notifications = Notifications.notifications
+ if notifications:
+ n = notifications[0]
- Notifications.notifications = Notifications.notifications[1:]
+ del notifications[0]
cb = n[0]
if n[3].has_key("onSessionOpenCallback"):
if bestdiff >= 0:
nearest = [0, False]
for cp in self.cut_list:
- if beforecut and cp[1] in [self.CUT_TYPE_IN, self.CUT_TYPE_OUT]:
+ if beforecut and cp[1] in (self.CUT_TYPE_IN, self.CUT_TYPE_OUT):
beforecut = False
if cp[1] == self.CUT_TYPE_IN: # Start is here, disregard previous marks
diff = cmp(cp[0] - pts)
bestdiff = diff
else:
nearest = None
- if cp[1] in [self.CUT_TYPE_MARK, self.CUT_TYPE_LAST]:
+ if cp[1] in (self.CUT_TYPE_MARK, self.CUT_TYPE_LAST):
diff = cmp(cp[0] - pts)
if diff >= 0 and (nearest is None or bestdiff > diff):
nearest = cp
# <convert type="ServiceName">Reference</convert>
# </widget>
- def __init__(self, session, parent):
- Screen.__init__(self, session, parent = parent)
-
class InfoBarSummarySupport:
def __init__(self):
pass
</widget>
</screen>"""
- def __init__(self, session, parent):
- Screen.__init__(self, session)
-
class InfoBarMoviePlayerSummarySupport:
def __init__(self):
pass
self.__selected_subtitle = None
def __serviceStopped(self):
- self.subtitle_window.hide()
- self.__subtitles_enabled = False
self.cached_subtitle_checked = False
+ if self.__subtitles_enabled:
+ self.subtitle_window.hide()
+ self.__subtitles_enabled = False
+ self.__selected_subtitle = None
def __updatedInfo(self):
if not self.cached_subtitle_checked:
- subtitle = self.getCurrentServiceSubtitle()
self.cached_subtitle_checked = True
- self.__selected_subtitle = subtitle and subtitle.getCachedSubtitle()
+ subtitle = self.getCurrentServiceSubtitle()
+ self.setSelectedSubtitle(subtitle and subtitle.getCachedSubtitle())
if self.__selected_subtitle:
- subtitle.enableSubtitles(self.subtitle_window.instance, self.selected_subtitle)
- self.subtitle_window.show()
- self.__subtitles_enabled = True
+ self.setSubtitlesEnable(True)
def getCurrentServiceSubtitle(self):
service = self.session.nav.getCurrentService()
def setSubtitlesEnable(self, enable=True):
subtitle = self.getCurrentServiceSubtitle()
- 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()
- self.__subtitles_enabled = True
+ if enable:
+ if 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.__selected_subtitle = False
self.__subtitles_enabled = False
self.subtitle_window.hide()
else:
self.last_error = error
- errors = {
+ error = {
eDVBServicePMTHandler.eventNoResources: _("No free tuner!"),
eDVBServicePMTHandler.eventTuneFailed: _("Tune failed!"),
eDVBServicePMTHandler.eventNoPAT: _("No data on transponder!\n(Timeout reading PAT)"),
eDVBServicePMTHandler.eventSOF: None,
eDVBServicePMTHandler.eventEOF: None,
eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
- }
-
- error = errors.get(error) #this returns None when the key not exist in the dict
+ }.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")