from ServiceReference import ServiceReference
from Tools import Notifications
-from Tools.Directories import SCOPE_HDD, resolveFilename, pathExists
+from Tools.Directories import SCOPE_HDD, resolveFilename, fileExists
from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
iPlayableService, eServiceReference, eEPGCache
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.session.open(EPGSelection, ref)
def showEventInfoPlugins(self):
- list = []
- for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO):
- list.append((p.name, boundFunction(self.runPlugin, p)))
- if len(list):
+ 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)
else:
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])
+ 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"""
return False
def getLower(self, n, lst):
- lst = lst+[]
+ lst = lst[:]
lst.reverse()
for x in lst:
if x < n:
oldstate = self.seekstate
self.seekstate = state
- for i in range(3):
+ for i in (0, 1, 2):
if oldstate[i] != self.seekstate[i]:
(self.session.nav.pause, pauseable.setFastForward, pauseable.setSlowMotion)[i](self.seekstate[i])
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 and self.seekstate != self.SEEK_STATE_PLAY:
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)
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))
- return list
+ return [((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU)]
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)
from Components.Task import job_manager
class InfoBarJobman:
self.addExtension(extension = self.getJobList, type = InfoBarExtensions.EXTENSION_LIST)
def getJobList(self):
- list = []
- for job in job_manager.getPendingJobs():
- list.append(((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None))
- return list
+ return [((boundFunction(self.getJobName, job), boundFunction(self.showJobView, job), lambda: True), None) for job in job_manager.getPendingJobs()]
def getJobName(self, job):
return "%s: %s (%d%%)" % (job.getStatustext(), job.name, int(100*job.progress/float(job.end)))
except:
pass
- begin = time()
- end = time() + 3600 * 24 * 365 * 1 # 1 year
+ begin = int(time())
+ end = begin + 3600 # dummy
name = "instant record"
description = ""
eventid = None
recording = RecordTimerEntry(serviceref, begin, end, name, description, eventid, dirname = config.movielist.last_videodir.value)
recording.dontSave = True
- recording.autoincrease = True
-
- simulTimerList = self.session.nav.RecordTimer.record(recording)
- if simulTimerList is not None:
- print "timer conflict detected!"
- if (len(simulTimerList) > 1):
- print "tsc_list > 1"
- recording.end = simulTimerList[1].begin - 30
+
+ if event is None or limitEvent == False:
+ recording.autoincrease = True
+ if recording.setAutoincreaseEnd():
self.session.nav.RecordTimer.record(recording)
- print "new endtime applied"
- else:
- print "conflict with only one timer? ! ?"
- self.recording.append(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
def inputCallback(self, value):
if value is not None:
print "stopping recording after", int(value), "minutes."
+ entry = self.recording[self.selectedEntry]
if int(value) != 0:
- self.recording[self.selectedEntry].autoincrease = False
- self.recording[self.selectedEntry].end = time() + 60 * int(value)
- self.session.nav.RecordTimer.timeChanged(self.recording[self.selectedEntry])
+ 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 pathExists(dir):
+ if not fileExists(dir, 'w'):
dir = resolveFilename(SCOPE_HDD)
try:
stat = os_stat(dir)
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"), \
- (_("add recording (stop after current event)"), "event"), \
+ list=((_("add recording (stop after current event)"), "event"), \
(_("add recording (enter recording duration)"), "manualduration"), \
(_("add recording (enter recording endtime)"), "manualendtime"), \
- (_("do nothing"), "no")])
+ (_("add recording (indefinitely)"), "indefinitely"), \
+ (_("change recording (duration)"), "changeduration"), \
+ (_("change recording (endtime)"), "changeendtime"), \
+ (_("stop recording"), "stop"), \
+ (_("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 (enter recording duration)"), "manualduration"), \
(_("add recording (enter recording endtime)"), "manualendtime"), \
- (_("don't record"), "no")])
+ (_("add recording (indefinitely)"), "indefinitely"), \
+ (_("don't record"), "no")))
from Tools.ISO639 import LanguageCodes
if n > 0:
self.audioChannel = service.audioChannel()
- for x in range(n):
- i = audio.getTrackInfo(x)
+ idx = 0
+ while idx < n:
+ i = audio.getTrackInfo(idx)
language = i.getLanguage()
description = i.getDescription()
else:
description = language
- tlist.append((description, x))
+ tlist.append((description, idx))
+ idx += 1
tlist.sort(key=lambda x: x[0])
if audio[1] == "mode":
keys = ["red", "green", "yellow"]
selection = self.audioChannel.getCurrentChannel()
- tlist = [(_("left"), 0), (_("stereo"), 1), (_("right"), 2)]
+ 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 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 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", "blue", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
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