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 time import time
+from os import stat as os_stat
+from bisect import insort
# hack alert!
from Menu import MainMenu, mdom
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()
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
self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions",
{
+ "playpauseService": (self.playpauseService, _("pause")),
"pauseService": (self.pauseService, _("pause")),
"unPauseService": (self.unPauseService, _("continue")),
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:
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:
# i don't really like this class.
print "hu, timeshift already enabled?"
else:
if not ts.startTimeshift():
- import time
self.timeshift_enabled = 1
# we remove the "relative time" for now.
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
self.addSubserviceToBouquet(self.bouquets[0][1])
self.session.open(MessageBox, _("Service has been added to the favourites."), MessageBox.TYPE_INFO)
- def bouquetSelClosed(self, **args):
+ def bouquetSelClosed(self, confirmed):
self.bsel = None
del self.selectedSubservice
- self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
+ if confirmed:
+ self.session.open(MessageBox, _("Service has been added to the selected bouquet."), MessageBox.TYPE_INFO)
def addSubserviceToBouquet(self, dest):
- serviceHandler = eServiceCenter.getInstance()
- list = dest and serviceHandler.list(dest)
- mutableList = dest and list and list.startEdit()
- if mutableList:
- if not mutableList.addService(self.selectedSubservice[1]):
- mutableList.flushChanges()
- # do some voodoo to check if the subservice is added to the
- # current selected bouquet in channellist
- cur_root = self.servicelist.getRoot();
- str1 = cur_root.toString()
- str2 = dest.toString()
- pos1 = str1.find("FROM BOUQUET")
- pos2 = str2.find("FROM BOUQUET")
- if pos1 != -1 and pos2 != -1 and str1[pos1:] == str2[pos2:]:
- self.servicelist.setMode()
+ self.servicelist.addServiceToBouquet(dest, self.selectedSubservice[1])
if self.bsel:
- self.bsel.close()
+ self.bsel.close(True)
else:
del self.selectedSubservice
self["ExtensionsAvailable"] = Boolean(fixed=1)
self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
- res_mgr = eDVBResourceManagerPtr()
- if eDVBResourceManager.getInstance(res_mgr) == 0:
+ res_mgr = eDVBResourceManager.getInstance()
+ if res_mgr:
res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged)
def tunerUseMaskChanged(self, mask):
self["NimB_Active"].hide()
def checkTunerState(self, service):
- info = service.frontendInfo()
+ info = service and service.frontendInfo()
feNumber = info and info.getFrontendInfo(iFrontendInformation.frontendNumber)
if feNumber is None:
self["NimA"].hide()
def gotServiceEvent(self, ev):
service = self.session.nav.getCurrentService()
- if ev == iPlayableService.evStart:
+ if ev == iPlayableService.evUpdatedInfo or ev == iPlayableService.evEnd:
self.checkTunerState(service)
class InfoBarNotifications:
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):
return None
def addMark(self, point):
- bisect.insort(self.cut_list, point)
+ insort(self.cut_list, point)
self.uploadCuesheet()
def removeMark(self, point):
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")
git.cweiske.de / enigma2.git / blobdiff