-from Screen import Screen
+from ChannelSelection import ChannelSelection, BouquetSelector
+
from Components.ActionMap import ActionMap, HelpableActionMap
from Components.ActionMap import NumberActionMap
-from Components.Label import *
-from Components.config import configfile, configsequencearg
-from Components.config import config, configElement, ConfigSubsection, configSequence
-from ChannelSelection import ChannelSelection
-
-from Components.Pixmap import Pixmap, PixmapConditional
from Components.BlinkingPixmap import BlinkingPixmapConditional
-from Components.ServiceName import ServiceName
-from Components.EventInfo import EventInfo
-
-from ServiceReference import ServiceReference
+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.CurrentService import CurrentService
+from Components.Sources.EventInfo import EventInfo
+from Components.Sources.FrontendStatus import FrontendStatus
+from Components.Sources.Boolean import Boolean
+from Components.Sources.Clock import Clock
+from Components.config import config, ConfigBoolean, ConfigClock
from EpgSelection import EPGSelection
+from Plugins.Plugin import PluginDescriptor
-from Screens.MessageBox import MessageBox
-from Screens.Volume import Volume
-from Screens.Mute import Mute
+from Screen import Screen
+from Screens.ChoiceBox import ChoiceBox
from Screens.Dish import Dish
-from Screens.Standby import Standby
-from Screens.EventView import EventView
+from Screens.EventView import EventViewEPGSelect, EventViewSimple
+from Screens.InputBox import InputBox
+from Screens.MessageBox import MessageBox
+from Screens.MinuteInput import MinuteInput
+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 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
+from time import time, localtime, strftime
+from os import stat as os_stat
+from bisect import insort
# hack alert!
from Menu import MainMenu, mdom
-class InfoBarVolumeControl:
- """Volume control, handles volUp, volDown, volMute actions and display
- a corresponding dialog"""
- def __init__(self):
- config.audio = ConfigSubsection()
- config.audio.volume = configElement("config.audio.volume", configSequence, [5], configsequencearg.get("INTEGER", (0, 100)))
-
- self["VolumeActions"] = ActionMap( ["InfobarVolumeActions"] ,
- {
- "volumeUp": self.volUp,
- "volumeDown": self.volDown,
- "volumeMute": self.volMute,
- })
-
- self.volumeDialog = self.session.instantiateDialog(Volume)
- self.muteDialog = self.session.instantiateDialog(Mute)
-
- self.hideVolTimer = eTimer()
- self.hideVolTimer.timeout.get().append(self.volHide)
-
- vol = config.audio.volume.value[0]
- self.volumeDialog.setValue(vol)
- eDVBVolumecontrol.getInstance().setVolume(vol, vol)
-
- def volSave(self):
- config.audio.volume.value = eDVBVolumecontrol.getInstance().getVolume()
- config.audio.volume.save()
-
- def volUp(self):
- if (eDVBVolumecontrol.getInstance().isMuted()):
- self.volMute()
- eDVBVolumecontrol.getInstance().volumeUp()
- self.volumeDialog.instance.show()
- self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
- self.volSave()
- self.hideVolTimer.start(3000)
-
- def volDown(self):
- if (eDVBVolumecontrol.getInstance().isMuted()):
- self.volMute()
- eDVBVolumecontrol.getInstance().volumeDown()
- self.volumeDialog.instance.show()
- self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
- self.volSave()
- self.hideVolTimer.start(3000)
-
- def volHide(self):
- self.volumeDialog.instance.hide()
-
- def volMute(self):
- eDVBVolumecontrol.getInstance().volumeToggleMute()
- self.volumeDialog.setValue(eDVBVolumecontrol.getInstance().getVolume())
-
- if (eDVBVolumecontrol.getInstance().isMuted()):
- self.muteDialog.instance.show()
- else:
- self.muteDialog.instance.hide()
-
class InfoBarDish:
def __init__(self):
self.dishDialog = self.session.instantiateDialog(Dish)
- self.onShown.append(self.dishDialog.instance.show)
+ self.onLayoutFinish.append(self.dishDialog.show)
class InfoBarShowHide:
""" InfoBar show/hide control, accepts toggleShow and hide actions, might start
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.onExecBegin.append(self.show)
- self.onClose.append(self.delHideTimer)
-
+ self.__state = self.STATE_SHOWN
+ self.__locked = 0
+
self.hideTimer = eTimer()
self.hideTimer.timeout.get().append(self.doTimerHide)
- self.hideTimer.start(5000)
+ self.hideTimer.start(5000, True)
- def delHideTimer(self):
- del self.hideTimer
+ self.onShow.append(self.__onShow)
+ self.onHide.append(self.__onHide)
- def hide(self):
- self.instance.hide()
-
- def show(self):
- self.state = self.STATE_SHOWN
- self.hideTimer.stop()
- self.hideTimer.start(5000)
+ 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:
+ idx = config.usage.infobar_timeout.index
+ if idx:
+ self.hideTimer.start(idx*1000, True)
+
+ def __onHide(self):
+ self.__state = self.STATE_HIDDEN
+
+ def doShow(self):
+ self.show()
+ self.startHideTimer()
def doTimerHide(self):
self.hideTimer.stop()
- if self.state == self.STATE_SHOWN:
- self.instance.hide()
- self.state = self.STATE_HIDDEN
+ if self.__state == self.STATE_SHOWN:
+ self.hide()
def toggleShow(self):
- if self.state == self.STATE_SHOWN:
- self.instance.hide()
- #pls check animation support, sorry
-# self.startHide()
+ if self.__state == self.STATE_SHOWN:
+ self.hide()
self.hideTimer.stop()
- self.state = self.STATE_HIDDEN
- elif self.state == self.STATE_HIDDEN:
- self.instance.show()
+ elif self.__state == self.STATE_HIDDEN:
self.show()
-
- 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
+
+ def lockShow(self):
+ self.__locked = self.__locked + 1
+ if self.execing:
+ self.show()
+ self.hideTimer.stop()
+
+ def unlockShow(self):
+ self.__locked = self.__locked - 1
+ if self.execing:
+ self.startHideTimer()
+
+# 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
class NumberZap(Screen):
def quit(self):
self.close(int(self["number"].getText()))
def keyNumberGlobal(self, number):
- self.Timer.start(3000) #reset timer
+ self.Timer.start(3000, True) #reset timer
self.field = self.field + str(number)
self["number"].setText(self.field)
if len(self.field) >= 4:
self.Timer = eTimer()
self.Timer.timeout.get().append(self.keyOK)
- self.Timer.start(3000)
-
-class InfoBarPowerKey:
- """ PowerKey stuff - handles the powerkey press and powerkey release actions"""
-
- def __init__(self):
- self.powerKeyTimer = eTimer()
- self.powerKeyTimer.timeout.get().append(self.powertimer)
- self["PowerKeyActions"] = HelpableActionMap(self, "PowerKeyActions",
- {
- "powerdown": self.powerdown,
- "powerup": self.powerup,
- "discreteStandby": (self.standby, "Go standby"),
- "discretePowerOff": (self.quit, "Go to deep standby"),
- })
-
- def powertimer(self):
- print "PowerOff - Now!"
- self.quit()
-
- def powerdown(self):
- self.standbyblocked = 0
- self.powerKeyTimer.start(3000)
-
- def powerup(self):
- self.powerKeyTimer.stop()
- if self.standbyblocked == 0:
- self.standbyblocked = 1
- self.standby()
-
- def standby(self):
- self.session.open(Standby, self)
-
- def quit(self):
- # halt
- quitMainloop(1)
+ self.Timer.start(3000, True)
class InfoBarNumberZap:
""" Handles an initial number for NumberZapping """
def __init__(self):
- self["NumberZapActions"] = NumberActionMap( [ "NumberZapActions"],
+ self["NumberActions"] = NumberActionMap( [ "NumberActions"],
{
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
def keyNumberGlobal(self, number):
# print "You pressed number " + str(number)
- self.session.openWithCallback(self.numberEntered, NumberZap, number)
+ if number == 0:
+ self.servicelist.recallPrevService()
+ else:
+ self.session.openWithCallback(self.numberEntered, NumberZap, number)
def numberEntered(self, retval):
# print self.servicelist
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)
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:
- self.session.nav.playService(service) #play service
if self.servicelist.getRoot() != bouquet: #already in correct bouquet?
- self.servicelist.setRoot(bouquet)
+ self.servicelist.clearPath()
+ if self.servicelist.bouquet_root != bouquet:
+ self.servicelist.enterPath(self.servicelist.bouquet_root)
+ self.servicelist.enterPath(bouquet)
self.servicelist.setCurrentSelection(service) #select the service in servicelist
+ self.servicelist.zap()
+
+config.misc.initialchannelselection = ConfigBoolean(default = True)
class InfoBarChannelSelection:
""" ChannelSelection - handles the channelSelection dialog and the initial
#instantiate forever
self.servicelist = self.session.instantiateDialog(ChannelSelection)
+ if config.misc.initialchannelselection.value:
+ self.onShown.append(self.firstRun)
+
self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
{
- "switchChannelUp": self.switchChannelUp,
- "switchChannelDown": self.switchChannelDown,
- "zapUp": (self.zapUp, _("next channel")),
- "zapDown": (self.zapDown, _("previous channel")),
+ "switchChannelUp": (self.switchChannelUp, _("open servicelist(up)")),
+ "switchChannelDown": (self.switchChannelDown, _("open servicelist(down)")),
+ "zapUp": (self.zapUp, _("previous channel")),
+ "zapDown": (self.zapDown, _("next channel")),
+ "historyBack": (self.historyBack, _("previous channel in history")),
+ "historyNext": (self.historyNext, _("next channel in history")),
+ "openServiceList": (self.openServiceList, _("open servicelist")),
})
-
- def switchChannelUp(self):
+
+ def showTvChannelList(self, zap=False):
+ self.servicelist.setModeTv()
+ if zap:
+ self.servicelist.zap()
+ self.session.execDialog(self.servicelist)
+
+ def showRadioChannelList(self, zap=False):
+ self.servicelist.setModeRadio()
+ if zap:
+ self.servicelist.zap()
+ self.session.execDialog(self.servicelist)
+
+ def firstRun(self):
+ self.onShown.remove(self.firstRun)
+ config.misc.initialchannelselection.value = False
+ config.misc.initialchannelselection.save()
+ self.switchChannelDown()
+
+ def historyBack(self):
+ self.servicelist.historyBack()
+
+ def historyNext(self):
+ self.servicelist.historyNext()
+
+ def switchChannelUp(self):
self.servicelist.moveUp()
self.session.execDialog(self.servicelist)
- def switchChannelDown(self):
+ def switchChannelDown(self):
self.servicelist.moveDown()
self.session.execDialog(self.servicelist)
- def zapUp(self):
- self.servicelist.moveUp()
+ def openServiceList(self):
+ self.session.execDialog(self.servicelist)
+
+ def zapUp(self):
+ if self.servicelist.inBouquet():
+ prev = self.servicelist.getCurrentSelection()
+ if prev:
+ prev = prev.toString()
+ while True:
+ if config.usage.quickzap_bouquet_change.value:
+ if self.servicelist.atBegin():
+ self.servicelist.prevBouquet()
+ self.servicelist.moveUp()
+ cur = self.servicelist.getCurrentSelection()
+ if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
+ break
+ else:
+ self.servicelist.moveUp()
self.servicelist.zap()
- self.instance.show()
- self.show()
- def zapDown(self):
- self.servicelist.moveDown()
+ def zapDown(self):
+ if self.servicelist.inBouquet():
+ prev = self.servicelist.getCurrentSelection()
+ if prev:
+ prev = prev.toString()
+ while True:
+ if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
+ self.servicelist.nextBouquet()
+ else:
+ self.servicelist.moveDown()
+ cur = self.servicelist.getCurrentSelection()
+ if not cur or (not (cur.flags & 64)) or cur.toString() == prev:
+ break
+ else:
+ self.servicelist.moveDown()
self.servicelist.zap()
- self.instance.show()
- self.show()
-
+
class InfoBarMenu:
""" Handles a menu action, to open the (main) menu """
def __init__(self):
self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions",
{
- "mainMenu": (self.mainMenu, "Enter 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 """
+ def __init__(self):
+ self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
+ {
+ "showEventInfo": (self.openEventView, _("show event details")),
+ })
+
+ def openEventView(self):
+ self.epglist = [ ]
+ service = self.session.nav.getCurrentService()
+ ref = self.session.nav.getCurrentlyPlayingServiceReference()
+ info = service.info()
+ ptr=info.getEvent(0)
+ if ptr:
+ self.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)
+
+ 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 InfoBarEPG:
""" EPG - Opens an EPG list when the showEPGList action fires """
def __init__(self):
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evUpdatedEventInfo: self.__evEventInfoChanged,
+ })
+
+ self.is_now_next = False
+ self.dlg_stack = [ ]
+ self.bouquetSel = None
+ self.eventView = None
self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
- "showEPGList": (self.showEPGList, _("show EPG...")),
+ "showEventInfo": (self.openEventView, _("show EPG...")),
+ "showSingleServiceEPG": (self.openSingleServiceEPG, _("show single service EPG...")),
+ "showInfobarOrEpgWhenInfobarAlreadyVisible": self.showEventInfoWhenNotVisible,
})
- def showEPGList(self):
+ 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?
+ self.servicelist.clearPath()
+ if self.servicelist.bouquet_root != self.epg_bouquet:
+ self.servicelist.enterPath(self.servicelist.bouquet_root)
+ self.servicelist.enterPath(self.epg_bouquet)
+ self.servicelist.setCurrentSelection(service) #select the service in servicelist
+ self.servicelist.zap()
+
+ def getBouquetServices(self, bouquet):
+ services = [ ]
+ servicelist = eServiceCenter.getInstance().list(bouquet)
+ if not servicelist is None:
+ while True:
+ service = servicelist.getNext()
+ if not service.valid(): #check if end of list
+ break
+ if service.flags & (eServiceReference.isDirectory | eServiceReference.isMarker): #ignore non playable services
+ continue
+ services.append(ServiceReference(service))
+ return services
+
+ def openBouquetEPG(self, bouquet, withCallback=True):
+ services = self.getBouquetServices(bouquet)
+ if len(services):
+ self.epg_bouquet = bouquet
+ if withCallback:
+ self.dlg_stack.append(self.session.openWithCallback(self.closed, EPGSelection, services, self.zapToService, None, self.changeBouquetCB))
+ else:
+ self.session.open(EPGSelection, services, self.zapToService, None, self.changeBouquetCB)
+
+ def changeBouquetCB(self, direction, epg):
+ if self.bouquetSel:
+ if direction > 0:
+ self.bouquetSel.down()
+ else:
+ self.bouquetSel.up()
+ bouquet = self.bouquetSel.getCurrent()
+ services = self.getBouquetServices(bouquet)
+ if len(services):
+ self.epg_bouquet = bouquet
+ epg.setServices(services)
+
+ def closed(self, ret=False):
+ closedScreen = self.dlg_stack.pop()
+ if self.bouquetSel and closedScreen == self.bouquetSel:
+ self.bouquetSel = None
+ elif self.eventView and closedScreen == self.eventView:
+ self.eventView = None
+ if ret:
+ dlgs=len(self.dlg_stack)
+ if dlgs > 0:
+ self.dlg_stack[dlgs-1].close(dlgs > 1)
+
+ def openMultiServiceEPG(self, withCallback=True):
+ bouquets = self.servicelist.getBouquetList()
+ if bouquets is None:
+ cnt = 0
+ else:
+ cnt = len(bouquets)
+ if cnt > 1: # show bouquet list
+ if withCallback:
+ self.bouquetSel = self.session.openWithCallback(self.closed, BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
+ self.dlg_stack.append(self.bouquetSel)
+ else:
+ self.bouquetSel = self.session.open(BouquetSelector, bouquets, self.openBouquetEPG, enableWrapAround=True)
+ elif cnt == 1:
+ self.openBouquetEPG(bouquets[0][1], withCallback)
+
+ def openSingleServiceEPG(self):
ref=self.session.nav.getCurrentlyPlayingServiceReference()
- ptr=eEPGCache.getInstance()
- if ptr.startTimeQuery(ref) != -1:
- self.session.open(EPGSelection, ref)
- else: # try to show now/next
- print 'no epg for service', ref.toString()
- try:
- self.epglist = [ ]
- service = self.session.nav.getCurrentService()
- info = service.info()
- ptr=info.getEvent(0)
- if ptr:
- self.epglist.append(ptr)
- ptr=info.getEvent(1)
+ self.session.open(EPGSelection, ref)
+
+ def openSimilarList(self, eventid, refstr):
+ self.session.open(EPGSelection, refstr, None, eventid)
+
+ def getNowNext(self):
+ self.epglist = [ ]
+ service = self.session.nav.getCurrentService()
+ info = service and service.info()
+ ptr = info and info.getEvent(0)
+ if ptr:
+ self.epglist.append(ptr)
+ ptr = info and info.getEvent(1)
+ if ptr:
+ self.epglist.append(ptr)
+
+ def __evEventInfoChanged(self):
+ if self.is_now_next and len(self.dlg_stack) == 1:
+ self.getNowNext()
+ assert self.eventView
+ if len(self.epglist):
+ self.eventView.setEvent(self.epglist[0])
+
+ def openEventView(self):
+ ref = self.session.nav.getCurrentlyPlayingServiceReference()
+ self.getNowNext()
+ if len(self.epglist) == 0:
+ self.is_now_next = False
+ epg = eEPGCache.getInstance()
+ ptr = ref and ref.valid() and epg.lookupEventTime(ref, -1)
+ if ptr:
+ self.epglist.append(ptr)
+ ptr = epg.lookupEventTime(ref, ptr.getBeginTime(), +1)
if ptr:
self.epglist.append(ptr)
- if len(self.epglist) > 0:
- self.session.open(EventView, self.epglist[0], ServiceReference(ref), self.eventViewCallback)
- except:
- pass
+ else:
+ self.is_now_next = True
+ if len(self.epglist) > 0:
+ 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:
+ print "no epg for the service avail.. so we show multiepg instead of eventinfo"
+ self.openMultiServiceEPG(False)
- def eventViewCallback(self, setEvent, val): #used for now/next displaying
+ 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"] = FrontendStatus(service_source = self.session.nav.getCurrentService)
+
class InfoBarEvent:
"""provides a current/next event info display"""
def __init__(self):
- self["Event_Now_StartTime"] = EventInfo(self.session.nav, EventInfo.Now_StartTime)
- self["Event_Next_StartTime"] = EventInfo(self.session.nav, EventInfo.Next_StartTime)
-
- self["Event_Now"] = EventInfo(self.session.nav, EventInfo.Now)
- self["Event_Next"] = EventInfo(self.session.nav, EventInfo.Next)
+ 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)
- self["Event_Now_Duration"] = EventInfo(self.session.nav, EventInfo.Now_Duration)
- self["Event_Next_Duration"] = EventInfo(self.session.nav, EventInfo.Next_Duration)
+ 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["ServiceName"] = ServiceName(self.session.nav)
+ 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_2X = (0, 2, 0, ">> 2x")
+ SEEK_STATE_FF_4X = (0, 4, 0, ">> 4x")
+ SEEK_STATE_FF_8X = (0, 8, 0, ">> 8x")
+ 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")
+
+ 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,
-class InfoBarPVR:
- """handles PVR specific actions like seeking, pause"""
- def __init__(self):
- self["PVRActions"] = HelpableActionMap(self, "InfobarPVRActions",
+ iPlayableService.evEOF: self.__evEOF,
+ iPlayableService.evSOF: self.__evSOF,
+ })
+
+ class InfoBarSeekActionMap(HelpableActionMap):
+ 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, actionmap,
{
- "pauseService": (self.pauseService, "pause"),
- "unPauseService": (self.unPauseService, "continue"),
+ "playpauseService": self.playpauseService,
+ "pauseService": (self.pauseService, _("pause")),
+ "unPauseService": (self.unPauseService, _("continue")),
+
+ "seekFwd": (self.seekFwd, _("skip forward")),
+ "seekFwdManual": (self.seekFwdManual, _("skip forward (enter time)")),
+ "seekBack": (self.seekBack, _("skip backward")),
+ "seekBackManual": (self.seekBackManual, _("skip backward (enter time)")),
- "seekFwd": (self.seekFwd, "skip forward"),
- "seekBack": (self.seekBack, "skip backward"),
- })
+ "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.seek_flag = True
+
+ 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 getSeek(self):
+ service = self.session.nav.getCurrentService()
+ if service is None:
+ return None
+
+ seek = service.seek()
+
+ if seek is None or not seek.isCurrentlySeekable():
+ return None
+
+ return seek
+
+ def isSeekable(self):
+ if self.getSeek() is None:
+ return False
+ return True
+
+ def __seekableStatusChanged(self):
+ print "seekable status changed!"
+ if not self.isSeekable():
+ self["SeekActions"].setEnabled(False)
+ print "not seekable, return to play"
+ self.setSeekState(self.SEEK_STATE_PLAY)
+ else:
+ self["SeekActions"].setEnabled(True)
+ print "seekable"
+
+ 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):
- self.session.nav.pause(1)
-
+ if self.seekstate == self.SEEK_STATE_PAUSE:
+ print "pause, but in fact unpause"
+ self.unPauseService()
+ else:
+ if self.seekstate == self.SEEK_STATE_PLAY:
+ print "yes, playing."
+ else:
+ print "no", self.seekstate
+ print "pause"
+ self.setSeekState(self.SEEK_STATE_PAUSE);
+
def unPauseService(self):
- self.session.nav.pause(0)
-
- def doSeek(self, dir, seektime):
+ 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 = service.seek()
+
+ seekable = self.getSeek()
if seekable is None:
return
- seekable.seekRelative(dir, 90 * seektime)
+
+ seekable.seekTo(90 * seektime)
def seekFwd(self):
- self.doSeek(+1, 60000)
-
+ 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_32X,
+ self.SEEK_STATE_FF_32X: 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_16X: self.SEEK_STATE_PLAY,
+ self.SEEK_STATE_BACK_32X: self.SEEK_STATE_BACK_16X,
+ self.SEEK_STATE_BACK_64X: self.SEEK_STATE_BACK_32X,
+ 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])
+
def seekBack(self):
- self.doSeek(-1, 60000)
+ lookup = {
+ self.SEEK_STATE_PLAY: self.SEEK_STATE_BACK_16X,
+ 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_32X: self.SEEK_STATE_FF_8X,
+ self.SEEK_STATE_FF_64X: self.SEEK_STATE_FF_32X,
+ self.SEEK_STATE_FF_128X: self.SEEK_STATE_FF_64X,
+ self.SEEK_STATE_BACK_16X: self.SEEK_STATE_BACK_32X,
+ self.SEEK_STATE_BACK_32X: 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_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 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 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 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_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_EOF)
+
+ def __evSOF(self):
+ self.setSeekState(self.SEEK_STATE_PLAY)
+ self.doSeek(0)
+
+ def seekRelative(self, 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()
+ if seekable is not None:
+ seekable.seekTo(abs)
+
+from Screens.PVRState import PVRState, TimeshiftState
+
+class InfoBarPVRState:
+ def __init__(self, screen=PVRState):
+ self.onPlayStateChanged.append(self.__playStateChanged)
+ self.pvrStateDialog = self.session.instantiateDialog(screen)
+ self.onShow.append(self._mayShow)
+ self.onHide.append(self.pvrStateDialog.hide)
+
+ 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()
+
+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.
+ # 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",
+ {
+ "movieList": (self.showMovies, _("movie list")),
+ "up": (self.showMovies, _("movie list")),
+ "down": (self.showMovies, _("movie list"))
+ })
+
+# InfoBarTimeshift requires InfoBarSeek, instantiated BEFORE!
+
+# Hrmf.
+#
+# Timeshift works the following way:
+# demux0 demux1 "TimeshiftActions" "TimeshiftActivateActions" "SeekActions"
+# - normal playback TUNER unused PLAY enable disable disable
+# - 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
+# - user backwards FILE record BACK # !! enable disable enable
+#
+
+# in other words:
+# - when a service is playing, pressing the "timeshiftStart" button ("yellow") enables recording ("enables timeshift"),
+# freezes the picture (to indicate timeshift), sets timeshiftMode ("activates timeshift")
+# now, the service becomes seekable, so "SeekActions" are enabled, "TimeshiftEnableActions" are disabled.
+# - the user can now PVR around
+# - if it hits the end, the service goes into live mode ("deactivates timeshift", it's of course still "enabled")
+# the service looses it's "seekable" state. It can still be paused, but just to activate timeshift right
+# after!
+# the seek actions will be disabled, but the timeshiftActivateActions will be enabled
+# - if the user rewinds, or press pause, timeshift will be activated again
+
+# note that a timeshift can be enabled ("recording") and
+# activated (currently time-shifting).
+
+class InfoBarTimeshift:
+ def __init__(self):
+ self["TimeshiftActions"] = HelpableActionMap(self, "InfobarTimeshiftActions",
+ {
+ "timeshiftStart": (self.startTimeshift, _("start timeshift")), # the "yellow key"
+ "timeshiftStop": (self.stopTimeshift, _("stop timeshift")) # currently undefined :), probably 'TV'
+ }, prio=1)
+ self["TimeshiftActivateActions"] = ActionMap(["InfobarTimeshiftActivateActions"],
+ {
+ "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_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()
+
+ def startTimeshift(self):
+ 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
+
+ if self.timeshift_enabled:
+ print "hu, timeshift already enabled?"
+ else:
+ if not ts.startTimeshift():
+ 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.activateTimeshiftEnd(False)
+
+ # enable the "TimeshiftEnableActions", which will override
+ # the startTimeshift actions
+ self.__seekableStatusChanged()
+ else:
+ print "timeshift failed"
+
+ def stopTimeshift(self):
+ if not self.timeshift_enabled:
+ return 0
+ print "disable timeshift"
+ ts = self.getTimeshift()
+ if ts is None:
+ return 0
+ self.session.openWithCallback(self.stopTimeshiftConfirmed, MessageBox, _("Stop Timeshift?"), MessageBox.TYPE_YESNO)
+
+ def stopTimeshiftConfirmed(self, confirmed):
+ if not confirmed:
+ return
+
+ ts = self.getTimeshift()
+ if ts is None:
+ return
+
+ ts.stopTimeshift()
+ self.timeshift_enabled = 0
+
+ # disable actions
+ self.__seekableStatusChanged()
+
+ # activates timeshift, and seeks to (almost) the end
+ 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:
+ 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):
+ 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
+ if not self.isSeekable() and self.timeshift_enabled:
+ enabled = True
+
+ print "timeshift activate:", enabled
+ self["TimeshiftActivateActions"].setEnabled(enabled)
+
+ def __serviceStarted(self):
+ self.timeshift_enabled = False
+ self.__seekableStatusChanged()
+
+from Screens.PiPSetup import PiPSetup
+
+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):
+ key = x
+ break
+
+ 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" ]
+ self.extensionKeys = {}
+ for x in self.list:
+ if x[0] == self.EXTENSION_SINGLE:
+ self.updateExtension(x[1], x[2])
+ else:
+ for y in x[1]():
+ self.updateExtension(y[0], y[1])
+
+
+ def showExtensionSelection(self):
+ self.updateExtensions()
+ extensionsList = self.extensionsList[:]
+ keys = []
+ list = []
+ for x in self.availableKeys:
+ if self.extensionKeys.has_key(x):
+ entry = self.extensionKeys[x]
+ extension = self.extensionsList[entry]
+ if extension[2]():
+ name = str(extension[0]())
+ list.append((extension[0](), extension))
+ keys.append(x)
+ extensionsList.remove(extension)
+ else:
+ extensionsList.remove(extension)
+ for x in extensionsList:
+ list.append((x[0](), x))
+ keys += [""] * len(extensionsList)
+ self.session.openWithCallback(self.extensionCallback, ChoiceBox, title=_("Please choose an extension..."), list = list, keys = keys)
+
+ def extensionCallback(self, answer):
+ if answer is not None:
+ answer[1][1]()
+
+from Tools.BoundFunction import boundFunction
+
+# depends on InfoBarExtensions
+from Components.PluginComponent import plugins
+
+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):
+ list.append(((boundFunction(self.getPluginName, p.name), boundFunction(self.runPlugin, p), lambda: True), None))
+ return list
+
+ def runPlugin(self, plugin):
+ plugin(session = self.session, servicelist = self.servicelist)
+
+# depends on InfoBarExtensions
+class InfoBarSleepTimer:
+ def __init__(self):
+ self.addExtension((self.getSleepTimerName, self.showSleepTimerSetup, self.available), "1")
+
+ def available(self):
+ return True
+
+ def getSleepTimerName(self):
+ return _("Sleep Timer")
+
+ 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), "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.pip.servicePath = self.servicelist.getCurrentServicePath()
+ else:
+ 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:
+ servicepath = self.servicelist.getCurrentServicePath()
+ ref=servicepath[len(servicepath)-1]
+ pipref=self.session.pip.getCurrentService()
+ self.session.pip.playService(swapservice)
+ self.servicelist.setCurrentServicePath(self.session.pip.servicePath)
+ if pipref.toString() != ref.toString(): # is a subservice ?
+ 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)
+
+from RecordTimer import parseEvent
class InfoBarInstantRecord:
"""Instant Record - handles the instantRecord action in order to
def __init__(self):
self["InstantRecordActions"] = HelpableActionMap(self, "InfobarInstantRecord",
{
- "instantRecord": (self.instantRecord, "Instant Record..."),
+ "instantRecord": (self.instantRecord, _("Instant Record...")),
})
- self.recording = None
-
+ self.recording = []
self["BlinkingPoint"] = BlinkingPixmapConditional()
- self.onShown.append(self["BlinkingPoint"].hideWidget)
+ self["BlinkingPoint"].hide()
self["BlinkingPoint"].setConnect(self.session.nav.RecordTimer.isRecording)
-
- def stopCurrentRecording(self):
- self.session.nav.RecordTimer.removeEntry(self.recording)
- self.recording = None
-
- def startInstantRecording(self):
+
+ 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
- epg = None
+ event = None
try:
service = self.session.nav.getCurrentService()
- info = service.info()
- ev = info.getEvent(0)
- epg = ev
+ epg = eEPGCache.getInstance()
+ event = epg.lookupEventTime(serviceref, -1, 0)
+ if event is None:
+ info = service.info()
+ ev = info.getEvent(0)
+ event = ev
except:
pass
-
- # fix me, description.
- self.recording = self.session.nav.recordWithTimer(time.time(), time.time() + 3600, serviceref, epg, "instant record")
- self.recording.dontSave = True
-
+
+ begin = time()
+ end = time() + 3600 * 10
+ name = "instant record"
+ description = ""
+ eventid = None
+
+ if event is not None:
+ curEvent = parseEvent(event)
+ name = curEvent[2]
+ description = curEvent[3]
+ eventid = curEvent[4]
+ if limitEvent:
+ end = curEvent[1]
+ 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):
- if self.recording != None:
- if self.recording.isRunning():
- return True
+ print "self.recording:", self.recording
+ if len(self.recording) > 0:
+ for x in self.recording:
+ if x.isRunning():
+ return True
return False
def recordQuestionCallback(self, answer):
- if answer == False:
+ print "pre:\n", self.recording
+
+ if answer is None or answer[1] == "no":
return
-
- if self.isInstantRecordRunning():
- self.stopCurrentRecording()
- else:
- self.startInstantRecording()
+ list = []
+ recording = self.recording[:]
+ for x in recording:
+ if not x in self.session.nav.RecordTimer.timer_list:
+ self.recording.remove(x)
+ elif x.dontSave and x.isRunning():
+ list.append((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)
+ elif answer[1] in ( "indefinitely" , "manualduration", "manualendtime", "event"):
+ self.startInstantRecording(limitEvent = answer[1] in ("event", "manualendtime") or False)
+ if answer[1] == "manualduration":
+ 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
+ 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])
def instantRecord(self):
try:
- stat = os.stat("/hdd/movies")
+ stat = os_stat(resolveFilename(SCOPE_HDD))
except:
- self.session.open(MessageBox, "No HDD found!")
+ self.session.open(MessageBox, _("No HDD found or HDD not initialized!"), MessageBox.TYPE_ERROR)
return
-
+
if self.isInstantRecordRunning():
- self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?"))
+ 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, MessageBox, _("Start recording?"))
+ 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 Screens.AudioSelection import AudioSelection
+from Tools.ISO639 import LanguageCodes
class InfoBarAudioSelection:
def __init__(self):
self["AudioSelectionAction"] = HelpableActionMap(self, "InfobarAudioSelectionActions",
{
- "audioSelection": (self.audioSelection, "Audio Options..."),
+ "audioSelection": (self.audioSelection, _("Audio Options...")),
})
def audioSelection(self):
service = self.session.nav.getCurrentService()
- audio = service.audioTracks()
- n = audio.getNumberOfTracks()
+ audio = service and service.audioTracks()
+ self.audioTracks = audio
+ n = audio and audio.getNumberOfTracks() or 0
+ keys = [ "red", "", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] + [""]*n
+ tlist = []
+ print "tlist:", tlist
if n > 0:
- self.session.open(AudioSelection, audio)
+ self.audioChannel = service.audioChannel()
+
+ for x in range(n):
+ i = audio.getTrackInfo(x)
+ language = i.getLanguage()
+ description = i.getDescription()
+
+ 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]))
+
+ selection = 2
+ for x in tlist:
+ if x[1] != selectedAudio:
+ selection += 1
+ else:
+ break
-from Screens.SubserviceSelection import SubserviceSelection
+ 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)
+ else:
+ del self.audioTracks
+
+ 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)
+ else:
+ del self.audioChannel
+ if self.session.nav.getCurrentService().audioTracks().getNumberOfTracks() > audio[1]:
+ self.audioTracks.selectTrack(audio[1])
+ else:
+ del self.audioChannel
+ del self.audioTracks
+
+ def modeSelected(self, mode):
+ if mode is not None:
+ self.audioChannel.selectChannel(mode[1])
+ del self.audioChannel
class InfoBarSubserviceSelection:
def __init__(self):
self["SubserviceSelectionAction"] = HelpableActionMap(self, "InfobarSubserviceSelectionActions",
{
- "subserviceSelection": (self.subserviceSelection, "Subservice list..."),
+ "subserviceSelection": (self.subserviceSelection, _("Subservice list...")),
})
+ self["SubserviceQuickzapAction"] = HelpableActionMap(self, "InfobarSubserviceQuickzapActions",
+ {
+ "nextSubservice": (self.nextSubservice, _("Switch to next subservice")),
+ "prevSubservice": (self.prevSubservice, _("Switch to previous subservice"))
+ }, -1)
+ self["SubserviceQuickzapAction"].setEnabled(False)
+
+ 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()
+ subservices = service and service.subServices()
+ if not subservices or subservices.getNumberOfSubservices() == 0:
+ self["SubserviceQuickzapAction"].setEnabled(False)
+
+ def nextSubservice(self):
+ self.changeSubservice(+1)
+
+ def prevSubservice(self):
+ self.changeSubservice(-1)
+
+ def changeSubservice(self, direction):
+ service = self.session.nav.getCurrentService()
+ subservices = service and service.subServices()
+ n = subservices and subservices.getNumberOfSubservices()
+ 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
+ if selection != -1:
+ selection += direction
+ if selection >= n:
+ selection=0
+ elif selection < 0:
+ selection=n-1
+ newservice = subservices.getSubservice(selection)
+ if newservice.valid():
+ del subservices
+ del service
+ self.session.nav.playService(newservice)
+
def subserviceSelection(self):
service = self.session.nav.getCurrentService()
- subservices = service.subServices()
- n = subservices.getNumberOfSubservices()
- if n > 0:
- self.session.openWithCallback(self.subserviceSelected, SubserviceSelection, subservices)
+ subservices = service and service.subServices()
+ self.bouquets = self.servicelist.getBouquetList()
+ n = subservices and subservices.getNumberOfSubservices()
+ selection = 0
+ if n and n > 0:
+ ref = self.session.nav.getCurrentlyPlayingServiceReference()
+ tlist = []
+ for x in range(n):
+ i = subservices.getSubservice(x)
+ if i.toString() == ref.toString():
+ selection = x
+ tlist.append((i.getName(), i))
+
+ 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, keys = keys)
def subserviceSelected(self, service):
+ del self.bouquets
if not service is None:
- self.session.nav.playService(service)
+ if isinstance(service[1], str):
+ if service[1] == "quickzap":
+ from Screens.SubservicesQuickzap import SubservicesQuickzap
+ self.session.open(SubservicesQuickzap, service[2])
+ else:
+ self["SubserviceQuickzapAction"].setEnabled(True)
+ 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["DolbyActive"] = PixmapConditional()
- # TODO: get the info from c++ somehow
- self["DolbyActive"].setConnect(lambda: False)
-
- self["CryptActive"] = PixmapConditional()
- # TODO: get the info from c++ somehow
- self["CryptActive"].setConnect(lambda: False)
-
- self["FormatActive"] = PixmapConditional()
- # TODO: get the info from c++ somehow
- self["FormatActive"].setConnect(lambda: False)
-
- self["ButtonRed"] = Pixmap()
- self["ButtonRedText"] = Label(_("Record"))
- self["ButtonGreen"] = PixmapConditional()
- self["ButtonGreen"].setConnect(lambda: self.session.nav.getCurrentService().subServices().getNumberOfSubservices() > 0)
-# self["ButtonGreenText"] = Label(text = _("Subservices"))
- self["ButtonGreenText"] = LabelConditional(text = _("Subservices"), withTimer = True)
- self["ButtonGreenText"].setConnect(lambda: self.session.nav.getCurrentService().subServices().getNumberOfSubservices() > 0)
-# self["ButtonGreenText"].hide()
-# self["ButtonGreen"].hidePixmap()
-# self["ButtonYellow"] = Pixmap()
-# self["ButtonBlue"] = Pixmap()
+ self["NimA"] = Pixmap()
+ self["NimB"] = Pixmap()
+ self["NimA_Active"] = Pixmap()
+ self["NimB_Active"] = Pixmap()
+
+ self["RecordingPossible"] = Boolean(fixed=harddiskmanager.HDDCount() > 0)
+ self["TimeshiftPossible"] = self["RecordingPossible"]
+ 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)
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:]
- print "open",n
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:])
+ dlg = self.session.openWithCallback(cb, n[1], *n[2], **n[3])
else:
- self.session.open(*n[1:])
+ 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):
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evEnd: self.serviceHasEnded
+ })
+
+ def serviceHasEnded(self):
+ print "service end!"
+
+ try:
+ self.setSeekState(self.SEEK_STATE_PLAY)
+ except:
+ pass
+
+class InfoBarCueSheetSupport:
+ CUT_TYPE_IN = 0
+ CUT_TYPE_OUT = 1
+ CUT_TYPE_MARK = 2
+ CUT_TYPE_LAST = 3
+
+ ENABLE_RESUME_SUPPORT = False
+
+ def __init__(self, actionmap = "InfobarCueSheetActions"):
+ 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)
+
+ self.cut_list = [ ]
+ self.is_closing = False
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evStart: self.__serviceStarted,
+ })
+
+ def __serviceStarted(self):
+ if self.is_closing:
+ 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)
+
+ def playLastCB(self, answer):
+ if answer == True:
+ 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()
+ if service is None:
+ return None
+ return service.seek()
+
+ def cueGetCurrentPosition(self):
+ seek = self.__getSeekable()
+ if seek is None:
+ return None
+ r = seek.getPlayPosition()
+ if r[0]:
+ return None
+ return long(r[1])
+
+ def jumpPreviousNextMark(self, cmp, alternative=None):
+ current_pos = self.cueGetCurrentPosition()
+ if current_pos is None:
+ return
+ mark = self.getNearestCutPoint(current_pos, cmp=cmp)
+ if mark is not None:
+ pts = mark[0]
+ elif alternative is not None:
+ pts = alternative
+ else:
+ return
+
+ seekable = self.__getSeekable()
+ if seekable is not None:
+ seekable.seekTo(pts)
+
+ 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)
+
+ def jumpNextMark(self):
+ self.jumpPreviousNextMark(lambda x: x)
+
+ def getNearestCutPoint(self, pts, cmp=abs):
+ # can be optimized
+ nearest = None
+ 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
+ return nearest
+
+ def toggleMark(self, onlyremove=False, onlyadd=False, tolerance=5*90000, onlyreturn=False):
+ current_pos = self.cueGetCurrentPosition()
+ 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
+ if not onlyadd:
+ 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):
+ 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()
+ if service is None:
+ return None
+ return service.cueSheet()
+
+ def uploadCuesheet(self):
+ cue = self.__getCuesheet()
+
+ if cue is None:
+ print "upload failed, no cuesheet interface"
+ return
+ cue.setCutList(self.cut_list)
+
+ def downloadCuesheet(self):
+ cue = self.__getCuesheet()
+
+ if cue is None:
+ print "download failed, no cuesheet interface"
+ self.cut_list = [ ]
+ else:
+ self.cut_list = cue.getCutList()
+
+class InfoBarSummary(Screen):
+ skin = """
+ <screen position="0,0" size="132,64">
+ <widget source="CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
+ <convert type="ClockToText">WithSeconds</convert>
+ </widget>
+ <widget source="CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
+ <convert type="ServiceName">Name</convert>
+ </widget>
+ </screen>"""
+
+ def __init__(self, session, parent):
+ Screen.__init__(self, session)
+ self["CurrentService"] = CurrentService(self.session.nav)
+ self["CurrentTime"] = Clock()
+
+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",
+ {
+ "startTeletext": (self.startTeletext, _("View teletext..."))
+ })
+ else:
+ print "no teletext plugin found!"
+
+ def startTeletext(self):
+ self.teletext_plugin(session=self.session, service=self.session.nav.getCurrentService())
+
+class InfoBarSubtitleSupport(object):
+ def __init__(self):
+ object.__init__(self)
+ self.subtitle_window = self.session.instantiateDialog(SubtitleDisplay)
+ self.__subtitles_enabled = False
+
+ self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
+ {
+ iPlayableService.evEnd: self.__serviceStopped,
+ iPlayableService.evUpdatedInfo: self.__updatedInfo
+ })
+ self.cached_subtitle_checked = False
+ self.__selected_subtitle = None
+
+ def __serviceStopped(self):
+ self.subtitle_window.hide()
+ self.__subtitles_enabled = False
+ 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 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
+ else:
+ if subtitle:
+ subtitle.disableSubtitles(self.subtitle_window.instance)
+ self.__subtitles_enabled = False
+ self.subtitle_window.hide()
+
+ def setSelectedSubtitle(self, 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")