-from Screen import Screen
+from ChannelSelection import ChannelSelection, BouquetSelector
+
from Components.ActionMap import ActionMap, HelpableActionMap
from Components.ActionMap import NumberActionMap
+from Components.BlinkingPixmap import BlinkingPixmapConditional
+from Components.Clock import Clock
+from Components.EventInfo import EventInfo, EventInfoProgress
+from Components.Harddisk import harddiskmanager
+from Components.Input import Input
from Components.Label import *
-from Components.ProgressBar import *
-from Components.config import configfile, configsequencearg
-from Components.config import config, configElement, ConfigSubsection, configSequence
-from ChannelSelection import ChannelSelection, BouquetSelector
-
from Components.Pixmap import Pixmap, PixmapConditional
-from Components.BlinkingPixmap import BlinkingPixmapConditional
+from Components.PluginComponent import plugins
+from Components.ProgressBar import *
+from Components.ServiceEventTracker import ServiceEventTracker
from Components.ServiceName import ServiceName
-from Components.EventInfo import EventInfo, EventInfoProgress
+from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean
+from Components.config import configfile, configsequencearg
-from ServiceReference import ServiceReference
from EpgSelection import EPGSelection
+from Plugins.Plugin import PluginDescriptor
-from Screens.MessageBox import MessageBox
+from Screen import Screen
+from Screens.ChoiceBox import ChoiceBox
from Screens.Dish import Dish
-from Screens.Standby import Standby
-from Screens.EventView import EventViewEPGSelect
+from Screens.EventView import EventViewEPGSelect, EventViewSimple
+from Screens.InputBox import InputBox
+from Screens.MessageBox import MessageBox
from Screens.MinuteInput import MinuteInput
-from Components.Harddisk import harddiskmanager
-
-from Components.ServiceEventTracker import ServiceEventTracker
+from Screens.Standby import Standby
+from ServiceReference import ServiceReference
from Tools import Notifications
from Tools.Directories import *
self.servicelist.setCurrentSelection(service) #select the service in servicelist
self.servicelist.zap()
+config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1);
+
class InfoBarChannelSelection:
""" ChannelSelection - handles the channelSelection dialog and the initial
channelChange actions which open the channelSelection dialog """
def __init__(self):
#instantiate forever
self.servicelist = self.session.instantiateDialog(ChannelSelection)
+
+ if config.misc.initialchannelselection.value == 1:
+ self.onShown.append(self.firstRun)
self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
{
"historyNext": (self.historyNext, _("next channel in history"))
})
+ def firstRun(self):
+ self.onShown.remove(self.firstRun)
+ config.misc.initialchannelselection.value = 0
+ config.misc.initialchannelselection.save()
+ self.switchChannelDown()
+
def historyBack(self):
self.servicelist.historyBack()
assert menu.tagName == "menu", "root element in menu must be 'menu'!"
self.session.open(MainMenu, menu, menu.childNodes)
+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):
iPlayableService.evEOF: self.__evEOF,
iPlayableService.evSOF: self.__evSOF,
})
- self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions",
+
+ class InfoBarSeekActionMap(HelpableActionMap):
+ def __init__(self, screen, *args, **kwargs):
+ HelpableActionMap.__init__(self, screen, *args, **kwargs)
+ self.screen = screen
+
+ def action(self, contexts, action):
+ if action[:5] == "seek:":
+ time = int(action[5:])
+ self.screen.seekRelative(time * 90000)
+ return 1
+ else:
+ return HelpableActionMap.action(self, contexts, action)
+
+ self["SeekActions"] = InfoBarSeekActionMap(self, "InfobarSeekActions",
{
"pauseService": (self.pauseService, "pause"),
"unPauseService": (self.unPauseService, "continue"),
self.SEEK_STATE_SM_EIGHTH: self.SEEK_STATE_PAUSE
}
self.setSeekState(lookup[self.seekstate])
+
+ if self.seekstate == self.SEEK_STATE_PAUSE:
+ seekable = self.getSeek()
+ if seekable is not None:
+ seekable.seekRelative(-1, 3)
def fwdTimerFire(self):
print "Display seek fwd"
if self.seekstate != self.SEEK_STATE_PLAY:
self.setSeekState(self.SEEK_STATE_PAUSE)
# HACK
- self.getSeek().seekRelative(1, -90000)
+ #self.getSeek().seekRelative(1, -90000)
self.setSeekState(self.SEEK_STATE_PLAY)
else:
self.setSeekState(self.SEEK_STATE_PAUSE)
def seekRelative(self, diff):
seekable = self.getSeek()
if seekable is not None:
- seekable.seekRelative(0, diff)
+ seekable.seekRelative(1, diff)
-from Screens.PVRState import PVRState
+from Screens.PVRState import PVRState, TimeshiftState
class InfoBarPVRState:
- def __init__(self):
+ def __init__(self, screen=PVRState):
self.onPlayStateChanged.append(self.__playStateChanged)
- self.pvrStateDialog = self.session.instantiateDialog(PVRState)
+ self.pvrStateDialog = self.session.instantiateDialog(screen)
self.onShow.append(self.__mayShow)
self.onHide.append(self.pvrStateDialog.hide)
def __mayShow(self):
- if self.seekstate != self.SEEK_STATE_PLAY:
+ if self.seekstate != self.SEEK_STATE_PLAY and self.execing:
self.pvrStateDialog.show()
def __playStateChanged(self, state):
self.pvrStateDialog["state"].setText(playstateString)
self.__mayShow()
+class InfoBarTimeshiftState(InfoBarPVRState):
+ def __init__(self):
+ InfoBarPVRState.__init__(self, screen=TimeshiftState)
+
+
class InfoBarShowMovies:
# i don't really like this class.
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
+ iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged
})
print "hu, timeshift already enabled?"
else:
if not ts.startTimeshift():
+ import time
self.timeshift_enabled = 1
+ self.pvrStateDialog["timeshift"].setRelative(time.time())
# PAUSE.
self.setSeekState(self.SEEK_STATE_PAUSE)
print "timeshift activate:", enabled
self["TimeshiftActivateActions"].setEnabled(enabled)
+ def __serviceStarted(self):
+ self.timeshift_enabled = False
+ self.__seekableStatusChanged()
+
from RecordTimer import parseEvent
class InfoBarInstantRecord:
})
self.recording = None
self["BlinkingPoint"] = BlinkingPixmapConditional()
- self.onLayoutFinish.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 startInstantRecording(self, limitEvent = False):
serviceref = self.session.nav.getCurrentlyPlayingServiceReference()
# try to get event info
event = None
try:
service = self.session.nav.getCurrentService()
- info = service.info()
- ev = info.getEvent(0)
- event = 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
+
+ begin = time.time()
+ end = time.time() + 3600 * 10
+ name = "instant record"
+ description = ""
+ eventid = None
if event is not None:
- data = parseEvent(event)
- begin = time.time()
- end = begin + 3600 * 10
-
- data = (begin, end, data[2], data[3], data[4])
+ curEvent = parseEvent(event)
+ name = curEvent[2]
+ description = curEvent[3]
+ eventid = curEvent[4]
+ if limitEvent:
+ end = curEvent[1]
else:
- data = (time.time(), time.time() + 3600 * 10, "instant record", "", None)
+ if limitEvent:
+ self.session.open(MessageBox, _("No event info found, recording indefinitely."), MessageBox.TYPE_INFO)
+
+ data = (begin, end, name, description, eventid)
- # fix me, description.
self.recording = self.session.nav.recordWithTimer(serviceref, *data)
self.recording.dontSave = True
return False
def recordQuestionCallback(self, answer):
- if answer == False:
+ if answer is None or answer[1] == "no":
return
if self.isInstantRecordRunning():
- self.stopCurrentRecording()
+ if answer[1] == "manualduration":
+ self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
+ else:
+ self.stopCurrentRecording()
else:
- self.startInstantRecording()
+ limitEvent = False
+ if answer[1] == "event":
+ limitEvent = True
+ if answer[1] == "manualduration":
+ self.session.openWithCallback(self.inputCallback, InputBox, title=_("How many minutes do you want to record?"), text="5", maxSize=False, type=Input.NUMBER)
+ self.startInstantRecording(limitEvent = limitEvent)
+
+ def inputCallback(self, value):
+ if value is not None:
+ print "stopping recording after", int(value), "minutes."
+ if self.recording is not None:
+ self.recording.end = time.time() + 60 * int(value)
+ self.session.nav.RecordTimer.timeChanged(self.recording)
def instantRecord(self):
try:
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"), "yes"), (_("enter recording duration"), "manualduration"), (_("do nothing"), "no")])
+# self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Do you want to stop the current\n(instant) recording?"))
else:
- self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?"))
+ self.session.openWithCallback(self.recordQuestionCallback, ChoiceBox, title=_("Start recording?"), list=[(_("record indefinitely"), "indefinitely"), (_("stop after current event"), "event"), (_("enter recording duration"), "manualduration"),(_("don't record"), "no")])
+ #self.session.openWithCallback(self.recordQuestionCallback, MessageBox, _("Start recording?"))
from Screens.AudioSelection import AudioSelection
self.session.nav.event.append(self.gotServiceEvent) # we like to get service events
def hideSubServiceIndication(self):
- self["ButtonGreen"].hideWidget()
+ self["ButtonGreen"].hide()
self["ButtonGreenText"].hide()
def showSubServiceIndication(self):
- self["ButtonGreen"].showWidget()
+ self["ButtonGreen"].show()
self["ButtonGreenText"].show()
def checkFormat(self, service):
if info is not None:
aspect = info.getInfo(iServiceInformation.sAspect)
if aspect in [ 3, 4, 7, 8, 0xB, 0xC, 0xF, 0x10 ]:
- self["FormatActive"].showWidget()
+ self["FormatActive"].show()
else:
- self["FormatActive"].hideWidget()
+ self["FormatActive"].hide()
def checkSubservices(self, service):
if service.subServices().getNumberOfSubservices() > 0:
dolby = True
break
if dolby:
- self["DolbyActive"].showWidget()
+ self["DolbyActive"].show()
else:
- self["DolbyActive"].hideWidget()
+ self["DolbyActive"].hide()
def checkCrypted(self, service):
info = service.info()
if info is not None:
if info.getInfo(iServiceInformation.sIsCrypted) > 0:
- self["CryptActive"].showWidget()
+ self["CryptActive"].show()
else:
- self["CryptActive"].hideWidget()
+ self["CryptActive"].hide()
def gotServiceEvent(self, ev):
service = self.session.nav.getCurrentService()
self.checkDolby(service)
elif ev == iPlayableService.evEnd:
self.hideSubServiceIndication()
- self["CryptActive"].hideWidget()
- self["DolbyActive"].hideWidget()
- self["FormatActive"].hideWidget()
+ self["CryptActive"].hide()
+ self["DolbyActive"].hide()
+ self["FormatActive"].hide()
class InfoBarNotifications:
def __init__(self):
return None
return service.seek()
- def __getCurrentPosition(self):
+ def cueGetCurrentPosition(self):
seek = self.__getSeekable()
if seek is None:
return None
return long(r[1])
def jumpPreviousNextMark(self, cmp, alternative=None):
- current_pos = self.__getCurrentPosition()
+ current_pos = self.cueGetCurrentPosition()
if current_pos is None:
return
mark = self.getNearestCutPoint(current_pos, cmp=cmp)
seekable.seekTo(pts)
def jumpPreviousMark(self):
- print "jumpPreviousMark"
# 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):
- print "jumpNextMark"
self.jumpPreviousNextMark(lambda x: x)
def getNearestCutPoint(self, pts, cmp=abs):
nearest = cp
return nearest
- def toggleMark(self):
- print "toggleMark"
- current_pos = self.__getCurrentPosition()
+ 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
- print "current position: ", current_pos
-
nearest_cutpoint = self.getNearestCutPoint(current_pos)
- print "nearest_cutpoint: ", nearest_cutpoint
- if nearest_cutpoint is not None and abs(nearest_cutpoint[0] - current_pos) < 5*90000:
- self.removeMark(self, *nearest_cutpoint)
- else:
- self.addMark(self, current_pos, self.CUT_TYPE_MARK)
+ 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, where, type):
- bisect.insort(self.cut_list, (current_pos, self.CUT_TYPE_MARK))
+ def addMark(self, point):
+ bisect.insort(self.cut_list, point)
self.uploadCuesheet()
- def removeMark(self, where, type):
- self.cut_list.remove(nearest_cutpoint)
+ def removeMark(self, point):
+ self.cut_list.remove(point)
self.uploadCuesheet()
def __getCuesheet(self):
return
self.cut_list = cue.getCutList()
- print "cuts:", self.cut_list
+class InfoBarSummary(Screen):
+ skin = """
+ <screen position="0,0" size="132,64">
+ <widget name="Clock" position="50,46" size="82,18" font="Regular;16" />
+ <widget name="CurrentService" position="0,4" size="132,42" font="Regular;18" />
+ </screen>"""
+
+ def __init__(self, session, parent):
+ Screen.__init__(self, session)
+ self["CurrentService"] = ServiceName(self.session.nav)
+ self["Clock"] = 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())
git.cweiske.de / enigma2.git / blobdiff