from Components.BlinkingPixmap import BlinkingPixmapConditional
from Components.Harddisk import harddiskmanager
from Components.Input import Input
-from Components.Label import *
-from Components.Pixmap import Pixmap, PixmapConditional
+from Components.Label import Label
+from Components.Pixmap import Pixmap
from Components.PluginComponent import plugins
-from Components.ProgressBar import *
from Components.ServiceEventTracker import ServiceEventTracker
from Components.Sources.CurrentService import CurrentService
from Components.Sources.EventInfo import EventInfo
from Components.Sources.Boolean import Boolean
from Components.Sources.Clock import Clock
from Components.TimerList import TimerEntryComponent
-from Components.config import config, ConfigBoolean
-
+from Components.config import config, ConfigBoolean, ConfigClock
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.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 *
+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, localtime, strftime
+from os import stat as os_stat
+from bisect import insort
# hack alert!
from Menu import MainMenu, mdom
STATE_HIDING = 1
STATE_SHOWING = 2
STATE_SHOWN = 3
-
+
def __init__(self):
self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] ,
{
"toggleShow": self.toggleShow,
"hide": self.hide,
+ }, 1) # lower prio to make it possible to override ok and cancel..
+
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evStart: self.serviceStarted,
})
self.__state = self.STATE_SHOWN
self.__locked = 0
-
- self.onExecBegin.append(self.show)
-
+
self.hideTimer = eTimer()
self.hideTimer.timeout.get().append(self.doTimerHide)
self.hideTimer.start(5000, True)
-
+
self.onShow.append(self.__onShow)
self.onHide.append(self.__onHide)
+ def serviceStarted(self):
+ if self.execing:
+ if config.usage.show_infobar_on_zap.value:
+ self.doShow()
+
def __onShow(self):
self.__state = self.STATE_SHOWN
self.startHideTimer()
-
+
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
if self.execing:
self.show()
self.hideTimer.stop()
-
+
def unlockShow(self):
self.__locked = self.__locked - 1
if self.execing:
# def startShow(self):
# self.instance.m_animation.startMoveAnimation(ePoint(0, 600), ePoint(0, 380), 100)
# self.__state = self.STATE_SHOWN
-#
+#
# def startHide(self):
# self.instance.m_animation.startMoveAnimation(ePoint(0, 380), ePoint(0, 600), 100)
# self.__state = self.STATE_HIDDEN
# print "You pressed number " + str(number)
if number == 0:
self.servicelist.recallPrevService()
- 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()
def __init__(self):
#instantiate forever
self.servicelist = self.session.instantiateDialog(ChannelSelection)
-
- print "__init__: servicelist is", self.servicelist
+
if config.misc.initialchannelselection.value:
self.onShown.append(self.firstRun)
self.onShown.remove(self.firstRun)
config.misc.initialchannelselection.value = False
config.misc.initialchannelselection.save()
- print "servicelist is", self.servicelist
self.switchChannelDown()
def historyBack(self):
def switchChannelDown(self):
self.servicelist.moveDown()
self.session.execDialog(self.servicelist)
-
+
def openServiceList(self):
self.session.execDialog(self.servicelist)
else:
self.servicelist.moveUp()
self.servicelist.zap()
- self.doShow()
def zapDown(self):
if self.servicelist.inBouquet():
else:
self.servicelist.moveDown()
self.servicelist.zap()
- self.doShow()
class InfoBarMenu:
""" Handles a menu action, to open the (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 """
self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
"showEventInfo": (self.openEventView, _("show EPG...")),
+ "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
+ "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
})
+ def showEventInfoWhenNotVisible(self):
+ if self.shown:
+ self.openEventView()
+ else:
+ self.toggleShow()
+ return 1
+
def zapToService(self, service):
if not service is None:
if self.servicelist.getRoot() != self.epg_bouquet: #already in correct bouquet?
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["Event_Now"] = EventInfo(self.session.nav, EventInfo.NOW)
self["Event_Next"] = EventInfo(self.session.nav, EventInfo.NEXT)
+class InfoBarRdsDecoder:
+ """provides RDS and Rass support/display"""
+ def __init__(self):
+ self.rds_display = self.session.instantiateDialog(RdsInfoDisplay)
+ self.rass_interactive = None
+
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evEnd: self.__serviceStopped,
+ iPlayableService.evUpdatedRassSlidePic: self.RassSlidePicChanged
+ })
+
+ self["RdsActions"] = ActionMap(["InfobarRdsActions"],
+ {
+ "startRassInteractive": self.startRassInteractive
+ },-1)
+
+ self["RdsActions"].setEnabled(False)
+
+ self.onLayoutFinish.append(self.rds_display.show)
+ self.rds_display.onRassInteractivePossibilityChanged.append(self.RassInteractivePossibilityChanged)
+
+ def RassInteractivePossibilityChanged(self, state):
+ self["RdsActions"].setEnabled(state)
+
+ def RassSlidePicChanged(self):
+ if not self.rass_interactive:
+ service = self.session.nav.getCurrentService()
+ decoder = service and service.rdsDecoder()
+ if decoder:
+ decoder.showRassSlidePicture()
+
+ def __serviceStopped(self):
+ if self.rass_interactive is not None:
+ rass_interactive = self.rass_interactive
+ self.rass_interactive = None
+ rass_interactive.close()
+
+ def startRassInteractive(self):
+ self.rds_display.hide()
+ self.rass_interactive = self.session.openWithCallback(self.RassInteractiveClosed, RassInteractive)
+
+ def RassInteractiveClosed(self, *val):
+ if self.rass_interactive is not None:
+ self.rass_interactive = None
+ self.RassSlidePicChanged()
+ self.rds_display.show()
+
class InfoBarServiceName:
def __init__(self):
self["CurrentService"] = CurrentService(self.session.nav)
class InfoBarSeek:
"""handles actions like seeking, pause"""
-
+
# ispause, isff, issm
SEEK_STATE_PLAY = (0, 0, 0, ">")
SEEK_STATE_PAUSE = (1, 0, 0, "||")
SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x")
SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x")
SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x")
-
+
SEEK_STATE_BACK_16X = (0, -16, 0, "<< 16x")
SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x")
SEEK_STATE_BACK_64X = (0, -64, 0, "<< 64x")
SEEK_STATE_BACK_128X = (0, -128, 0, "<< 128x")
-
+
SEEK_STATE_SM_HALF = (0, 0, 2, "/2")
SEEK_STATE_SM_QUARTER = (0, 0, 4, "/4")
SEEK_STATE_SM_EIGHTH = (0, 0, 8, "/8")
-
- def __init__(self):
+
+ SEEK_STATE_EOF = (1, 0, 0, "END")
+
+ def __init__(self, actionmap = "InfobarSeekActions"):
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
iPlayableService.evStart: self.__serviceStarted,
-
+
iPlayableService.evEOF: self.__evEOF,
iPlayableService.evSOF: self.__evSOF,
})
def __init__(self, screen, *args, **kwargs):
HelpableActionMap.__init__(self, screen, *args, **kwargs)
self.screen = screen
-
+
def action(self, contexts, action):
+ print "action:", action
if action[:5] == "seek:":
time = int(action[5:])
self.screen.seekRelative(time * 90000)
+ self.screen.showAfterSeek()
return 1
else:
return HelpableActionMap.action(self, contexts, action)
- self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions",
+ self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
{
+ "playpauseService": self.playpauseService,
"pauseService": (self.pauseService, _("pause")),
"unPauseService": (self.unPauseService, _("continue")),
-
+
"seekFwd": (self.seekFwd, _("skip forward")),
- "seekFwdDown": self.seekFwdDown,
- "seekFwdUp": self.seekFwdUp,
+ "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
"seekBack": (self.seekBack, _("skip backward")),
- "seekBackDown": self.seekBackDown,
- "seekBackUp": self.seekBackUp,
+ "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")),
+
+ "seekFwdDef": (self.seekFwdDef, _("skip forward (self defined)")),
+ "seekBackDef": (self.seekBackDef, _("skip backward (self defined)"))
}, prio=-1)
# give them a little more priority to win over color buttons
+ self["SeekActions"].setEnabled(False)
+
self.seekstate = self.SEEK_STATE_PLAY
- self.onClose.append(self.delTimer)
- self.fwdtimer = False
- self.fwdKeyTimer = eTimer()
- self.fwdKeyTimer.timeout.get().append(self.fwdTimerFire)
+ self.seek_flag = True
- self.rwdtimer = False
- self.rwdKeyTimer = eTimer()
- self.rwdKeyTimer.timeout.get().append(self.rwdTimerFire)
-
self.onPlayStateChanged = [ ]
-
+
self.lockedBecauseOfSkipping = False
-
+
+ self.__seekableStatusChanged()
+
+ def showAfterSeek(self):
+ if isinstance(self, InfoBarShowHide):
+ self.doShow()
+
def up(self):
pass
-
+
def down(self):
pass
-
- def delTimer(self):
- del self.fwdKeyTimer
- del self.rwdKeyTimer
-
+
def getSeek(self):
service = self.session.nav.getCurrentService()
if service is None:
if seek is None or not seek.isCurrentlySeekable():
return None
-
+
return seek
-
+
def isSeekable(self):
if self.getSeek() is None:
return False
def __serviceStarted(self):
self.seekstate = self.SEEK_STATE_PLAY
+ self.__seekableStatusChanged()
def setSeekState(self, state):
service = self.session.nav.getCurrentService()
-
+
if service is None:
return False
-
+
if not self.isSeekable():
if state not in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
state = self.SEEK_STATE_PLAY
-
+
pauseable = service.pause()
if pauseable is None:
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])
for c in self.onPlayStateChanged:
c(self.seekstate)
-
+
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 "pause, but in fact unpause"
print "no", self.seekstate
print "pause"
self.setSeekState(self.SEEK_STATE_PAUSE);
-
+
def unPauseService(self):
print "unpause"
if self.seekstate == self.SEEK_STATE_PLAY:
return 0
self.setSeekState(self.SEEK_STATE_PLAY)
-
+
def doSeek(self, seektime):
print "doseek", seektime
service = self.session.nav.getCurrentService()
if service is None:
return
-
+
seekable = self.getSeek()
if seekable is None:
return
-
- seekable.seekTo(90 * seektime)
-
- def seekFwdDown(self):
- print "start fwd timer"
- self.fwdtimer = True
- self.fwdKeyTimer.start(1000)
- def seekBackDown(self):
- print "start rewind timer"
- self.rwdtimer = True
- self.rwdKeyTimer.start(1000)
-
- def seekFwdUp(self):
- print "seekFwdUp"
- if self.fwdtimer:
- self.fwdKeyTimer.stop()
- self.fwdtimer = False
- self.seekFwd()
+ seekable.seekTo(90 * seektime)
def seekFwd(self):
lookup = {
self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_64X,
self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_HALF,
self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_HALF,
- self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER
+ self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_SM_QUARTER,
+ self.SEEK_STATE_EOF: self.SEEK_STATE_EOF,
}
self.setSeekState(lookup[self.seekstate])
-
- def seekBackUp(self):
- print "seekBackUp"
- if self.rwdtimer:
- self.rwdKeyTimer.stop()
- self.rwdtimer = False
- self.seekBack()
-
+
def seekBack(self):
lookup = {
self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X,
self.SEEK_STATE_BACK_128X: self.SEEK_STATE_BACK_128X,
self.SEEK_STATE_SM_HALF: self.SEEK_STATE_SM_QUARTER,
self.SEEK_STATE_SM_QUARTER: self.SEEK_STATE_SM_EIGHTH,
- self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
+ self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE,
+ self.SEEK_STATE_EOF: self.SEEK_STATE_BACK_16X,
}
self.setSeekState(lookup[self.seekstate])
-
+
if self.seekstate == self.SEEK_STATE_PAUSE:
seekable = self.getSeek()
if seekable is not None:
seekable.seekRelative(-1, 3)
- def fwdTimerFire(self):
- print "Display seek fwd"
- self.fwdKeyTimer.stop()
- self.fwdtimer = False
- self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
+ def seekFwdDef(self):
+ self.seek_flag = False
+ seconds = config.usage.self_defined_seek.value
+ print "Seek", seconds, "seconds self defined forward"
+ seekable = self.getSeek()
+ if seekable is not None:
+ seekable.seekRelative(1, seconds * 90000)
+
+ def seekBackDef(self):
+ self.seek_flag = False
+ seconds = config.usage.self_defined_seek.value
+ print "Seek", seconds, "seconds self defined backward"
+ seekable = self.getSeek()
+ if seekable is not None:
+ seekable.seekRelative(1, 0 - seconds * 90000)
+ def seekFwdManual(self):
+ self.session.openWithCallback(self.fwdSeekTo, MinuteInput)
+
def fwdSeekTo(self, minutes):
print "Seek", minutes, "minutes forward"
if minutes != 0:
seekable = self.getSeek()
if seekable is not None:
seekable.seekRelative(1, minutes * 60 * 90000)
-
- def rwdTimerFire(self):
- print "rwdTimerFire"
- self.rwdKeyTimer.stop()
- self.rwdtimer = False
+
+ def seekBackManual(self):
self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
-
+
def rwdSeekTo(self, minutes):
print "rwdSeekTo"
self.fwdSeekTo(0 - minutes)
-
+
def checkSkipShowHideLock(self):
wantlock = self.seekstate != self.SEEK_STATE_PLAY
-
- if self.lockedBecauseOfSkipping and not wantlock:
- self.unlockShow()
- self.lockedBecauseOfSkipping = False
-
- if wantlock and not self.lockedBecauseOfSkipping:
- self.lockShow()
- self.lockedBecauseOfSkipping = True
+
+ 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
def __evEOF(self):
- if self.seekstate != self.SEEK_STATE_PLAY:
- self.setSeekState(self.SEEK_STATE_PAUSE)
- # HACK
- #self.getSeek().seekRelative(1, -90000)
- self.setSeekState(self.SEEK_STATE_PLAY)
+ if self.seekstate == self.SEEK_STATE_EOF:
+ return
+ if self.seekstate[1] < 0: # SEEK_STATE_BACK_*X
+ print "end of stream while seeking back, ignoring."
+ return
+
+ # if we are seeking, we try to end up ~1s before the end, and pause there.
+ if not self.seekstate in [self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE]:
+ self.setSeekState(self.SEEK_STATE_EOF)
+ self.seekRelativeToEnd(-90000)
else:
- self.setSeekState(self.SEEK_STATE_PAUSE)
-
+ self.setSeekState(self.SEEK_STATE_EOF)
+
def __evSOF(self):
self.setSeekState(self.SEEK_STATE_PLAY)
self.doSeek(0)
def seekRelative(self, diff):
- seekable = self.getSeek()
- if seekable is not None:
- seekable.seekRelative(1, diff)
+ if self.seek_flag == True:
+ seekable = self.getSeek()
+ if seekable is not None:
+ print "seekRelative: res:", seekable.seekRelative(1, diff)
+ else:
+ print "seek failed!"
+ else:
+ self.seek_flag = True
+
+ def seekRelativeToEnd(self, diff):
+ assert diff <= 0, "diff is expected to be negative!"
+
+ # might sound like an evil hack, but:
+ # if we seekRelativeToEnd(0), we expect to be at the end, which is what we want,
+ # and we don't get that by passing 0 here (it would seek to begin).
+ if diff == 0:
+ diff = -1
+
+ # relative-to-end seeking is implemented as absolutes seeks with negative time
+ self.seekAbsolute(diff)
def seekAbsolute(self, abs):
seekable = self.getSeek()
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.
def __init__(self):
self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
{
- "movieList": (self.showMovies, "movie list"),
- "up": (self.showMovies, "movie list"),
- "down": (self.showMovies, "movie list")
+ "movieList": (self.showMovies, _("movie list")),
+ "up": (self.showMovies, _("movie list")),
+ "down": (self.showMovies, _("movie list"))
})
# InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
# Timeshift works the following way:
# demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
# - normal playback TUNER unused PLAY enable disable disable
-# - user presses "yellow" button. TUNER record PAUSE enable disable enable
+# - user presses "yellow" button. FILE record PAUSE enable disable enable
# - user presess pause again FILE record PLAY enable disable enable
# - user fast forwards FILE record FF enable disable enable
# - end of timeshift buffer reached TUNER record PLAY enable enable disable
}, prio=1)
self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
{
- "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "pause key"
- "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "backward key"
+ "timeshiftActivateEnd": self.activateTimeshiftEnd, # something like "rewind key"
+ "timeshiftActivateEndAndPause": self.activateTimeshiftEndAndPause # something like "pause key"
}, prio=-1) # priority over record
self.timeshift_enabled = 0
self.timeshift_state = 0
- self.ts_pause_timer = eTimer()
- self.ts_pause_timer.timeout.get().append(self.pauseService)
+ self.ts_rewind_timer = eTimer()
+ self.ts_rewind_timer.timeout.get().append(self.rewindService)
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
})
-
+
def getTimeshift(self):
service = self.session.nav.getCurrentService()
return service and service.timeshift()
print "enable timeshift"
ts = self.getTimeshift()
if ts is None:
-# self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
-# print "no ts interface"
- return 0;
-
+ self.session.open(MessageBox, _("Timeshift not possible!"), MessageBox.TYPE_ERROR)
+ print "no ts interface"
+ return 0
+
if self.timeshift_enabled:
print "hu, timeshift already enabled?"
else:
if not ts.startTimeshift():
- import time
self.timeshift_enabled = 1
# we remove the "relative time" for now.
#self.pvrStateDialog["timeshift"].setRelative(time.time())
-
+
# PAUSE.
- self.setSeekState(self.SEEK_STATE_PAUSE)
-
+ #self.setSeekState(self.SEEK_STATE_PAUSE)
+ self.activateTimeshiftEnd(False)
+
# enable the "TimeshiftEnableActions", which will override
# the startTimeshift actions
self.__seekableStatusChanged()
# disable actions
self.__seekableStatusChanged()
-
+
# activates timeshift, and seeks to (almost) the end
- def activateTimeshiftEnd(self):
+ def activateTimeshiftEnd(self, back = True):
ts = self.getTimeshift()
-
+ print "activateTimeshiftEnd"
+
if ts is None:
return
-
+
if ts.isTimeshiftActive():
print "!! activate timeshift called - but shouldn't this be a normal pause?"
self.pauseService()
else:
- self.setSeekState(self.SEEK_STATE_PLAY)
- ts.activateTimeshift()
- self.seekRelative(0)
-
+ print "play, ..."
+ ts.activateTimeshift() # activate timeshift will automatically pause
+ self.setSeekState(self.SEEK_STATE_PAUSE)
+ self.seekRelativeToEnd(-90000) # seek approx. 1 sec before end
+
+ if back:
+ self.ts_rewind_timer.start(200, 1)
+
+ def rewindService(self):
+ self.setSeekState(self.SEEK_STATE_BACK_16X)
+
# same as activateTimeshiftEnd, but pauses afterwards.
def activateTimeshiftEndAndPause(self):
- state = self.seekstate
- self.activateTimeshiftEnd()
-
- # well, this is "andPause", but it could be pressed from pause,
- # when pausing on the (fake-)"live" picture, so an un-pause
- # is perfectly ok.
-
- print "now, pauseService"
- if state == self.SEEK_STATE_PLAY:
- print "is PLAYING, start pause timer"
- self.ts_pause_timer.start(200, 1)
- else:
- print "unpause"
- self.unPauseService()
-
+ print "activateTimeshiftEndAndPause"
+ #state = self.seekstate
+ self.activateTimeshiftEnd(False)
+
def __seekableStatusChanged(self):
enabled = False
-
+
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
# the timeshift
class InfoBarExtensions:
EXTENSION_SINGLE = 0
EXTENSION_LIST = 1
-
+
def __init__(self):
self.list = []
-
+
self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions",
{
"extensions": (self.showExtensionSelection, _("view extensions...")),
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):
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" ]
class InfoBarPlugins:
def __init__(self):
self.addExtension(extension = self.getPluginList, type = InfoBarExtensions.EXTENSION_LIST)
-
-
+
def getPluginName(self, name):
return name
-
+
def getPluginList(self):
list = []
for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EXTENSIONSMENU):
return list
def runPlugin(self, plugin):
+ self.session.servicelist = self.servicelist
plugin(session = self.session)
+ del self.session.servicelist
-# depends on InfoBarExtensions and InfoBarSubtitleSupport
-class InfoBarSubtitles:
+# depends on InfoBarExtensions
+class InfoBarSleepTimer:
def __init__(self):
- self.addExtension((self.getDisableSubtitleName, self.disableSubtitles, self.subtitlesEnabled), "4")
- self.addExtension(extension = self.getSubtitleList, type = InfoBarExtensions.EXTENSION_LIST)
-
- def getDisableSubtitleName(self):
- return _("Disable subtitles")
+ self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
- def getSubtitleList(self):
- list = []
- s = self.getCurrentServiceSubtitle()
- l = s and s.getSubtitleList() or [ ]
+ def available(self):
+ return True
- for x in l:
- list.append(((boundFunction(self.getSubtitleEntryName, x[0]), boundFunction(self.enableSubtitle, x[1]), lambda: True), None))
- return list
-
- def getSubtitleEntryName(self, name):
- return "Enable Subtitles: " + name
+ def getSleepTimerName(self):
+ return _("Sleep Timer")
- def enableSubtitle(self, subtitles):
- print "enable subitles", subtitles
- self.selected_subtitle = subtitles
- self.subtitles_enabled = True
-
- def subtitlesEnabled(self):
- return self.subtitles_enabled
-
- def disableSubtitles(self):
- self.subtitles_enabled = False
+ 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), "1")
- self.addExtension((self.getMoveName, self.movePiP, self.pipShown), "2")
- self.addExtension((self.getSwapName, self.swapPiP, self.pipShown), "3")
-
+ 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)
+ self.session.pip.show()
newservice = self.session.nav.getCurrentlyPlayingServiceReference()
if self.session.pip.playService(newservice):
self.session.pipshown = True
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:
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)
self["BlinkingPoint"].hide()
self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
- def stopCurrentRecording(self, entry = -1):
+ def stopCurrentRecording(self, entry = -1):
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()
-
+
# try to get event info
event = None
try:
except:
pass
- begin = time.time()
- end = time.time() + 3600 * 10
+ begin = time()
+ end = time() + 3600 * 10
name = "instant record"
description = ""
eventid = None
-
+
if event is not None:
curEvent = parseEvent(event)
name = curEvent[2]
else:
if limitEvent:
self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
-
+
data = (begin, end, name, description, eventid)
-
+
recording = self.session.nav.recordWithTimer(serviceref, *data)
recording.dontSave = True
self.recording.append(recording)
-
+
#self["BlinkingPoint"].setConnect(lambda: self.recording.isRunning())
-
+
def isInstantRecordRunning(self):
print "self.recording:", self.recording
if len(self.recording) > 0:
def recordQuestionCallback(self, answer):
print "pre:\n", self.recording
-
+
if answer is None or answer[1] == "no":
return
list = []
if not x in self.session.nav.RecordTimer.timer_list:
self.recording.remove(x)
elif x.dontSave and x.isRunning():
- list.append(TimerEntryComponent(x, False))
+ list.append(TimerEntryComponent(x, False))
if answer[1] == "changeduration":
if len(self.recording) == 1:
self.changeDuration(0)
else:
self.session.openWithCallback(self.changeDuration, TimerSelection, list)
+ elif answer[1] == "changeendtime":
+ if len(self.recording) == 1:
+ self.setEndtime(0)
+ else:
+ self.session.openWithCallback(self.setEndTime, TimerSelection, list)
elif answer[1] == "stop":
if len(self.recording) == 1:
self.stopCurrentRecording(0)
else:
self.session.openWithCallback(self.stopCurrentRecording, TimerSelection, list)
- if answer[1] == "indefinitely" or answer[1] == "manualduration" or answer[1] == "event":
- limitEvent = False
- if answer[1] == "event":
- limitEvent = True
+ elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
+ self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
if answer[1] == "manualduration":
- self.selectedEntry = len(self.recording)
- self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
- self.startInstantRecording(limitEvent = limitEvent)
-
+ self.changeDuration(len(self.recording)-1)
+ elif answer[1] == "manualendtime":
+ self.setEndtime(len(self.recording)-1)
print "after:\n", self.recording
+ def setEndtime(self, entry):
+ if entry is not None:
+ self.selectedEntry = entry
+ self.endtime=ConfigClock(default = self.recording[self.selectedEntry].end)
+ dlg = self.session.openWithCallback(self.TimeDateInputClosed, TimeDateInput, self.endtime)
+ dlg.setTitle(_("Please change recording endtime"))
+
+ def TimeDateInputClosed(self, ret):
+ if len(ret) > 1:
+ if ret[0]:
+ localendtime = localtime(ret[1])
+ print "stopping recording at", strftime("%c", localendtime)
+ 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:
self.selectedEntry = entry
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"), \
+ (_("change recording (endtime)"), "changeendtime"), \
+ (_("add recording (indefinitely)"), "indefinitely"), \
+ (_("add recording (stop after current event)"), "event"), \
+ (_("add recording (enter recording duration)"), "manualduration"), \
+ (_("add recording (enter recording endtime)"), "manualendtime"), \
+ (_("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"), \
+ (_("add recording (enter recording endtime)"), "manualendtime"), \
+ (_("don't record"), "no")])
from Tools.ISO639 import LanguageCodes
i = audio.getTrackInfo(x)
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 + ")"
else:
description = language
-
+
tlist.append((description, x))
-
+
selectedAudio = tlist[0][1]
tlist.sort(lambda x,y : cmp(x[0], y[0]))
self.audioChannel.selectChannel(mode[1])
del self.audioChannel
-
class InfoBarSubserviceSelection:
def __init__(self):
self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
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
- 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))
- tlist = [(_("Quickzap"), "quickzap", service.subServices()), ("--", "")] + tlist
-
- keys = ["red", "", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ] + [""] * n
+ 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 + 2, keys = keys)
+ 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:
if isinstance(service[1], str):
if service[1] == "quickzap":
self.session.open(SubservicesQuickzap, service[2])
else:
self["SubserviceQuickzapAction"].setEnabled(True)
- 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["NimA"] = Pixmap()
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:
self.onExecBegin.append(self.checkNotifications)
Notifications.notificationAdded.append(self.checkNotificationsIfExecing)
self.onClose.append(self.__removeNotification)
-
+
def __removeNotification(self):
Notifications.notificationAdded.remove(self.checkNotificationsIfExecing)
-
+
def checkNotificationsIfExecing(self):
if self.execing:
self.checkNotifications()
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_OUT = 1
CUT_TYPE_MARK = 2
CUT_TYPE_LAST = 3
-
+
ENABLE_RESUME_SUPPORT = False
-
- def __init__(self):
- self["CueSheetActions"] = HelpableActionMap(self, "InfobarCueSheetActions",
+
+ def __init__(self, actionmap = "InfobarCueSheetActions"):
+ self["CueSheetActions"] = HelpableActionMap(self, actionmap,
{
- "jumpPreviousMark": (self.jumpPreviousMark, "jump to next marked position"),
- "jumpNextMark": (self.jumpNextMark, "jump to previous marked position"),
- "toggleMark": (self.toggleMark, "toggle a cut mark at the current position")
+ "jumpPreviousMark": (self.jumpPreviousMark, _("jump to previous marked position")),
+ "jumpNextMark": (self.jumpNextMark, _("jump to next marked position")),
+ "toggleMark": (self.toggleMark, _("toggle a cut mark at the current position"))
}, prio=1)
-
+
self.cut_list = [ ]
self.is_closing = False
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
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)
seekable = self.__getSeekable()
if seekable is not None:
seekable.seekTo(self.resume_point)
+ self.hideAfterResume()
+
+ def hideAfterResume(self):
+ if isinstance(self, InfoBarShowHide):
+ self.hide()
def __getSeekable(self):
service = self.session.nav.getCurrentService()
nearest = None
for cp in self.cut_list:
diff = cmp(cp[0] - pts)
- if diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
+ if cp[1] == self.CUT_TYPE_MARK and diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
nearest = cp
return nearest
if current_pos is None:
print "not seekable"
return
-
+
nearest_cutpoint = self.getNearestCutPoint(current_pos)
-
+
if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < tolerance:
if onlyreturn:
return nearest_cutpoint
self.removeMark(nearest_cutpoint)
elif not onlyremove and not onlyreturn:
self.addMark((current_pos, self.CUT_TYPE_MARK))
-
+
if onlyreturn:
return None
def addMark(self, point):
- bisect.insort(self.cut_list, point)
+ insort(self.cut_list, point)
self.uploadCuesheet()
+ self.showAfterCuesheetOperation()
def removeMark(self, point):
self.cut_list.remove(point)
self.uploadCuesheet()
+ self.showAfterCuesheetOperation()
+
+ def showAfterCuesheetOperation(self):
+ if isinstance(self, InfoBarShowHide):
+ self.doShow()
def __getCuesheet(self):
service = self.session.nav.getCurrentService()
cue = self.__getCuesheet()
if cue is None:
- print "upload failed, no cuesheet interface"
- return
- self.cut_list = cue.getCutList()
+ print "download failed, no cuesheet interface"
+ self.cut_list = [ ]
+ else:
+ self.cut_list = cue.getCutList()
class InfoBarSummary(Screen):
skin = """
class InfoBarSummarySupport:
def __init__(self):
pass
-
+
def createSummary(self):
return InfoBarSummary
class InfoBarTeletextPlugin:
def __init__(self):
self.teletext_plugin = None
-
+
for p in plugins.getPlugins(PluginDescriptor.WHERE_TELETEXT):
self.teletext_plugin = p
-
+
if self.teletext_plugin is not None:
self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions",
{
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
- iPlayableService.evStart: self.__serviceStarted,
+ iPlayableService.evEnd: self.__serviceStopped,
+ iPlayableService.evUpdatedInfo: self.__updatedInfo
})
+ self.cached_subtitle_checked = False
+ self.__selected_subtitle = None
- 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
+ self.__selected_subtitle = 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
def getCurrentServiceSubtitle(self):
service = self.session.nav.getCurrentService()
return service and service.subtitle()
-
+
def setSubtitlesEnable(self, enable=True):
subtitle = self.getCurrentServiceSubtitle()
- if enable and self.__selected_subtitle:
+ if 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")
git.cweiske.de / enigma2.git / blobdiff