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 Components.UsageConfig import preferredInstantRecordPath, defaultMoviePath
from EpgSelection import EPGSelection
from Plugins.Plugin import PluginDescriptor
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 Screens.UnhandledKey import UnhandledKey
from ServiceReference import ServiceReference
from Tools import Notifications
-from Tools.Directories import SCOPE_HDD, resolveFilename
+from Tools.Directories import fileExists
from enigma import eTimer, eServiceCenter, eDVBServicePMTHandler, iServiceInformation, \
- iPlayableService, eServiceReference, eDVBResourceManager, iFrontendInformation, eEPGCache
+ iPlayableService, eServiceReference, eEPGCache, eActionMap
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
class InfoBarDish:
def __init__(self):
self.dishDialog = self.session.instantiateDialog(Dish)
- self.onLayoutFinish.append(self.dishDialog.show)
+
+class InfoBarUnhandledKey:
+ def __init__(self):
+ self.unhandledKeyDialog = self.session.instantiateDialog(UnhandledKey)
+ self.hideUnhandledKeySymbolTimer = eTimer()
+ self.hideUnhandledKeySymbolTimer.callback.append(self.unhandledKeyDialog.hide)
+ self.checkUnusedTimer = eTimer()
+ self.checkUnusedTimer.callback.append(self.checkUnused)
+ self.onLayoutFinish.append(self.unhandledKeyDialog.hide)
+ eActionMap.getInstance().bindAction('', -0x7FFFFFFF, self.actionA) #highest prio
+ eActionMap.getInstance().bindAction('', 0x7FFFFFFF, self.actionB) #lowest prio
+ self.flags = (1<<1);
+ self.uflags = 0;
+
+ #this function is called on every keypress!
+ def actionA(self, key, flag):
+ if flag != 4:
+ if self.flags & (1<<1):
+ self.flags = self.uflags = 0
+ self.flags |= (1<<flag)
+ if flag == 1: # break
+ self.checkUnusedTimer.start(0, True)
+ return 0
+
+ #this function is only called when no other action has handled this key
+ def actionB(self, key, flag):
+ if flag != 4:
+ self.uflags |= (1<<flag)
+
+ def checkUnused(self):
+ if self.flags == self.uflags:
+ self.unhandledKeyDialog.show()
+ self.hideUnhandledKeySymbolTimer.start(2000, True)
class InfoBarShowHide:
""" InfoBar show/hide control, accepts toggleShow and hide actions, might start
self.__locked = 0
self.hideTimer = eTimer()
- self.hideTimer.timeout.get().append(self.doTimerHide)
+ self.hideTimer.callback.append(self.doTimerHide)
self.hideTimer.start(5000, True)
self.onShow.append(self.__onShow)
self["number"] = Label(self.field)
- self["actions"] = NumberActionMap( [ "SetupActions" ],
+ self["actions"] = NumberActionMap( [ "SetupActions" ],
{
"cancel": self.quit,
"ok": self.keyOK,
})
self.Timer = eTimer()
- self.Timer.timeout.get().append(self.keyOK)
+ self.Timer.callback.append(self.keyOK)
self.Timer.start(3000, True)
class InfoBarNumberZap:
else:
self.servicelist.recallPrevService()
else:
- self.session.openWithCallback(self.numberEntered, NumberZap, number)
+ if self.has_key("TimeshiftActions") and not self.timeshift_enabled:
+ self.session.openWithCallback(self.numberEntered, NumberZap, number)
def numberEntered(self, retval):
# print self.servicelist
config.misc.initialchannelselection = ConfigBoolean(default = True)
class InfoBarChannelSelection:
- """ ChannelSelection - handles the channelSelection dialog and the initial
+ """ ChannelSelection - handles the channelSelection dialog and the initial
channelChange actions which open the channelSelection dialog """
def __init__(self):
#instantiate forever
class InfoBarMenu:
""" Handles a menu action, to open the (main) menu """
def __init__(self):
- self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
+ self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
{
"mainMenu": (self.mainMenu, _("Enter main menu...")),
})
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.dlg_stack = [ ]
self.bouquetSel = None
self.eventView = None
- self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
+ self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
"showEventInfo": (self.openEventView, _("show EPG...")),
- "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
+ "showEventInfoPlugin": (self.showEventInfoPlugins, _("list of EPG views...")),
"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)
self.dlg_stack.append(self.bouquetSel)
else:
self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
- elif cnt == 1:
+ 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"""
- # ispause, isff, issm
SEEK_STATE_PLAY = (0, 0, 0, ">")
SEEK_STATE_PAUSE = (1, 0, 0, "||")
- SEEK_STATE_FF_2X = (0, 2, 0, ">> 2x")
- SEEK_STATE_FF_4X = (0, 4, 0, ">> 4x")
- SEEK_STATE_FF_8X = (0, 8, 0, ">> 8x")
- SEEK_STATE_FF_16X = (0, 16, 0, ">> 16x")
- SEEK_STATE_FF_32X = (0, 32, 0, ">> 32x")
- SEEK_STATE_FF_48X = (0, 48, 0, ">> 48x")
- SEEK_STATE_FF_64X = (0, 64, 0, ">> 64x")
- SEEK_STATE_FF_128X = (0, 128, 0, ">> 128x")
-
- SEEK_STATE_BACK_8X = (0, -8, 0, "<< 8x")
- SEEK_STATE_BACK_16X = (0, -16, 0, "<< 16x")
- SEEK_STATE_BACK_32X = (0, -32, 0, "<< 32x")
- SEEK_STATE_BACK_48X = (0, -48, 0, "<< 48x")
- 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")
-
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.fast_winding_hint_message_showed = False
class InfoBarSeekActionMap(HelpableActionMap):
def __init__(self, screen, *args, **kwargs):
print "action:", action
if action[:5] == "seek:":
time = int(action[5:])
- self.screen.seekRelative(time * 90000)
- if config.usage.show_infobar_on_skip.value:
- self.screen.showAfterSeek()
+ self.screen.doSeekRelative(time * 90000)
return 1
+ elif action[:8] == "seekdef:":
+ key = int(action[8:])
+ 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]
+ self.screen.doSeekRelative(time * 90000)
+ return 1
else:
return HelpableActionMap.action(self, contexts, action)
- self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
+ self["SeekActions"] = InfoBarSeekActionMap(self, actionmap,
{
"playpauseService": self.playpauseService,
"pauseService": (self.pauseService, _("pause")),
"seekFwd": (self.seekFwd, _("skip forward")),
"seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
"seekBack": (self.seekBack, _("skip backward")),
- "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")),
-
- "seekFwdDef": (self.seekFwdDef, _("skip forward (self defined)")),
- "seekBackDef": (self.seekBackDef, _("skip backward (self defined)"))
+ "seekBackManual": (self.seekBackManual, _("skip backward (enter time)"))
}, prio=-1)
# give them a little more priority to win over color buttons
self["SeekActions"].setEnabled(False)
self.seekstate = self.SEEK_STATE_PLAY
-
- self.seek_flag = True
+ self.lastseekstate = self.SEEK_STATE_PLAY
self.onPlayStateChanged = [ ]
self.__seekableStatusChanged()
+ def makeStateForward(self, n):
+# minspeed = config.seek.stepwise_minspeed.value
+# repeat = int(config.seek.stepwise_repeat.value)
+# if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
+# return (0, n * repeat, repeat, ">> %dx" % n)
+# else:
+ return (0, n, 0, ">> %dx" % n)
+
+ def makeStateBackward(self, n):
+# minspeed = config.seek.stepwise_minspeed.value
+# repeat = int(config.seek.stepwise_repeat.value)
+# if minspeed != "Never" and n >= int(minspeed) and repeat > 1:
+# return (0, -n * repeat, repeat, "<< %dx" % n)
+# else:
+ return (0, -n, 0, "<< %dx" % n)
+
+ def makeStateSlowMotion(self, n):
+ return (0, 0, n, "/%d" % n)
+
+ def isStateForward(self, state):
+ return state[1] > 1
+
+ def isStateBackward(self, state):
+ return state[1] < 0
+
+ def isStateSlowMotion(self, state):
+ return state[1] == 0 and state[2] > 1
+
+ def getHigher(self, n, lst):
+ for x in lst:
+ if x > n:
+ return x
+ return False
+
+ def getLower(self, n, lst):
+ lst = lst[:]
+ lst.reverse()
+ for x in lst:
+ if x < n:
+ return x
+ return False
+
def showAfterSeek(self):
if isinstance(self, InfoBarShowHide):
self.doShow()
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.fast_winding_hint_message_showed = False
self.seekstate = self.SEEK_STATE_PLAY
self.__seekableStatusChanged()
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)
def pauseService(self):
if self.seekstate == self.SEEK_STATE_PAUSE:
- print "pause, but in fact unpause"
- self.unPauseService()
+ if config.seek.on_pause.value == "play":
+ self.unPauseService()
+ elif config.seek.on_pause.value == "step":
+ self.doSeekRelative(1)
+ elif config.seek.on_pause.value == "last":
+ self.setSeekState(self.lastseekstate)
+ self.lastseekstate = self.SEEK_STATE_PLAY
else:
- if self.seekstate == self.SEEK_STATE_PLAY:
- print "yes, playing."
- else:
- print "no", self.seekstate
- print "pause"
+ if self.seekstate != self.SEEK_STATE_EOF:
+ self.lastseekstate = self.seekstate
self.setSeekState(self.SEEK_STATE_PAUSE);
def unPauseService(self):
return 0
self.setSeekState(self.SEEK_STATE_PLAY)
- def doSeek(self, seektime):
- print "doseek", seektime
- service = self.session.nav.getCurrentService()
- if service is None:
+ def doSeek(self, pts):
+ seekable = self.getSeek()
+ if seekable is None:
return
+ seekable.seekTo(pts)
+ def doSeekRelative(self, pts):
seekable = self.getSeek()
if seekable is None:
return
+ prevstate = self.seekstate
- seekable.seekTo(90 * seektime)
+ 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)
+ seekable.seekRelative(pts<0 and -1 or 1, abs(pts))
+ if abs(pts) > 100 and config.usage.show_infobar_on_skip.value:
+ self.showAfterSeek()
def seekFwd(self):
- lookup = {
- self.SEEK_STATE_PLAY: self.SEEK_STATE_FF_2X,
- self.SEEK_STATE_PAUSE: self.SEEK_STATE_SM_EIGHTH,
- self.SEEK_STATE_FF_2X: self.SEEK_STATE_FF_4X,
- self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_8X,
- self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_16X,
- self.SEEK_STATE_FF_16X: self.SEEK_STATE_FF_32X,
- self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_48X,
- self.SEEK_STATE_FF_48X: self.SEEK_STATE_FF_64X,
- self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_128X,
- self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_128X,
- self.SEEK_STATE_BACK_8X: self.SEEK_STATE_PLAY,
- self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_8X,
- self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X,
- self.SEEK_STATE_BACK_48X: self.SEEK_STATE_BACK_32X,
- self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_48X,
- 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_EOF: self.SEEK_STATE_EOF,
- }
- self.setSeekState(lookup[self.seekstate])
+ seek = self.getSeek()
+ if seek and not (seek.isCurrentlySeekable() & 2):
+ if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
+ self.session.open(MessageBox, _("No fast winding possible yet.. but you can use the number buttons to skip forward/backward!"), MessageBox.TYPE_INFO, timeout=10)
+ self.fast_winding_hint_message_showed = True
+ return
+ return 0 # trade as unhandled action
+ if self.seekstate == self.SEEK_STATE_PLAY:
+ self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
+ elif self.seekstate == self.SEEK_STATE_PAUSE:
+ if len(config.seek.speeds_slowmotion.value):
+ self.setSeekState(self.makeStateSlowMotion(config.seek.speeds_slowmotion.value[-1]))
+ else:
+ self.setSeekState(self.makeStateForward(int(config.seek.enter_forward.value)))
+ elif self.seekstate == self.SEEK_STATE_EOF:
+ pass
+ elif self.isStateForward(self.seekstate):
+ speed = self.seekstate[1]
+ if self.seekstate[2]:
+ speed /= self.seekstate[2]
+ speed = self.getHigher(speed, config.seek.speeds_forward.value) or config.seek.speeds_forward.value[-1]
+ self.setSeekState(self.makeStateForward(speed))
+ elif self.isStateBackward(self.seekstate):
+ speed = -self.seekstate[1]
+ if self.seekstate[2]:
+ speed /= self.seekstate[2]
+ speed = self.getLower(speed, config.seek.speeds_backward.value)
+ if speed:
+ self.setSeekState(self.makeStateBackward(speed))
+ else:
+ self.setSeekState(self.SEEK_STATE_PLAY)
+ elif self.isStateSlowMotion(self.seekstate):
+ speed = self.getLower(self.seekstate[2], config.seek.speeds_slowmotion.value) or config.seek.speeds_slowmotion.value[0]
+ self.setSeekState(self.makeStateSlowMotion(speed))
def seekBack(self):
- lookup = {
- self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_8X,
- self.SEEK_STATE_PAUSE: self.SEEK_STATE_PAUSE,
- self.SEEK_STATE_FF_2X: self.SEEK_STATE_PLAY,
- self.SEEK_STATE_FF_4X: self.SEEK_STATE_FF_2X,
- self.SEEK_STATE_FF_8X: self.SEEK_STATE_FF_4X,
- self.SEEK_STATE_FF_16X: self.SEEK_STATE_FF_8X,
- self.SEEK_STATE_FF_32X: self.SEEK_STATE_FF_16X,
- self.SEEK_STATE_FF_48X: self.SEEK_STATE_FF_32X,
- self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_48X,
- self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
- self.SEEK_STATE_BACK_8X: self.SEEK_STATE_BACK_16X,
- self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X,
- self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_48X,
- self.SEEK_STATE_BACK_48X: self.SEEK_STATE_BACK_64X,
- self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_128X,
- 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_EOF: self.SEEK_STATE_BACK_8X,
- }
- self.setSeekState(lookup[self.seekstate])
-
- if self.seekstate == self.SEEK_STATE_PAUSE:
- seekable = self.getSeek()
- if seekable is not None:
- seekable.seekRelative(-1, 3)
+ seek = self.getSeek()
+ if seek and not (seek.isCurrentlySeekable() & 2):
+ if not self.fast_winding_hint_message_showed and (seek.isCurrentlySeekable() & 1):
+ self.session.open(MessageBox, _("No fast winding possible yet.. but you can use the number buttons to skip forward/backward!"), MessageBox.TYPE_INFO, timeout=10)
+ self.fast_winding_hint_message_showed = True
+ return
+ return 0 # trade as unhandled action
+ seekstate = self.seekstate
+ if seekstate == self.SEEK_STATE_PLAY:
+ self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
+ elif seekstate == self.SEEK_STATE_EOF:
+ self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
+ self.doSeekRelative(-6)
+ elif seekstate == self.SEEK_STATE_PAUSE:
+ self.doSeekRelative(-1)
+ 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(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(seekstate):
+ speed = self.getHigher(seekstate[2], config.seek.speeds_slowmotion.value)
+ if speed:
+ self.setSeekState(self.makeStateSlowMotion(speed))
+ else:
+ self.setSeekState(self.SEEK_STATE_PAUSE)
- 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)
+ self.doSeekRelative(minutes * 60 * 90000)
def seekBackManual(self):
self.session.openWithCallback(self.rwdSeekTo, MinuteInput)
def rwdSeekTo(self, minutes):
print "rwdSeekTo"
- self.fwdSeekTo(0 - minutes)
+ self.doSeekRelative(-minutes * 60 * 90000)
def checkSkipShowHideLock(self):
wantlock = self.seekstate != self.SEEK_STATE_PLAY
self.lockShow()
self.lockedBecauseOfSkipping = True
+ def calcRemainingTime(self):
+ seekable = self.getSeek()
+ if seekable is not None:
+ len = seekable.getLength()
+ try:
+ tmp = self.cueGetEndCutPosition()
+ if tmp:
+ len = [False, tmp]
+ except:
+ pass
+ pos = seekable.getPlayPosition()
+ speednom = self.seekstate[1] or 1
+ speedden = self.seekstate[2] or 1
+ if not len[0] and not pos[0]:
+ if len[1] <= pos[1]:
+ return 0
+ time = (len[1] - pos[1])*speedden/(90*speednom)
+ return time
+ return False
+
def __evEOF(self):
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:
+ # if we are seeking forward, we try to end up ~1s before the end, and pause there.
+ seekstate = self.seekstate
+ if self.seekstate != 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):
- if self.seek_flag == True:
+ if seekstate not in (self.SEEK_STATE_PLAY, self.SEEK_STATE_PAUSE): # if we are seeking
seekable = self.getSeek()
if seekable is not None:
- print "seekRelative: res:", seekable.seekRelative(1, diff)
- else:
- print "seek failed!"
+ seekable.seekTo(-1)
+ if seekstate == self.SEEK_STATE_PLAY: # regular EOF
+ self.doEofInternal(True)
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
+ self.doEofInternal(False)
- # relative-to-end seeking is implemented as absolutes seeks with negative time
- self.seekAbsolute(diff)
+ def doEofInternal(self, playing):
+ pass # Defined in subclasses
- def seekAbsolute(self, abs):
- seekable = self.getSeek()
- if seekable is not None:
- seekable.seekTo(abs)
+ def __evSOF(self):
+ self.setSeekState(self.SEEK_STATE_PLAY)
+ self.doSeek(0)
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)
+ self.__hideTimer = eTimer()
+ self.__hideTimer.callback.append(self.__hideTimeshiftState)
def _mayShow(self):
if self.execing and self.timeshift_enabled:
self.pvrStateDialog.show()
+ if self.seekstate == self.SEEK_STATE_PLAY and not self.shown:
+ self.__hideTimer.start(5*1000, True)
+
+ def __hideTimeshiftState(self):
+ self.pvrStateDialog.hide()
class InfoBarShowMovies:
- # i don't really like this class.
+ # i don't really like this class.
# it calls a not further specified "movie list" on up/down/movieList,
# so this is not more than an action map
def __init__(self):
- self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
+ self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions",
{
"movieList": (self.showMovies, _("movie list")),
"up": (self.showMovies, _("movie list")),
class InfoBarTimeshift:
def __init__(self):
- self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
+ self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
{
"timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
"timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
self.timeshift_enabled = 0
self.timeshift_state = 0
self.ts_rewind_timer = eTimer()
- self.ts_rewind_timer.timeout.get().append(self.rewindService)
+ self.ts_rewind_timer.callback.append(self.rewindService)
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
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)
+ self.setSeekState(self.makeStateBackward(int(config.seek.enter_backward.value)))
# same as activateTimeshiftEnd, but pauses afterwards.
def activateTimeshiftEndAndPause(self):
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
-
- 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
+ try:
+ self.session.pipshown
+ except:
+ self.session.pipshown = False
+ if 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
+ """Instant Record - handles the instantRecord action in order to
start/stop instant records"""
def __init__(self):
self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
"instantRecord": (self.instantRecord, _("Instant Record...")),
})
self.recording = []
- self["BlinkingPoint"] = BlinkingPixmapConditional()
- self["BlinkingPoint"].hide()
- self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
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 = preferredInstantRecordPath())
recording.dontSave = True
- self.recording.append(recording)
-
- #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
if len(self.recording) == 1:
self.setEndtime(0)
else:
- self.session.openWithCallback(self.setEndTime, TimerSelection, list)
+ self.session.openWithCallback(self.setEndtime, TimerSelection, list)
elif answer[1] == "stop":
if len(self.recording) == 1:
self.stopCurrentRecording(0)
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 = preferredInstantRecordPath()
+ if not dir or not fileExists(dir, 'w'):
+ dir = defaultMoviePath()
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
class InfoBarAudioSelection:
def __init__(self):
- self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
+ self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
{
"audioSelection": (self.audioSelection, _("Audio Options...")),
})
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)
+ availableKeys = []
+ usedKeys = []
+
+ if SystemInfo["CanDownmixAC3"]:
+ flist = [(_("AC3 downmix") + " - " +(_("Off"), _("On"))[config.av.downmix_ac3.value and 1 or 0], "CALLFUNC", self.changeAC3Downmix),
+ ((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
+ usedKeys.extend(["red", "green"])
+ availableKeys.extend(["yellow", "blue"])
+ selection += 2
+ else:
+ flist = [((_("Left"), _("Stereo"), _("Right"))[self.audioChannel.getCurrentChannel()], "mode")]
+ usedKeys.extend(["red"])
+ availableKeys.extend(["green", "yellow", "blue"])
+ selection += 1
+
+ if hasattr(self, "runPlugin"):
+ class PluginCaller:
+ def __init__(self, fnc, *args):
+ self.fnc = fnc
+ self.args = args
+ def __call__(self, *args, **kwargs):
+ self.fnc(*self.args)
+
+ Plugins = [ (p.name, PluginCaller(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_AUDIOMENU) ]
+
+ for p in Plugins:
+ selection += 1
+ flist.append((p[0], "CALLFUNC", p[1]))
+ if availableKeys:
+ usedKeys.append(availableKeys[0])
+ del availableKeys[0]
+ else:
+ usedKeys.append("")
+
+ flist.append(("--", ""))
+ usedKeys.append("")
+ selection += 1
+
+ keys = usedKeys + [ "1", "2", "3", "4", "5", "6", "7", "8", "9", "0" ] + [""] * n
+ self.session.openWithCallback(self.audioSelected, ChoiceBox, title=_("Select audio track"), list = flist + 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["NimA"] = Pixmap()
- self["NimB"] = Pixmap()
- self["NimA_Active"] = Pixmap()
- self["NimB_Active"] = Pixmap()
- 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)
- self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
- res_mgr = eDVBResourceManager.getInstance()
- if res_mgr:
- res_mgr.frontendUseMaskChanged.get().append(self.tunerUseMaskChanged)
-
- def 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"):
ENABLE_RESUME_SUPPORT = False
def __init__(self, actionmap = "InfobarCueSheetActions"):
- self["CueSheetActions"] = HelpableActionMap(self, actionmap,
+ self["CueSheetActions"] = HelpableActionMap(self, actionmap,
{
"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)
+ }, prio=1)
self.cut_list = [ ]
self.is_closing = False
if last is not None:
self.resume_point = last
- Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?"), timeout=10)
+
+ l = last / 90000
+ if config.usage.on_movie_start.value == "ask":
+ Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Do you want to resume this playback?") + "\n" + (_("Resume position at %s") % ("%d:%02d:%02d" % (l/3600, l%3600/60, l%60))), timeout=10)
+ elif config.usage.on_movie_start.value == "resume":
+# TRANSLATORS: The string "Resuming playback" flashes for a moment
+# TRANSLATORS: at the start of a movie, when the user has selected
+# TRANSLATORS: "Resume from last position" as start behavior.
+# TRANSLATORS: The purpose is to notify the user that the movie starts
+# TRANSLATORS: in the middle somewhere and not from the beginning.
+# TRANSLATORS: (Some translators seem to have interpreted it as a
+# TRANSLATORS: question or a choice, but it is a statement.)
+ Notifications.AddNotificationWithCallback(self.playLastCB, MessageBox, _("Resuming playback"), timeout=2, type=MessageBox.TYPE_INFO)
def playLastCB(self, answer):
if answer == True:
- seekable = self.__getSeekable()
- if seekable is not None:
- seekable.seekTo(self.resume_point)
+ self.doSeek(self.resume_point)
self.hideAfterResume()
-
+
def hideAfterResume(self):
if isinstance(self, InfoBarShowHide):
self.hide()
return None
return long(r[1])
- def jumpPreviousNextMark(self, cmp, alternative=None):
+ def cueGetEndCutPosition(self):
+ ret = False
+ isin = True
+ for cp in self.cut_list:
+ if cp[1] == self.CUT_TYPE_OUT:
+ if isin:
+ isin = False
+ ret = cp[0]
+ elif cp[1] == self.CUT_TYPE_IN:
+ isin = True
+ return ret
+
+ def jumpPreviousNextMark(self, cmp, start=False):
current_pos = self.cueGetCurrentPosition()
if current_pos is None:
- return
- mark = self.getNearestCutPoint(current_pos, cmp=cmp)
+ return False
+ mark = self.getNearestCutPoint(current_pos, cmp=cmp, start=start)
if mark is not None:
pts = mark[0]
- elif alternative is not None:
- pts = alternative
else:
- return
+ return False
- seekable = self.__getSeekable()
- if seekable is not None:
- seekable.seekTo(pts)
+ self.doSeek(pts)
+ return True
def jumpPreviousMark(self):
# we add 2 seconds, so if the play position is <2s after
# the mark, the mark before will be used
- self.jumpPreviousNextMark(lambda x: -x-5*90000, alternative=0)
+ self.jumpPreviousNextMark(lambda x: -x-5*90000, start=True)
def jumpNextMark(self):
- self.jumpPreviousNextMark(lambda x: x)
+ if not self.jumpPreviousNextMark(lambda x: x):
+ self.doSeek(-1)
- def getNearestCutPoint(self, pts, cmp=abs):
+ def getNearestCutPoint(self, pts, cmp=abs, start=False):
# can be optimized
+ beforecut = False
nearest = None
+ if start:
+ beforecut = True
+ bestdiff = cmp(0 - pts)
+ if bestdiff >= 0:
+ nearest = [0, False]
for cp in self.cut_list:
- diff = cmp(cp[0] - pts)
- if cp[1] == self.CUT_TYPE_MARK and diff >= 0 and (nearest is None or cmp(nearest[0] - pts) > diff):
- nearest = cp
+ 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)
+ if diff >= 0:
+ nearest = cp
+ bestdiff = diff
+ else:
+ nearest = None
+ 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
+ bestdiff = diff
return nearest
def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
class InfoBarSummary(Screen):
skin = """
<screen position="0,0" size="132,64">
- <widget source="global.CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
+ <widget source="global.CurrentTime" render="Label" position="62,46" size="82,18" font="Regular;16" >
<convert type="ClockToText">WithSeconds</convert>
</widget>
+ <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="82,18" zPosition="1" >
+ <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
+ <convert type="ConditionalShowHide">Blink</convert>
+ </widget>
<widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
<convert type="ServiceName">Name</convert>
- </widget>
+ </widget>
+ <widget source="session.Event_Now" render="Progress" position="6,46" size="46,18" borderWidth="1" >
+ <convert type="EventTime">Progress</convert>
+ </widget>
</screen>"""
# for picon: (path="piconlcd" will use LCD picons)
# <convert type="ServiceName">Reference</convert>
# </widget>
- def __init__(self, session, parent):
- Screen.__init__(self, session)
-
class InfoBarSummarySupport:
def __init__(self):
pass
class InfoBarMoviePlayerSummary(Screen):
skin = """
<screen position="0,0" size="132,64">
- <widget source="global.CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
+ <widget source="global.CurrentTime" render="Label" position="62,46" size="64,18" font="Regular;16" halign="right" >
<convert type="ClockToText">WithSeconds</convert>
</widget>
+ <widget source="session.RecordState" render="FixedLabel" text=" " position="62,46" size="64,18" zPosition="1" >
+ <convert type="ConfigEntryTest">config.usage.blinking_display_clock_during_recording,True,CheckSourceBoolean</convert>
+ <convert type="ConditionalShowHide">Blink</convert>
+ </widget>
<widget source="session.CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
<convert type="ServiceName">Name</convert>
</widget>
- <widget source="session.CurrentService" render="Progress" position="0,46" size="56,18" >
+ <widget source="session.CurrentService" render="Progress" position="6,46" size="56,18" borderWidth="1" >
<convert type="ServicePosition">Position</convert>
</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.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
+ eDVBServicePMTHandler.eventEOF: None,
+ eDVBServicePMTHandler.eventMisconfiguration: _("Service unavailable!\nCheck tuner configuration!"),
+ }.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")
git.cweiske.de / enigma2.git / blobdiff