def __init__(self, event, Ref, callback=None, similarEPGCB=None, parent=None):
self.similarEPGCB = similarEPGCB
self.cbFunc = callback
self.currentService=Ref
self.isRecording = (not Ref.ref.flags & eServiceReference.isGroup) and Ref.ref.getPath()
self.event = event
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["epg_eventname"] = ScrollLabel()
self["epg_description"] = ScrollLabel()
self["FullDescription"] = ScrollLabel()
self["datetime"] = Label()
self["channel"] = Label()
self["duration"] = Label()
self["now"] = Label()
self["next"] = Label()
self["key_red"] = StaticText("")
if similarEPGCB is not None:
self.SimilarBroadcastTimer = eTimer()
self.SimilarBroadcastTimer.callback.append(self.getSimilarEvents)
else:
self.SimilarBroadcastTimer = None
self.key_green_choice = self.ADD_TIMER
if self.isRecording:
self["key_green"] = StaticText("")
else:
self["key_green"] = StaticText(_("Add timer"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["actions"] = ActionMap(["OkCancelActions", "EventViewActions"],
{
"cancel": self.close,
"ok": self.close,
"pageUp": self.pageUp,
"pageDown": self.pageDown,
"prevEvent": self.prevEvent,
"nextEvent": self.nextEvent,
"timerAdd": self.timerAdd,
"openSimilarList": self.openSimilarList,
"contextMenu": self.doContext,
})
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def __init__(self, session):
Screen.__init__(self, session)
list = [ ]
self.list = list
self.url = None
self["timerlist"] = TimerList(list)
self.key_red_choice = self.EMPTY
self.key_yellow_choice = self.EMPTY
self.key_blue_choice = self.EMPTY
self["key_red"] = Button(" ")
self["key_green"] = Button(_("Add"))
self["key_yellow"] = Button(" ")
self["key_blue"] = Button(" ")
self["key_info"] = StaticText(" ")
self["description"] = Label(" ")
self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"],
{
"ok": self.openEdit,
"cancel": self.leave,
"green": self.addCurrentTimer,
"log": self.showLog,
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down
}, -1)
self.setTitle(_("Timer overview"))
self.session.nav.RecordTimer.on_state_change.append(self.onStateChange)
self.onShown.append(self.updateState)
if self.isProtected() and config.ParentalControl.servicepin[0].value:
self.onFirstExecBegin.append(boundFunction(self.session.openWithCallback, self.pinEntered, PinInput, pinList=[x.value for x in config.ParentalControl.servicepin], triesEntry=config.ParentalControl.retries.servicepin, title=_("Please enter the correct pin code"), windowTitle=_("Enter pin code")))
self.fallbackTimer = FallbackTimerList(self, self.fillTimerList)
def __init__(self,
session,
service,
zapFunc=None,
eventid=None,
bouquetChangeCB=None,
serviceChangeCB=None,
parent=None):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
self.ask_time = -1 #now
self["key_red"] = StaticText("")
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.session = session
self.Console = Console()
if isinstance(service, str) and eventid is not None:
self.type = EPG_TYPE_SIMILAR
self.setTitle(_("Similar EPG"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["key_red"] = StaticText()
self.currentService = service
self.eventid = eventid
self.zapFunc = None
elif isinstance(service, eServiceReference) or isinstance(
service, str):
self.setTitle(_("Single EPG"))
self.type = EPG_TYPE_SINGLE
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Select Channel"))
self.currentService = ServiceReference(service)
self.zapFunc = zapFunc
self.sort_type = 0
self.setSortDescription()
else:
self.setTitle(_("Multi EPG"))
self.skinName = "EPGSelectionMulti"
self.type = EPG_TYPE_MULTI
if self.bouquetChangeCB == StaticText:
self["key_yellow"] = StaticText(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = StaticText(
pgettext("button label, 'next screen'", "Next"))
else:
self["key_yellow"] = Button(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = Button(
pgettext("button label, 'next screen'", "Next"))
self["now_button"] = Pixmap()
self["next_button"] = Pixmap()
self["more_button"] = Pixmap()
self["now_button_sel"] = Pixmap()
self["next_button_sel"] = Pixmap()
self["more_button_sel"] = Pixmap()
self["now_text"] = Label()
self["next_text"] = Label()
self["more_text"] = Label()
self["date"] = Label()
self.services = service
self.zapFunc = zapFunc
self.parent = parent
if self.bouquetChangeCB == StaticText:
self["key_green"] = StaticText(_("Add timer"))
else:
self["key_green"] = Button(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self["actions"] = ActionMap(
["EPGSelectActions", "OkCancelActions"],
{
"cancel": self.closeScreen,
"ok": self.eventSelected,
"timerAdd": self.timerAdd,
"yellow": self.yellowButtonPressed,
"blue": self.blueButtonPressed,
"info": self.infoKeyPressed,
"menu": self.furtherOptions,
"nextBouquet": self.nextBouquet, # just used in multi epg yet
"prevBouquet": self.prevBouquet, # just used in multi epg yet
"nextService": self.nextService, # just used in single epg yet
"prevService": self.prevService, # just used in single epg yet
"preview": self.eventPreview,
})
self['colouractions'] = HelpableActionMap(
self, 'ColorActions',
{"red": (self.GoToTmbd, _("Search event in TMBD"))})
self.isTMBD = fileExists(
resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo"))
if self.isTMBD:
self["key_red"] = Button(_("Search TMBD"))
self.select = True
if not self.isTMBD:
self["key_red"] = Button(_("TMBD Not Installed"))
self.select = False
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
description = _("Search yt-trailer for event")
except ImportError as ie:
pass
else:
if baseEPGSelection__init__ is not None:
self["trailerActions"] = ActionMap(
["InfobarActions", "InfobarTeletextActions"], {
"showTv": self.showTrailer,
"showRadio": self.showTrailerList,
"startTeletext": self.showConfig
})
self["actions"].csel = self
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
class EPGSelection(Screen):
EMPTY = 0
ADD_TIMER = 1
REMOVE_TIMER = 2
ZAP = 1
def __init__(self,
session,
service,
zapFunc=None,
eventid=None,
bouquetChangeCB=None,
serviceChangeCB=None,
parent=None):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
self.ask_time = -1 #now
self["key_red"] = StaticText("")
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.session = session
self.Console = Console()
if isinstance(service, str) and eventid is not None:
self.type = EPG_TYPE_SIMILAR
self.setTitle(_("Similar EPG"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["key_red"] = StaticText()
self.currentService = service
self.eventid = eventid
self.zapFunc = None
elif isinstance(service, eServiceReference) or isinstance(
service, str):
self.setTitle(_("Single EPG"))
self.type = EPG_TYPE_SINGLE
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Select Channel"))
self.currentService = ServiceReference(service)
self.zapFunc = zapFunc
self.sort_type = 0
self.setSortDescription()
else:
self.setTitle(_("Multi EPG"))
self.skinName = "EPGSelectionMulti"
self.type = EPG_TYPE_MULTI
if self.bouquetChangeCB == StaticText:
self["key_yellow"] = StaticText(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = StaticText(
pgettext("button label, 'next screen'", "Next"))
else:
self["key_yellow"] = Button(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = Button(
pgettext("button label, 'next screen'", "Next"))
self["now_button"] = Pixmap()
self["next_button"] = Pixmap()
self["more_button"] = Pixmap()
self["now_button_sel"] = Pixmap()
self["next_button_sel"] = Pixmap()
self["more_button_sel"] = Pixmap()
self["now_text"] = Label()
self["next_text"] = Label()
self["more_text"] = Label()
self["date"] = Label()
self.services = service
self.zapFunc = zapFunc
self.parent = parent
if self.bouquetChangeCB == StaticText:
self["key_green"] = StaticText(_("Add timer"))
else:
self["key_green"] = Button(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self["actions"] = ActionMap(
["EPGSelectActions", "OkCancelActions"],
{
"cancel": self.closeScreen,
"ok": self.eventSelected,
"timerAdd": self.timerAdd,
"yellow": self.yellowButtonPressed,
"blue": self.blueButtonPressed,
"info": self.infoKeyPressed,
"menu": self.furtherOptions,
"nextBouquet": self.nextBouquet, # just used in multi epg yet
"prevBouquet": self.prevBouquet, # just used in multi epg yet
"nextService": self.nextService, # just used in single epg yet
"prevService": self.prevService, # just used in single epg yet
"preview": self.eventPreview,
})
self['colouractions'] = HelpableActionMap(
self, 'ColorActions',
{"red": (self.GoToTmbd, _("Search event in TMBD"))})
self.isTMBD = fileExists(
resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo"))
if self.isTMBD:
self["key_red"] = Button(_("Search TMBD"))
self.select = True
if not self.isTMBD:
self["key_red"] = Button(_("TMBD Not Installed"))
self.select = False
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
description = _("Search yt-trailer for event")
except ImportError as ie:
pass
else:
if baseEPGSelection__init__ is not None:
self["trailerActions"] = ActionMap(
["InfobarActions", "InfobarTeletextActions"], {
"showTv": self.showTrailer,
"showRadio": self.showTrailerList,
"startTeletext": self.showConfig
})
self["actions"].csel = self
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def GoToTmbd(self):
if fileExists(
resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo")):
self.runTMBD()
if not fileExists(
resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo")):
self.session.openWithCallback(
self.doInstall, MessageBox,
_('The TMBD plugin is not installed!\nDo you want to install it?'
), MessageBox.TYPE_YESNO)
def runTMBD(self):
if fileExists(
resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo")):
from Plugins.Extensions.TMBD.plugin import TMBD
description = _("TMBD Details")
description = _("TMBD details for event")
description = _("Query details from the Internet Movie Database")
cur = self["list"].getCurrent()
if cur[0] is not None:
name2 = cur[0].getEventName() or ''
name3 = name2.split("(")[0].strip()
eventname = name3.replace('"',
'').replace('', '').replace('.', '')
eventname = eventname.replace('', '')
try:
tmbdsearch = config.plugins.tmbd.profile.value
except:
tmbdsearch = None
if tmbdsearch is not None:
if config.plugins.tmbd.profile.value == "0":
self.session.open(TMBD, eventname, False)
else:
try:
from Plugins.Extensions.TMBD.plugin import KinoRu
self.session.open(KinoRu, eventname, False)
except:
pass
else:
self.session.open(TMBD, eventname, False)
def doInstall(self, val):
if val:
self.message = self.session.open(MessageBox,
_("Please wait..."),
MessageBox.TYPE_INFO,
enable_input=False)
self.message.setTitle(_('Installing TMBD'))
self.Console.ePopen(
'opkg update && opkg install enigma2-plugin-extensions-tmbd',
self.installComplete)
else:
self.close()
def installComplete(self, str, retval, extra_args):
if 'Collected errors' in str:
self.session.openWithCallback(
self.close,
MessageBox,
_("Seems internet connection down, Or TMBD Plugin not on feed."
),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
self.message.close()
else:
self.message.close()
self.close()
def nextBouquet(self):
if self.type == EPG_TYPE_SINGLE:
self.session.openWithCallback(
self.channelSelectionCallback,
ChannelSelection.SimpleChannelSelection, _("Select channel"),
True, True, self.currentService.ref, self.parent
and self.parent.epg_bouquet)
if self.bouquetChangeCB:
self.bouquetChangeCB(1, self)
def prevBouquet(self):
if self.type == EPG_TYPE_SINGLE:
self.session.openWithCallback(
self.channelSelectionCallback,
ChannelSelection.SimpleChannelSelection, _("Select channel"),
True, True, self.currentService.ref, self.parent
and self.parent.epg_bouquet)
if self.bouquetChangeCB:
self.bouquetChangeCB(-1, self)
def nextService(self):
if self.serviceChangeCB:
self.serviceChangeCB(1, self)
def prevService(self):
if self.serviceChangeCB:
self.serviceChangeCB(-1, self)
def enterDateTime(self):
if self.type == EPG_TYPE_MULTI:
global mepg_config_initialized
if not mepg_config_initialized:
config.misc.prev_mepg_time = ConfigClock(default=time())
mepg_config_initialized = True
self.session.openWithCallback(self.onDateTimeInputClosed,
TimeDateInput,
config.misc.prev_mepg_time)
def furtherOptions(self):
menu = []
text = _("Select action")
event = self["list"].getCurrent()[0]
if event:
menu = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO) \
if 'selectedevent' in p.__call__.func_code.co_varnames]
if menu:
text += ": %s" % event.getEventName()
if self.type == EPG_TYPE_MULTI:
menu.append((_("Goto specific date/time"), self.enterDateTime))
menu.append((_("Timer Overview"), self.openTimerOverview))
if len(menu) == 1:
menu and menu[0][1]()
elif len(menu) > 1:
def boxAction(choice):
if choice:
choice[1]()
self.session.openWithCallback(boxAction,
ChoiceBox,
title=text,
list=menu,
windowTitle=_("Further options"))
def runPlugin(self, plugin):
event = self["list"].getCurrent()
plugin(session=self.session, selectedevent=event)
def openTimerOverview(self):
self.session.open(TimerEditList)
def onDateTimeInputClosed(self, ret):
if len(ret) > 1:
if ret[0]:
self.ask_time = ret[1]
self["list"].fillMultiEPG(self.services, ret[1])
def closeScreen(self):
if self.zapFunc:
self.zapFunc(None, zapback=True)
self.close(self.closeRecursive)
def infoKeyPressed(self):
cur = self["list"].getCurrent()
event = cur[0]
service = cur[1]
if event is not None:
if self.type != EPG_TYPE_SIMILAR:
self.session.open(EventViewSimple,
event,
service,
self.eventViewCallback,
self.openSimilarList,
parent=self.parent)
else:
self.session.open(EventViewSimple,
event,
service,
self.eventViewCallback,
parent=self.parent)
def openSimilarList(self, eventid, refstr):
self.session.open(EPGSelection, refstr, None, eventid)
def setServices(self, services):
self.services = services
self.onCreate()
def setService(self, service):
self.currentService = service
self.onCreate()
#just used in multipeg
def onCreate(self):
l = self["list"]
l.recalcEntrySize()
if self.type == EPG_TYPE_MULTI:
l.fillMultiEPG(self.services, self.ask_time)
l.moveToService(
Screens.InfoBar.InfoBar.instance and Screens.InfoBar.InfoBar.
instance.servicelist.getCurrentSelection()
or self.session.nav.getCurrentlyPlayingServiceOrGroup())
elif self.type == EPG_TYPE_SINGLE:
service = self.currentService
self["Service"].newService(service.ref)
if not self.saved_title:
self.saved_title = self.instance.getTitle()
self.setTitle(self.saved_title + ' - ' + service.getServiceName())
l.fillSingleEPG(service)
else:
l.fillSimilarList(self.currentService, self.eventid)
def eventViewCallback(self, setEvent, setService, val):
l = self["list"]
old = l.getCurrent()
if val == -1:
self.moveUp()
elif val == +1:
self.moveDown()
cur = l.getCurrent()
if self.type == EPG_TYPE_MULTI and cur[0] is None and cur[
1].ref != old[1].ref:
self.eventViewCallback(setEvent, setService, val)
else:
setService(cur[1])
setEvent(cur[0])
def zapTo(self):
if self.key_red_choice == self.ZAP and self.zapFunc:
self.closeRecursive = True
from Components.ServiceEventTracker import InfoBarCount
if InfoBarCount > 1:
self.eventPreview()
else:
self.zapSelectedService()
self.close(self.closeRecursive)
def zapSelectedService(self, prev=False):
lst = self["list"]
count = lst.getCurrentChangeCount()
if count == 0:
ref = lst.getCurrent()[1]
if ref is not None:
self.zapFunc(ref.ref, preview=prev)
def eventPreview(self):
if self.zapFunc:
# if enabled, then closed whole EPG with EXIT:
# self.closeRecursive = True
self.zapSelectedService(True)
def eventSelected(self):
if self.skinName == "EPGSelectionMulti":
cur = self["list"].getCurrent()
event = cur[0]
ref = cur[1] and cur[1].ref.toString()
if ref and event:
self.session.open(EPGSelection, ref)
else:
self.infoKeyPressed()
def yellowButtonPressed(self):
if self.type == EPG_TYPE_MULTI:
self["list"].updateMultiEPG(-1)
elif self.type == EPG_TYPE_SINGLE:
if self.sort_type == 0:
self.sort_type = 1
else:
self.sort_type = 0
self["list"].sortSingleEPG(self.sort_type)
self.setSortDescription()
def setSortDescription(self):
if self.sort_type == 1:
# TRANSLATORS: This must fit into the header button in the EPG-List
self["key_yellow"].setText(_("Sort time"))
else:
# TRANSLATORS: This must fit into the header button in the EPG-List
self["key_yellow"].setText(_("Sort A-Z"))
def blueButtonPressed(self):
if self.type == EPG_TYPE_MULTI:
self["list"].updateMultiEPG(1)
if self.type == EPG_TYPE_SINGLE:
self.session.openWithCallback(
self.channelSelectionCallback,
ChannelSelection.SimpleChannelSelection, _("Select channel"),
True, True, self.currentService.ref, self.parent
and self.parent.epg_bouquet)
def channelSelectionCallback(self, *args):
if args and len(args) == 2:
serviceref, bouquetref = args[:2]
if self.parent:
self.parent.selectBouquet(bouquetref, self)
self.setService(ServiceReference(serviceref))
def removeTimer(self, timer):
if timer.external:
self.fallbackTimer.removeTimer(timer, self.onSelectionChanged)
else:
timer.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(timer)
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def disableTimer(self, timer, state, repeat=False, record=False):
if repeat:
if record:
title_text = _(
"Repeating event currently recording.\nWhat do you want to do?"
)
menu = [(_("Stop current event but not coming events"),
"stoponlycurrent"),
(_("Stop current event and disable coming events"),
"stopall")]
if not timer.disabled:
menu.append((_(
"Don't stop current event but disable coming events"),
"stoponlycoming"))
else:
title_text = _(
"Attention, this is repeated timer!\nWhat do you want to do?"
)
menu = [(_("Disable current event but not coming events"),
"nextonlystop"), (_("Disable timer"), "simplestop")]
self.session.openWithCallback(boundFunction(
self.runningEventCallback, timer, state),
ChoiceBox,
title=title_text,
list=menu)
elif timer.state == state:
if timer.external:
self.fallbackTimer.toggleTimer(timer, self.onSelectionChanged)
else:
timer.disable()
self.session.nav.RecordTimer.timeChanged(timer)
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def runningEventCallback(self, t, state, result):
if result is not None and t.state == state:
findNextRunningEvent = True
findEventNext = False
if result[1] == "nextonlystop":
findEventNext = True
t.disable()
self.session.nav.RecordTimer.timeChanged(t)
t.processRepeated(findNextEvent=True)
t.enable()
if result[1] in ("stoponlycurrent", "stopall"):
findNextRunningEvent = False
t.enable()
t.processRepeated(findRunningEvent=False)
self.session.nav.RecordTimer.doActivate(t)
if result[1] in ("stoponlycoming", "stopall", "simplestop"):
findNextRunningEvent = True
t.disable()
self.session.nav.RecordTimer.timeChanged(t)
t.findRunningEvent = findNextRunningEvent
t.findNextEvent = findEventNext
if result[1] in ("stoponlycurrent", "stopall", "simplestop",
"nextonlystop"):
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def timerAdd(self):
cur = self["list"].getCurrent()
event = cur[0]
if event is None:
return
serviceref = cur[1]
isRecordEvent = isRepeat = firstNextRepeatEvent = isRunning = False
eventid = event.getEventId()
begin = event.getBeginTime()
end = begin + event.getDuration()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(
timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and timer.eit == eventid and (
begin < timer.begin <= end
or timer.begin <= begin <= timer.end):
isRecordEvent = True
break
elif needed_ref and timer.repeated and self.session.nav.RecordTimer.isInRepeatTimer(
timer, event):
isRecordEvent = True
break
if isRecordEvent:
isRepeat = timer.repeated
prev_state = timer.state
isRunning = prev_state in (1, 2)
title_text = isRepeat and _(
"Attention, this is repeated timer!\n") or ""
firstNextRepeatEvent = isRepeat and (
begin < timer.begin <= end
or timer.begin <= begin <= timer.end) and not timer.justplay
menu = [(_("Delete timer"), "delete"), (_("Edit timer"), "edit")]
buttons = ["red", "green"]
if not isRunning:
if firstNextRepeatEvent and timer.isFindRunningEvent(
) and not timer.isFindNextEvent():
menu.append((_("Options disable timer"), "disablerepeat"))
else:
menu.append((_("Disable timer"), "disable"))
buttons.append("yellow")
elif prev_state == 2 and firstNextRepeatEvent:
menu.append(
(_("Options disable timer"), "disablerepeatrunning"))
buttons.append("yellow")
menu.append((_("Timer Overview"), "timereditlist"))
def timerAction(choice):
if choice is not None:
if choice[1] == "delete":
self.removeTimer(timer)
elif choice[1] == "edit":
self.session.openWithCallback(self.finishedEdit,
TimerEntry, timer)
elif choice[1] == "disable":
self.disableTimer(timer, prev_state)
elif choice[1] == "timereditlist":
self.session.open(TimerEditList)
elif choice[1] == "disablerepeatrunning":
self.disableTimer(timer,
prev_state,
repeat=True,
record=True)
elif choice[1] == "disablerepeat":
self.disableTimer(timer, prev_state, repeat=True)
self.session.openWithCallback(
timerAction,
ChoiceBox,
title=title_text +
_("Select action for timer '%s'.") % timer.name,
list=menu,
keys=buttons)
else:
newEntry = RecordTimerEntry(serviceref,
checkOldTimers=True,
dirname=preferredTimerPath(),
*parseEvent(event))
newEntry.justplay = config.recording.timer_default_type.value == "zap"
newEntry.always_zap = config.recording.timer_default_type.value == "zap+record"
self.session.openWithCallback(self.finishedAdd, TimerEntry,
newEntry)
def finishedEdit(self, answer):
if answer[0]:
entry = answer[1]
if entry.external_prev != entry.external:
def removeEditTimer():
entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev
self.removeTimer(entry)
def moveEditTimerError():
entry.external = entry.external_prev
self.onSelectionChanged()
if entry.external:
self.fallbackTimer.addTimer(entry, removeEditTimer,
moveEditTimerError)
else:
newentry = createRecordTimerEntry(entry)
entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev
self.fallbackTimer.removeTimer(
entry, boundFunction(self.finishedAdd,
(True, newentry)),
moveEditTimerError)
elif entry.external:
self.fallbackTimer.editTimer(entry, self.onSelectionChanged)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(
boundFunction(self.finishedEdit, service_ref,
begin, end), TimerSanityConflict,
simulTimerList)
return
else:
self.session.nav.RecordTimer.timeChanged(entry)
self.onSelectionChanged()
def finishedAdd(self, answer):
print("[EpgSelection] finished add")
if answer[0]:
entry = answer[1]
if entry.external:
self.fallbackTimer.addTimer(entry, self.onSelectionChanged)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
if not entry.repeated and not config.recording.margin_before.value and not config.recording.margin_after.value and len(
simulTimerList) > 1:
change_time = False
conflict_begin = simulTimerList[1].begin
conflict_end = simulTimerList[1].end
if conflict_begin == entry.end:
entry.end -= 30
change_time = True
elif entry.begin == conflict_end:
entry.begin += 30
change_time = True
elif entry.begin == conflict_begin and (
entry.service_ref and entry.service_ref.ref
and entry.service_ref.ref.flags
& eServiceReference.isGroup):
entry.begin += 30
change_time = True
if change_time:
simulTimerList = self.session.nav.RecordTimer.record(
entry)
if simulTimerList is not None:
self.session.openWithCallback(
self.finishSanityCorrection,
TimerSanityConflict, simulTimerList)
return
cur = self["list"].getCurrent()
event = cur and cur[0]
if event:
begin = event.getBeginTime()
end = begin + event.getDuration()
if begin < entry.begin <= end or entry.begin <= begin <= entry.end:
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
print("[EpgSelection] Timeredit aborted")
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def moveUp(self):
self["list"].moveUp()
def moveDown(self):
self["list"].moveDown()
def applyButtonState(self, state):
if state == 0:
self["now_button"].hide()
self["now_button_sel"].hide()
self["next_button"].hide()
self["next_button_sel"].hide()
self["more_button"].hide()
self["more_button_sel"].hide()
self["now_text"].hide()
self["next_text"].hide()
self["more_text"].hide()
self["key_red"].setText("")
else:
if state == 1:
self["now_button_sel"].show()
self["now_button"].hide()
else:
self["now_button"].show()
self["now_button_sel"].hide()
if state == 2:
self["next_button_sel"].show()
self["next_button"].hide()
else:
self["next_button"].show()
self["next_button_sel"].hide()
if state == 3:
self["more_button_sel"].show()
self["more_button"].hide()
else:
self["more_button"].show()
self["more_button_sel"].hide()
def onSelectionChanged(self):
cur = self["list"].getCurrent()
if cur is None:
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
return
event = cur[0]
self["Event"].newEvent(event)
if self.type == EPG_TYPE_MULTI:
count = self["list"].getCurrentChangeCount()
if self.ask_time != -1:
self.applyButtonState(0)
elif count > 1:
self.applyButtonState(3)
elif count > 0:
self.applyButtonState(2)
else:
self.applyButtonState(1)
days = [
_("Mon"),
_("Tue"),
_("Wed"),
_("Thu"),
_("Fri"),
_("Sat"),
_("Sun")
]
datestr = ""
if event is not None:
now = time()
beg = event.getBeginTime()
nowTime = localtime(now)
begTime = localtime(beg)
if nowTime[2] != begTime[2]:
datestr = strftime(config.usage.date.dayshort.value,
begTime)
else:
datestr = '%s' % _('Today')
self["date"].setText(datestr)
if cur[1] is None:
self["Service"].newService(None)
else:
self["Service"].newService(cur[1].ref)
if cur[1] is None or cur[1].getServiceName() == "":
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
return
if event is None:
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
return
serviceref = cur[1]
eventid = event.getEventId()
begin = event.getBeginTime()
end = begin + event.getDuration()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
isRecordEvent = False
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(
timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and (timer.eit == eventid and
(begin < timer.begin <= end
or timer.begin <= begin <= timer.end)
or timer.repeated and
self.session.nav.RecordTimer.isInRepeatTimer(
timer, event)):
isRecordEvent = True
break
if isRecordEvent and self.key_green_choice != self.REMOVE_TIMER:
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
elif not isRecordEvent and self.key_green_choice != self.ADD_TIMER:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
if self.parent and eventid and hasattr(self.parent, "setEvent"):
self.parent.setEvent(serviceref, eventid)
self["list"].l.invalidate()
class TimerEditList(Screen):
EMPTY = 0
ENABLE = 1
DISABLE = 2
CLEANUP = 3
DELETE = 4
STOP = 5
def __init__(self, session):
Screen.__init__(self, session)
list = []
self.list = list
self.url = None
self["timerlist"] = TimerList(list)
self["Service"] = ServiceEvent()
self.key_red_choice = self.EMPTY
self.key_yellow_choice = self.EMPTY
self.key_blue_choice = self.EMPTY
self["key_red"] = StaticText("")
self["key_green"] = StaticText(_("Add"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["key_info"] = StaticText("")
self["description"] = Label("")
self["actions"] = ActionMap(
[
"OkCancelActions", "DirectionActions", "ShortcutActions",
"TimerEditActions"
], {
"ok": self.openEdit,
"cancel": self.leave,
"green": self.addCurrentTimer,
"log": self.showLog,
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down
}, -1)
self.setTitle(_("Timer overview"))
self.session.nav.RecordTimer.on_state_change.append(self.onStateChange)
self.onShown.append(self.updateState)
if self.isProtected() and config.ParentalControl.servicepin[0].value:
self.onFirstExecBegin.append(
boundFunction(
self.session.openWithCallback,
self.pinEntered,
PinInput,
pinList=[
x.value for x in config.ParentalControl.servicepin
],
triesEntry=config.ParentalControl.retries.servicepin,
title=_("Please enter the correct pin code"),
windowTitle=_("Enter pin code")))
self.fallbackTimer = FallbackTimerList(self, self.fillTimerList)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and (
not config.ParentalControl.config_sections.main_menu.value or
hasattr(self.session, 'infobar') and self.session.infobar is None
) and config.ParentalControl.config_sections.timer_menu.value
def pinEntered(self, result):
if result is None:
self.closeProtectedScreen()
elif not result:
self.session.openWithCallback(
self.close(),
MessageBox,
_("The pin code you entered is wrong."),
MessageBox.TYPE_ERROR,
timeout=5)
def closeProtectedScreen(self, result=None):
self.close(None)
def up(self):
self["timerlist"].instance.moveSelection(
self["timerlist"].instance.moveUp)
self.updateState()
def down(self):
self["timerlist"].instance.moveSelection(
self["timerlist"].instance.moveDown)
self.updateState()
def left(self):
self["timerlist"].instance.moveSelection(
self["timerlist"].instance.pageUp)
self.updateState()
def right(self):
self["timerlist"].instance.moveSelection(
self["timerlist"].instance.pageDown)
self.updateState()
def toggleDisabledState(self):
cur = self["timerlist"].getCurrent()
timer_changed = True
if cur:
t = cur
if t.external:
self.fallbackTimer.toggleTimer(t, self.refill)
else:
stateRunning = t.state in (1, 2)
if t.disabled and t.repeated and stateRunning and not t.justplay:
return
if t.disabled:
print "[TimerEditList] try to ENABLE timer"
t.enable()
timersanitycheck = TimerSanityCheck(
self.session.nav.RecordTimer.timer_list, cur)
if not timersanitycheck.check():
t.disable()
print "[TimerEditList] sanity check failed"
simulTimerList = timersanitycheck.getSimulTimerList()
if simulTimerList is not None:
self.session.openWithCallback(
self.finishedEdit, TimerSanityConflict,
simulTimerList)
timer_changed = False
else:
print "[TimerEditList] sanity check passed"
if timersanitycheck.doubleCheck():
t.disable()
else:
if stateRunning:
if t.isRunning() and t.repeated:
list = ((
_("Stop current event but not coming events"),
"stoponlycurrent"
), (_(
"Stop current event and disable coming events"
), "stopall"), (_(
"Don't stop current event but disable coming events"
), "stoponlycoming"))
self.session.openWithCallback(
boundFunction(self.runningEventCallback, t),
ChoiceBox,
title=
_("Repeating event currently recording... What do you want to do?"
),
list=list)
timer_changed = False
else:
t.disable()
if timer_changed:
self.session.nav.RecordTimer.timeChanged(t)
self.refill()
def runningEventCallback(self, t, result):
if result is not None and t.isRunning():
findNextRunningEvent = True
if result[1] == "stoponlycurrent" or result[1] == "stopall":
findNextRunningEvent = False
t.enable()
t.processRepeated(findRunningEvent=False)
self.session.nav.RecordTimer.doActivate(t)
if result[1] == "stoponlycoming" or result[1] == "stopall":
findNextRunningEvent = True
t.disable()
self.session.nav.RecordTimer.timeChanged(t)
t.findRunningEvent = findNextRunningEvent
self.refill()
def removeAction(self, descr):
actions = self["actions"].actions
if descr in actions:
del actions[descr]
def updateState(self):
cur = self["timerlist"].getCurrent()
if cur:
self["Service"].newService(cur.service_ref.ref)
if cur.external:
self["key_info"].setText("")
else:
self["key_info"].setText(_("Info"))
text = cur.description
event = eEPGCache.getInstance().lookupEventId(
cur.service_ref.ref, cur.eit) if cur.eit is not None else None
if event:
ext_description = event.getExtendedDescription()
short_description = event.getShortDescription()
if text != short_description:
if text and short_description:
text = _("Timer:") + " " + text + "\n\n" + _(
"EPG:") + " " + short_description
elif short_description:
text = short_description
cur.description = short_description
if ext_description and ext_description != text:
if text:
text += "\n\n" + ext_description
else:
text = ext_description
if not cur.conflict_detection:
text = _("\nConflict detection disabled!") + "\n\n" + text
self["description"].setText(text)
stateRunning = cur.state in (1, 2)
if cur.state == 2 and self.key_red_choice != self.STOP:
self["actions"].actions.update({"red": self.stopTimerQuestion})
self["key_red"].setText(_("Stop"))
self.key_red_choice = self.STOP
elif cur.state != 2 and self.key_red_choice != self.DELETE:
self["actions"].actions.update(
{"red": self.removeTimerQuestion})
self["key_red"].setText(_("Delete"))
self.key_red_choice = self.DELETE
if cur.disabled and (self.key_yellow_choice != self.ENABLE):
if stateRunning and cur.repeated and not cur.justplay:
self.removeAction("yellow")
self["key_yellow"].setText("")
self.key_yellow_choice = self.EMPTY
else:
self["actions"].actions.update(
{"yellow": self.toggleDisabledState})
self["key_yellow"].setText(_("Enable"))
self.key_yellow_choice = self.ENABLE
elif stateRunning and (not cur.repeated or cur.state == 1) and (
self.key_yellow_choice != self.EMPTY):
self.removeAction("yellow")
self["key_yellow"].setText("")
self.key_yellow_choice = self.EMPTY
elif (not stateRunning or cur.repeated
and cur.isRunning()) and not cur.disabled and (
self.key_yellow_choice != self.DISABLE):
self["actions"].actions.update(
{"yellow": self.toggleDisabledState})
self["key_yellow"].setText(_("Disable"))
self.key_yellow_choice = self.DISABLE
else:
self["description"].setText("")
if self.key_red_choice != self.EMPTY:
self.removeAction("red")
self["key_red"].setText("")
self.key_red_choice = self.EMPTY
if self.key_yellow_choice != self.EMPTY:
self.removeAction("yellow")
self["key_yellow"].setText("")
self.key_yellow_choice = self.EMPTY
showCleanup = True
for x in self.list:
if (not x[0].disabled) and (x[1] == True):
break
else:
showCleanup = False
if showCleanup and (self.key_blue_choice != self.CLEANUP):
self["actions"].actions.update({"blue": self.cleanupQuestion})
self["key_blue"].setText(_("Cleanup"))
self.key_blue_choice = self.CLEANUP
elif (not showCleanup) and (self.key_blue_choice != self.EMPTY):
self.removeAction("blue")
self["key_blue"].setText("")
self.key_blue_choice = self.EMPTY
def fillTimerList(self):
def eol_compare(x, y):
if x[0].state != y[0].state and x[
0].state == RealTimerEntry.StateEnded or y[
0].state == RealTimerEntry.StateEnded:
return cmp(x[0].state, y[0].state)
return cmp(x[0].begin, y[0].begin)
self.list = []
if self.fallbackTimer.list:
self.list.extend([(timer, False)
for timer in self.fallbackTimer.list
if timer.state != 3])
self.list.extend([(timer, True)
for timer in self.fallbackTimer.list
if timer.state == 3])
self.list.extend([
(timer, False) for timer in self.session.nav.RecordTimer.timer_list
])
self.list.extend([
(timer, True)
for timer in self.session.nav.RecordTimer.processed_timers
])
if config.usage.timerlist_finished_timer_position.index: #end of list
self.list.sort(cmp=eol_compare)
else:
self.list.sort(key=lambda x: x[0].begin)
self["timerlist"].l.setList(self.list)
self.updateState()
def showLog(self):
cur = self["timerlist"].getCurrent()
if cur and not cur.external:
self.session.openWithCallback(self.finishedEdit, TimerLog, cur)
else:
return 0
def openEdit(self):
cur = self["timerlist"].getCurrent()
if cur:
self.session.openWithCallback(self.finishedEdit, TimerEntry, cur)
def cleanupQuestion(self):
self.session.openWithCallback(self.cleanupTimer, MessageBox,
_("Really delete done timers?"))
def cleanupTimer(self, delete):
if delete:
self.session.nav.RecordTimer.cleanup()
self.fallbackTimer.cleanupTimers(self.refill)
def stopTimerQuestion(self):
cur = self["timerlist"].getCurrent()
if cur:
self.session.openWithCallback(
self.removeTimer, MessageBox,
_("Do you really want to stop current event and delete timer %s?"
) % (cur.name))
def removeTimerQuestion(self):
cur = self["timerlist"].getCurrent()
if cur:
self.session.openWithCallback(
self.removeTimer, MessageBox,
_("Do you really want to delete %s?") % (cur.name))
def removeTimer(self, result=True):
if result:
cur = self["timerlist"].getCurrent()
if cur:
if cur.external:
self.fallbackTimer.removeTimer(cur, self.refill)
else:
cur.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(cur)
self.refill()
def refill(self):
oldsize = len(self.list)
self.fillTimerList()
lst = self["timerlist"]
newsize = len(self.list)
if oldsize and oldsize != newsize:
idx = lst.getCurrentIndex()
lst.entryRemoved(idx)
else:
lst.invalidate()
self.updateState()
def addCurrentTimer(self):
event = None
service = self.session.nav.getCurrentService()
if service is not None:
info = service.info()
if info is not None:
event = info.getEvent(0)
# FIXME only works if already playing a service
serviceref = ServiceReference(
self.session.nav.getCurrentlyPlayingServiceOrGroup())
if event is None:
data = (int(time()), int(time() + 60), "", "", None)
else:
data = parseEvent(event, description=False)
timer = RecordTimerEntry(serviceref,
checkOldTimers=True,
dirname=preferredTimerPath(),
*data)
timer.justplay = config.recording.timer_default_type.value == "zap"
timer.always_zap = config.recording.timer_default_type.value == "zap+record"
self.addTimer(timer)
def addTimer(self, timer):
self.session.openWithCallback(self.finishedAdd, TimerEntry, timer)
def finishedEdit(self, answer):
print "[TimerEditList] finished edit"
if answer[0]:
entry = answer[1]
if entry.external_prev != entry.external:
def removeEditTimer():
entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev
self.removeTimer()
def moveEditTimerError():
entry.external = entry.external_prev
self.refill()
if entry.external:
self.fallbackTimer.addTimer(entry, removeEditTimer,
moveEditTimerError)
else:
newentry = createRecordTimerEntry(entry)
entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev
self.fallbackTimer.removeTimer(
entry, boundFunction(self.finishedAdd,
(True, newentry)),
moveEditTimerError)
elif entry.external:
self.fallbackTimer.editTimer(entry, self.refill)
else:
timersanitycheck = TimerSanityCheck(
self.session.nav.RecordTimer.timer_list, entry)
success = False
if not timersanitycheck.check():
simulTimerList = timersanitycheck.getSimulTimerList()
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
if not timersanitycheck.check():
simulTimerList = timersanitycheck.getSimulTimerList(
)
if simulTimerList is not None:
self.session.openWithCallback(
self.finishedEdit, TimerSanityConflict,
timersanitycheck.getSimulTimerList())
else:
success = True
else:
success = True
if success:
print "[TimerEditList] sanity check passed"
self.session.nav.RecordTimer.timeChanged(entry)
self.fillTimerList()
def finishedAdd(self, answer):
print "[TimerEditList] finished add"
if answer[0]:
entry = answer[1]
if entry.external:
self.fallbackTimer.addTimer(entry, self.refill)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(
self.finishSanityCorrection, TimerSanityConflict,
simulTimerList)
self.fillTimerList()
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def leave(self):
self.session.nav.RecordTimer.on_state_change.remove(self.onStateChange)
self.close()
def onStateChange(self, entry):
self.refill()
class EventViewBase:
ADD_TIMER = 0
REMOVE_TIMER = 1
def __init__(self, event, Ref, callback=None, similarEPGCB=None, parent=None):
self.similarEPGCB = similarEPGCB
self.cbFunc = callback
self.currentService=Ref
self.isRecording = (not Ref.ref.flags & eServiceReference.isGroup) and Ref.ref.getPath()
self.event = event
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["epg_eventname"] = ScrollLabel()
self["epg_description"] = ScrollLabel()
self["FullDescription"] = ScrollLabel()
self["datetime"] = Label()
self["channel"] = Label()
self["duration"] = Label()
self["key_red"] = StaticText("")
if similarEPGCB is not None:
self.SimilarBroadcastTimer = eTimer()
self.SimilarBroadcastTimer.callback.append(self.getSimilarEvents)
else:
self.SimilarBroadcastTimer = None
self.key_green_choice = self.ADD_TIMER
if self.isRecording:
self["key_green"] = StaticText("")
else:
self["key_green"] = StaticText(_("Add timer"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["actions"] = ActionMap(["OkCancelActions", "EventViewActions"],
{
"cancel": self.close,
"ok": self.close,
"pageUp": self.pageUp,
"pageDown": self.pageDown,
"prevEvent": self.prevEvent,
"nextEvent": self.nextEvent,
"timerAdd": self.timerAdd,
"openSimilarList": self.openSimilarList,
"contextMenu": self.doContext,
})
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def onCreate(self):
self.setService(self.currentService)
self.setEvent(self.event)
def prevEvent(self):
if self.cbFunc is not None:
self.cbFunc(self.setEvent, self.setService, -1)
def nextEvent(self):
if self.cbFunc is not None:
self.cbFunc(self.setEvent, self.setService, +1)
def removeTimer(self, timer):
if timer.external:
self.fallbackTimer.removeTimer(timer, self.setTimerState)
else:
timer.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(timer)
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def timerAdd(self):
if self.isRecording:
return
event = self.event
serviceref = self.currentService
if event is None:
return
eventid = event.getEventId()
begin = event.getBeginTime()
end = begin + event.getDuration()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
isRecordEvent = False
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and timer.eit == eventid and (begin < timer.begin <= end or timer.begin <= begin <= timer.end):
isRecordEvent = True
break
elif needed_ref and timer.repeated and self.session.nav.RecordTimer.isInRepeatTimer(timer, event):
isRecordEvent = True
break
if isRecordEvent:
title_text = timer.repeated and _("Attention, this is repeated timer!\n") or ""
menu = [(_("Delete timer"), "delete"),(_("Edit timer"), "edit")]
buttons = ["red", "green"]
def timerAction(choice):
if choice is not None:
if choice[1] == "delete":
self.removeTimer(timer)
elif choice[1] == "edit":
self.session.openWithCallback(self.finishedEdit, TimerEntry, timer)
self.session.openWithCallback(timerAction, ChoiceBox, title=title_text + _("Select action for timer '%s'.") % timer.name, list=menu, keys=buttons)
else:
newEntry = RecordTimerEntry(self.currentService, checkOldTimers = True, dirname = preferredTimerPath(), *parseEvent(self.event))
newEntry.justplay = config.recording.timer_default_type.value == "zap"
newEntry.always_zap = config.recording.timer_default_type.value == "zap+record"
self.session.openWithCallback(self.finishedAdd, TimerEntry, newEntry)
def finishedEdit(self, answer):
if answer[0]:
entry = answer[1]
if entry.external_prev != entry.external:
def removeEditTimer():
entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev
self.removeTimer(entry)
def moveEditTimerError():
entry.external = entry.external_prev
self.onSelectionChanged()
if entry.external:
self.fallbackTimer.addTimer(entry, removeEditTimer, moveEditTimerError)
else:
newentry = createRecordTimerEntry(entry)
entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev
self.fallbackTimer.removeTimer(entry, boundFunction(self.finishedAdd, (True, newentry)), moveEditTimerError)
elif entry.external:
self.fallbackTimer.editTimer(entry, self.setTimerState)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, simulTimerList)
return
else:
self.session.nav.RecordTimer.timeChanged(entry)
if answer is not None and len(answer) > 1:
entry = answer[1]
if not entry.disabled:
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def finishedAdd(self, answer):
print "finished add"
if answer[0]:
entry = answer[1]
if entry.external:
self.fallbackTimer.addTimer(entry, self.setTimerState)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
if not entry.repeated and not config.recording.margin_before.value and not config.recording.margin_after.value and len(simulTimerList) > 1:
change_time = False
conflict_begin = simulTimerList[1].begin
conflict_end = simulTimerList[1].end
if conflict_begin == entry.end:
entry.end -= 30
change_time = True
elif entry.begin == conflict_end:
entry.begin += 30
change_time = True
elif entry.begin == conflict_begin and (entry.service_ref and entry.service_ref.ref and entry.service_ref.ref.flags & eServiceReference.isGroup):
entry.begin += 30
change_time = True
if change_time:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
print "Timeredit aborted"
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def setService(self, service):
self.currentService=service
self["Service"].newService(service.ref)
if self.isRecording:
self["channel"].setText(_("Recording"))
else:
name = service.getServiceName()
if name is not None:
self["channel"].setText(name)
else:
self["channel"].setText(_("unknown service"))
def sort_func(self,x,y):
if x[1] < y[1]:
return -1
elif x[1] == y[1]:
return 0
else:
return 1
def setEvent(self, event):
self.event = event
self["Event"].newEvent(event)
if event is None:
return
text = event.getEventName()
short = event.getShortDescription()
ext = event.getExtendedDescription()
if short == text:
short = ""
if short and text:
if short.find(text):
short = ""
if short and ext:
if short.find(ext):
short =""
else:
ext = short + "\n\n" + ext
elif short:
ext = short
if text and ext:
text += "\n\n"
text += ext
self.setTitle(event.getEventName())
self["epg_eventname"].setText(event.getEventName())
self["epg_description"].setText(text)
self["FullDescription"].setText(ext)
self["datetime"].setText(event.getBeginTimeString())
self["duration"].setText(_("%d min")%(event.getDuration()/60))
self["key_red"].setText("")
if self.SimilarBroadcastTimer is not None:
self.SimilarBroadcastTimer.start(400,True)
self.setTimerState()
def setTimerState(self):
serviceref = self.currentService
eventid = self.event.getEventId()
begin = self.event.getBeginTime()
end = begin + self.event.getDuration()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
isRecordEvent = False
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and (timer.eit == eventid and (begin < timer.begin <= end or timer.begin <= begin <= timer.end) or timer.repeated and self.session.nav.RecordTimer.isInRepeatTimer(timer, self.event)):
isRecordEvent = True
break
if isRecordEvent and self.key_green_choice != self.REMOVE_TIMER:
self["key_green"].setText(_("Remove timer"))
self.key_green_choice = self.REMOVE_TIMER
elif not isRecordEvent and self.key_green_choice != self.ADD_TIMER:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def pageUp(self):
self["epg_eventname"].pageUp()
self["epg_description"].pageUp()
self["FullDescription"].pageUp()
def pageDown(self):
self["epg_eventname"].pageDown()
self["epg_description"].pageDown()
self["FullDescription"].pageDown()
def getSimilarEvents(self):
# search similar broadcastings
if not self.event:
return
refstr = str(self.currentService)
id = self.event.getEventId()
epgcache = eEPGCache.getInstance()
ret = epgcache.search(('NB', 100, eEPGCache.SIMILAR_BROADCASTINGS_SEARCH, refstr, id))
if ret is not None:
text = '\n\n' + _('Similar broadcasts:')
ret.sort(self.sort_func)
for x in ret:
t = localtime(x[1])
text += '\n%02d.%02d.%d, %02d:%02d - %s' % (t[2], t[1], t[0], t[3], t[4], x[0])
descr = self["epg_description"]
descr.setText(descr.getText()+text)
descr = self["FullDescription"]
descr.setText(descr.getText()+text)
self["key_red"].setText(_("Similar"))
def openSimilarList(self):
if self.similarEPGCB is not None and self["key_red"].getText():
id = self.event and self.event.getEventId()
refstr = str(self.currentService)
if id is not None:
self.similarEPGCB(id, refstr)
def doContext(self):
if self.event:
text = _("Select action")
menu = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO) \
if 'servicelist' not in p.__call__.func_code.co_varnames \
if 'selectedevent' not in p.__call__.func_code.co_varnames ]
if len(menu) == 1:
menu and menu[0][1]()
elif len(menu) > 1:
def boxAction(choice):
if choice:
choice[1]()
text += ": %s" % self.event.getEventName()
self.session.openWithCallback(boxAction, ChoiceBox, title=text, list=menu, windowTitle=_("Event view context menu"))
def runPlugin(self, plugin):
plugin(session=self.session, service=self.currentService, event=self.event, eventName=self.event.getEventName())
def __init__(self,
session,
service,
zapFunc=None,
eventid=None,
bouquetChangeCB=None,
serviceChangeCB=None,
parent=None):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
self.ask_time = -1 #now
self["key_red"] = StaticText("")
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.session = session
if isinstance(service, str) and eventid is not None:
self.type = EPG_TYPE_SIMILAR
self.setTitle(_("Similar EPG"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["key_red"] = StaticText()
self.currentService = service
self.eventid = eventid
self.zapFunc = None
elif isinstance(service, eServiceReference) or isinstance(
service, str):
self.setTitle(_("Single EPG"))
self.type = EPG_TYPE_SINGLE
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Select Channel"))
self.currentService = ServiceReference(service)
self.zapFunc = zapFunc
self.sort_type = 0
self.setSortDescription()
else:
self.setTitle(_("Multi EPG"))
self.skinName = "EPGSelectionMulti"
self.type = EPG_TYPE_MULTI
self["key_yellow"] = StaticText(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = StaticText(
pgettext("button label, 'next screen'", "Next"))
self["now_button"] = Pixmap()
self["next_button"] = Pixmap()
self["more_button"] = Pixmap()
self["now_button_sel"] = Pixmap()
self["next_button_sel"] = Pixmap()
self["more_button_sel"] = Pixmap()
self["now_text"] = Label()
self["next_text"] = Label()
self["more_text"] = Label()
self["date"] = Label()
self.services = service
self.zapFunc = zapFunc
self.parent = parent
self["key_green"] = StaticText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self["actions"] = ActionMap(
["EPGSelectActions", "OkCancelActions"],
{
"cancel": self.closeScreen,
"ok": self.eventSelected,
"timerAdd": self.timerAdd,
"yellow": self.yellowButtonPressed,
"blue": self.blueButtonPressed,
"info": self.infoKeyPressed,
"red": self.zapTo,
"menu": self.furtherOptions,
"nextBouquet": self.nextBouquet, # just used in multi epg yet
"prevBouquet": self.prevBouquet, # just used in multi epg yet
"nextService": self.nextService, # just used in single epg yet
"prevService": self.prevService, # just used in single epg yet
"preview": self.eventPreview,
})
self["actions"].csel = self
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
class EventViewBase:
ADD_TIMER = 0
REMOVE_TIMER = 1
def __init__(self, event, Ref, callback=None, similarEPGCB=None, parent=None):
self.similarEPGCB = similarEPGCB
self.cbFunc = callback
self.currentService=Ref
self.isRecording = (not Ref.ref.flags & eServiceReference.isGroup) and Ref.ref.getPath()
self.event = event
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["epg_eventname"] = ScrollLabel()
self["epg_description"] = ScrollLabel()
self["FullDescription"] = ScrollLabel()
self["datetime"] = Label()
self["channel"] = Label()
self["duration"] = Label()
self["now"] = Label()
self["next"] = Label()
self["key_red"] = StaticText("")
if similarEPGCB is not None:
self.SimilarBroadcastTimer = eTimer()
self.SimilarBroadcastTimer.callback.append(self.getSimilarEvents)
else:
self.SimilarBroadcastTimer = None
self.key_green_choice = self.ADD_TIMER
if self.isRecording:
self["key_green"] = StaticText("")
else:
self["key_green"] = StaticText(_("Add timer"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["actions"] = ActionMap(["OkCancelActions", "EventViewActions"],
{
"cancel": self.close,
"ok": self.close,
"pageUp": self.pageUp,
"pageDown": self.pageDown,
"prevEvent": self.prevEvent,
"nextEvent": self.nextEvent,
"timerAdd": self.timerAdd,
"openSimilarList": self.openSimilarList,
"contextMenu": self.doContext,
})
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def onCreate(self):
self.setService(self.currentService)
self.setEvent(self.event)
self["now"].show()
self["next"].hide()
def prevEvent(self):
if self.cbFunc is not None:
self.cbFunc(self.setEvent, self.setService, -1)
self["now"].show()
self["next"].hide()
def nextEvent(self):
if self.cbFunc is not None:
self.cbFunc(self.setEvent, self.setService, +1)
self["next"].show()
self["now"].hide()
def removeTimer(self, timer):
if timer.external:
self.fallbackTimer.removeTimer(timer, self.setTimerState)
else:
timer.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(timer)
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def timerAdd(self):
if self.isRecording:
return
event = self.event
serviceref = self.currentService
if event is None:
return
eventid = event.getEventId()
begin = event.getBeginTime()
end = begin + event.getDuration()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
isRecordEvent = False
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and timer.eit == eventid and (begin < timer.begin <= end or timer.begin <= begin <= timer.end):
isRecordEvent = True
break
elif needed_ref and timer.repeated and self.session.nav.RecordTimer.isInRepeatTimer(timer, event):
isRecordEvent = True
break
if isRecordEvent:
title_text = timer.repeated and _("Attention, this is repeated timer!\n") or ""
menu = [(_("Delete timer"), "delete"),(_("Edit timer"), "edit")]
buttons = ["red", "green"]
def timerAction(choice):
if choice is not None:
if choice[1] == "delete":
self.removeTimer(timer)
elif choice[1] == "edit":
self.session.openWithCallback(self.finishedEdit, TimerEntry, timer)
self.session.openWithCallback(timerAction, ChoiceBox, title=title_text + _("Select action for timer '%s'.") % timer.name, list=menu, keys=buttons)
else:
newEntry = RecordTimerEntry(self.currentService, checkOldTimers = True, dirname = preferredTimerPath(), *parseEvent(self.event))
self.session.openWithCallback(self.finishedAdd, TimerEntry, newEntry)
def finishedEdit(self, answer):
if answer[0]:
entry = answer[1]
if entry.external_prev != entry.external:
def removeEditTimer():
entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev
self.removeTimer(entry)
def moveEditTimerError():
entry.external = entry.external_prev
self.onSelectionChanged()
if entry.external:
self.fallbackTimer.addTimer(entry, removeEditTimer, moveEditTimerError)
else:
newentry = createRecordTimerEntry(entry)
entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev
self.fallbackTimer.removeTimer(entry, boundFunction(self.finishedAdd, (True, newentry)), moveEditTimerError)
elif entry.external:
self.fallbackTimer.editTimer(entry, self.setTimerState)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, simulTimerList)
return
else:
self.session.nav.RecordTimer.timeChanged(entry)
if answer is not None and len(answer) > 1:
entry = answer[1]
if not entry.disabled:
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def finishedAdd(self, answer):
print "finished add"
if answer[0]:
entry = answer[1]
if entry.external:
self.fallbackTimer.addTimer(entry, self.setTimerState)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
if not entry.repeated and not config.recording.margin_before.value and not config.recording.margin_after.value and len(simulTimerList) > 1:
change_time = False
conflict_begin = simulTimerList[1].begin
conflict_end = simulTimerList[1].end
if conflict_begin == entry.end:
entry.end -= 30
change_time = True
elif entry.begin == conflict_end:
entry.begin += 30
change_time = True
elif entry.begin == conflict_begin and (entry.service_ref and entry.service_ref.ref and entry.service_ref.ref.flags & eServiceReference.isGroup):
entry.begin += 30
change_time = True
if change_time:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
print "Timeredit aborted"
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def setService(self, service):
self.currentService=service
self["Service"].newService(service.ref)
if self.isRecording:
self["channel"].setText(_("Recording"))
else:
name = service.getServiceName()
if name is not None:
self["channel"].setText(name)
else:
self["channel"].setText(_("unknown service"))
def sort_func(self,x,y):
if x[1] < y[1]:
return -1
elif x[1] == y[1]:
return 0
else:
return 1
def setEvent(self, event):
self.event = event
self["Event"].newEvent(event)
if event is None:
return
text = event.getEventName()
short = event.getShortDescription()
ext = event.getExtendedDescription()
if short == text:
short = ""
if short and ext:
ext = short + "\n\n" + ext
elif short:
ext = short
if text and ext:
text += "\n\n"
text += ext
self.setTitle(event.getEventName())
self["epg_eventname"].setText(event.getEventName())
self["epg_description"].setText(text)
self["FullDescription"].setText(ext)
self["datetime"].setText(event.getBeginTimeString())
self["duration"].setText(_("%d min")%(event.getDuration()/60))
self["now"].setText(_("Now") + _(":"))
self["next"].setText(_("Following") + _(":"))
self["key_red"].setText("")
if self.SimilarBroadcastTimer is not None:
self.SimilarBroadcastTimer.start(400,True)
self.setTimerState()
def setTimerState(self):
serviceref = self.currentService
eventid = self.event.getEventId()
begin = self.event.getBeginTime()
try:
end = begin + self.event.getDuration()
except:
pass
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
isRecordEvent = False
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and (timer.eit == eventid and (begin < timer.begin <= end or timer.begin <= begin <= timer.end) or timer.repeated and self.session.nav.RecordTimer.isInRepeatTimer(timer, self.event)):
isRecordEvent = True
break
if isRecordEvent and self.key_green_choice != self.REMOVE_TIMER:
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
elif not isRecordEvent and self.key_green_choice != self.ADD_TIMER:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def pageUp(self):
self["epg_eventname"].pageUp()
self["epg_description"].pageUp()
self["FullDescription"].pageUp()
def pageDown(self):
self["epg_eventname"].pageDown()
self["epg_description"].pageDown()
self["FullDescription"].pageDown()
def getSimilarEvents(self):
# search similar broadcastings
if not self.event:
return
refstr = str(self.currentService)
id = self.event.getEventId()
epgcache = eEPGCache.getInstance()
ret = epgcache.search(('NB', 100, eEPGCache.SIMILAR_BROADCASTINGS_SEARCH, refstr, id))
if ret is not None:
text = '\n\n' + _('Similar broadcasts:')
ret.sort(self.sort_func)
for x in ret:
t = localtime(x[1])
text += '\n%02d.%02d.%d, %02d:%02d - %s' % (t[2], t[1], t[0], t[3], t[4], x[0])
descr = self["epg_description"]
descr.setText(descr.getText()+text)
descr = self["FullDescription"]
descr.setText(descr.getText()+text)
self["key_red"].setText(_("Similar"))
def openSimilarList(self):
if self.similarEPGCB is not None and self["key_red"].getText():
id = self.event and self.event.getEventId()
refstr = str(self.currentService)
if id is not None:
self.similarEPGCB(id, refstr)
def doContext(self):
if self.event:
text = _("Select action")
menu = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO) \
if 'servicelist' not in p.__call__.func_code.co_varnames \
if 'selectedevent' not in p.__call__.func_code.co_varnames ]
if len(menu) == 1:
menu and menu[0][1]()
elif len(menu) > 1:
def boxAction(choice):
if choice:
choice[1]()
text += ": %s" % self.event.getEventName()
self.session.openWithCallback(boxAction, ChoiceBox, title=text, list=menu, windowTitle=_("Event view context menu"))
def runPlugin(self, plugin):
plugin(session=self.session, service=self.currentService, event=self.event, eventName=self.event.getEventName())
class TimerEditList(Screen):
EMPTY = 0
ENABLE = 1
DISABLE = 2
CLEANUP = 3
DELETE = 4
STOP = 5
def __init__(self, session):
Screen.__init__(self, session)
list = [ ]
self.list = list
self.url = None
self["timerlist"] = TimerList(list)
self.key_red_choice = self.EMPTY
self.key_yellow_choice = self.EMPTY
self.key_blue_choice = self.EMPTY
self["key_red"] = Button(" ")
self["key_green"] = Button(_("Add"))
self["key_yellow"] = Button(" ")
self["key_blue"] = Button(" ")
self["key_info"] = StaticText(" ")
self["description"] = Label(" ")
self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions"],
{
"ok": self.openEdit,
"cancel": self.leave,
"green": self.addCurrentTimer,
"log": self.showLog,
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down
}, -1)
self.setTitle(_("Timer overview"))
self.session.nav.RecordTimer.on_state_change.append(self.onStateChange)
self.onShown.append(self.updateState)
if self.isProtected() and config.ParentalControl.servicepin[0].value:
self.onFirstExecBegin.append(boundFunction(self.session.openWithCallback, self.pinEntered, PinInput, pinList=[x.value for x in config.ParentalControl.servicepin], triesEntry=config.ParentalControl.retries.servicepin, title=_("Please enter the correct pin code"), windowTitle=_("Enter pin code")))
self.fallbackTimer = FallbackTimerList(self, self.fillTimerList)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and (not config.ParentalControl.config_sections.main_menu.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and config.ParentalControl.config_sections.timer_menu.value
def pinEntered(self, result):
if result is None:
self.closeProtectedScreen()
elif not result:
self.session.openWithCallback(self.close(), MessageBox, _("The pin code you entered is wrong."), MessageBox.TYPE_ERROR, timeout=3)
def closeProtectedScreen(self, result=None):
self.close(None)
def up(self):
self["timerlist"].instance.moveSelection(self["timerlist"].instance.moveUp)
self.updateState()
def down(self):
self["timerlist"].instance.moveSelection(self["timerlist"].instance.moveDown)
self.updateState()
def left(self):
self["timerlist"].instance.moveSelection(self["timerlist"].instance.pageUp)
self.updateState()
def right(self):
self["timerlist"].instance.moveSelection(self["timerlist"].instance.pageDown)
self.updateState()
def toggleDisabledState(self):
cur = self["timerlist"].getCurrent()
timer_changed = True
if cur:
t = cur
if t.external:
self.fallbackTimer.toggleTimer(t, self.refill)
else:
stateRunning = t.state in (1, 2)
if t.disabled and t.repeated and stateRunning and not t.justplay:
return
if t.disabled:
print "[TimerEditList] try to ENABLE timer"
t.enable()
timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, cur)
if not timersanitycheck.check():
t.disable()
print "[TimerEditList] sanity check failed"
simulTimerList = timersanitycheck.getSimulTimerList()
if simulTimerList is not None:
self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, simulTimerList)
timer_changed = False
else:
print "[TimerEditList] sanity check passed"
if timersanitycheck.doubleCheck():
t.disable()
else:
if stateRunning:
if t.isRunning() and t.repeated:
list = (
(_("Stop current event but not coming events"), "stoponlycurrent"),
(_("Stop current event and disable coming events"), "stopall"),
(_("Don't stop current event but disable coming events"), "stoponlycoming")
)
self.session.openWithCallback(boundFunction(self.runningEventCallback, t), ChoiceBox, title=_("Repeating event currently recording... What do you want to do?"), list = list)
timer_changed = False
else:
t.disable()
if timer_changed:
self.session.nav.RecordTimer.timeChanged(t)
self.refill()
def runningEventCallback(self, t, result):
if result is not None and t.isRunning():
findNextRunningEvent = True
if result[1] == "stoponlycurrent" or result[1] == "stopall":
findNextRunningEvent = False
t.enable()
t.processRepeated(findRunningEvent = False)
self.session.nav.RecordTimer.doActivate(t)
if result[1] == "stoponlycoming" or result[1] == "stopall":
findNextRunningEvent = True
t.disable()
self.session.nav.RecordTimer.timeChanged(t)
t.findRunningEvent = findNextRunningEvent
self.refill()
def removeAction(self, descr):
actions = self["actions"].actions
if descr in actions:
del actions[descr]
def updateState(self):
cur = self["timerlist"].getCurrent()
if cur:
if cur.external:
self["key_info"].setText("")
else:
self["key_info"].setText(_("Info"))
text = cur.description
if not cur.conflict_detection:
text += _("\nConflict detection disabled!")
self["description"].setText(text)
stateRunning = cur.state in (1, 2)
if cur.state == 2 and self.key_red_choice != self.STOP:
self["actions"].actions.update({"red":self.stopTimerQuestion})
self["key_red"].setText(_("Stop"))
self.key_red_choice = self.STOP
elif cur.state != 2 and self.key_red_choice != self.DELETE:
self["actions"].actions.update({"red":self.removeTimerQuestion})
self["key_red"].setText(_("Delete"))
self.key_red_choice = self.DELETE
if cur.disabled and (self.key_yellow_choice != self.ENABLE):
if stateRunning and cur.repeated and not cur.justplay:
self.removeAction("yellow")
self["key_yellow"].setText(" ")
self.key_yellow_choice = self.EMPTY
else:
self["actions"].actions.update({"yellow":self.toggleDisabledState})
self["key_yellow"].setText(_("Enable"))
self.key_yellow_choice = self.ENABLE
elif stateRunning and (not cur.repeated or cur.state == 1) and (self.key_yellow_choice != self.EMPTY):
self.removeAction("yellow")
self["key_yellow"].setText(" ")
self.key_yellow_choice = self.EMPTY
elif (not stateRunning or cur.repeated and cur.isRunning()) and not cur.disabled and (self.key_yellow_choice != self.DISABLE):
self["actions"].actions.update({"yellow":self.toggleDisabledState})
self["key_yellow"].setText(_("Disable"))
self.key_yellow_choice = self.DISABLE
else:
self["description"].setText(" ")
if self.key_red_choice != self.EMPTY:
self.removeAction("red")
self["key_red"].setText(" ")
self.key_red_choice = self.EMPTY
if self.key_yellow_choice != self.EMPTY:
self.removeAction("yellow")
self["key_yellow"].setText(" ")
self.key_yellow_choice = self.EMPTY
showCleanup = True
for x in self.list:
if (not x[0].disabled) and (x[1] == True):
break
else:
showCleanup = False
if showCleanup and (self.key_blue_choice != self.CLEANUP):
self["actions"].actions.update({"blue":self.cleanupQuestion})
self["key_blue"].setText(_("Cleanup"))
self.key_blue_choice = self.CLEANUP
elif (not showCleanup) and (self.key_blue_choice != self.EMPTY):
self.removeAction("blue")
self["key_blue"].setText(" ")
self.key_blue_choice = self.EMPTY
def fillTimerList(self):
def eol_compare(x, y):
if x[0].state != y[0].state and x[0].state == RealTimerEntry.StateEnded or y[0].state == RealTimerEntry.StateEnded:
return cmp(x[0].state, y[0].state)
return cmp(x[0].begin, y[0].begin)
self.list = []
if self.fallbackTimer.list:
self.list.extend([(timer, False) for timer in self.fallbackTimer.list if timer.state != 3])
self.list.extend([(timer, True) for timer in self.fallbackTimer.list if timer.state == 3])
self.list.extend([(timer, False) for timer in self.session.nav.RecordTimer.timer_list])
self.list.extend([(timer, True) for timer in self.session.nav.RecordTimer.processed_timers])
if config.usage.timerlist_finished_timer_position.index: #end of list
self.list.sort(cmp = eol_compare)
else:
self.list.sort(key = lambda x: x[0].begin)
self["timerlist"].l.setList(self.list)
self.updateState()
def showLog(self):
cur = self["timerlist"].getCurrent()
if cur and not cur.external:
self.session.openWithCallback(self.finishedEdit, TimerLog, cur)
else:
return 0
def openEdit(self):
cur = self["timerlist"].getCurrent()
if cur:
self.session.openWithCallback(self.finishedEdit, TimerEntry, cur)
def cleanupQuestion(self):
self.session.openWithCallback(self.cleanupTimer, MessageBox, _("Really delete done timers?"))
def cleanupTimer(self, delete):
if delete:
self.session.nav.RecordTimer.cleanup()
self.fallbackTimer.cleanupTimers(self.refill)
def stopTimerQuestion(self):
cur = self["timerlist"].getCurrent()
if cur:
self.session.openWithCallback(self.removeTimer, MessageBox, _("Do you really want to stop current event and delete timer %s?") % (cur.name))
def removeTimerQuestion(self):
cur = self["timerlist"].getCurrent()
if cur:
self.session.openWithCallback(self.removeTimer, MessageBox, _("Do you really want to delete %s?") % (cur.name))
def removeTimer(self, result=True):
if result:
cur = self["timerlist"].getCurrent()
if cur:
if cur.external:
self.fallbackTimer.removeTimer(cur, self.refill)
else:
cur.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(cur)
self.refill()
def refill(self):
oldsize = len(self.list)
self.fillTimerList()
lst = self["timerlist"]
newsize = len(self.list)
if oldsize and oldsize != newsize:
idx = lst.getCurrentIndex()
lst.entryRemoved(idx)
else:
lst.invalidate()
self.updateState()
def addCurrentTimer(self):
event = None
service = self.session.nav.getCurrentService()
if service is not None:
info = service.info()
if info is not None:
event = info.getEvent(0)
# FIXME only works if already playing a service
serviceref = ServiceReference(self.session.nav.getCurrentlyPlayingServiceOrGroup())
if event is None:
data = (int(time()), int(time() + 60), "", "", None)
else:
data = parseEvent(event, description = False)
self.addTimer(RecordTimerEntry(serviceref, checkOldTimers = True, dirname = preferredTimerPath(), *data))
def addTimer(self, timer):
self.session.openWithCallback(self.finishedAdd, TimerEntry, timer)
def finishedEdit(self, answer):
print "[TimerEditList] finished edit"
if answer[0]:
entry = answer[1]
if entry.external_prev != entry.external:
def removeEditTimer():
entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev
self.removeTimer()
def moveEditTimerError():
entry.external = entry.external_prev
self.refill()
if entry.external:
self.fallbackTimer.addTimer(entry, removeEditTimer, moveEditTimerError)
else:
newentry = createRecordTimerEntry(entry)
entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev
self.fallbackTimer.removeTimer(entry, boundFunction(self.finishedAdd, (True, newentry)), moveEditTimerError)
elif entry.external:
self.fallbackTimer.editTimer(entry, self.refill)
else:
timersanitycheck = TimerSanityCheck(self.session.nav.RecordTimer.timer_list, entry)
success = False
if not timersanitycheck.check():
simulTimerList = timersanitycheck.getSimulTimerList()
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
if not timersanitycheck.check():
simulTimerList = timersanitycheck.getSimulTimerList()
if simulTimerList is not None:
self.session.openWithCallback(self.finishedEdit, TimerSanityConflict, timersanitycheck.getSimulTimerList())
else:
success = True
else:
success = True
if success:
print "[TimerEditList] sanity check passed"
self.session.nav.RecordTimer.timeChanged(entry)
self.fillTimerList()
def finishedAdd(self, answer):
print "[TimerEditList] finished add"
if answer[0]:
entry = answer[1]
if entry.external:
self.fallbackTimer.addTimer(entry, self.refill)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
self.fillTimerList()
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def leave(self):
self.session.nav.RecordTimer.on_state_change.remove(self.onStateChange)
self.close()
def onStateChange(self, entry):
self.refill()
def __init__(self,
event,
serviceRef,
callback=None,
similarEPGCB=None,
parent=None,
windowTitle=None):
self.event = event
self.serviceRef = serviceRef
self.callbackMethod = callback
if similarEPGCB is None:
self.similarBroadcastTimer = None
else:
self.similarBroadcastTimer = eTimer()
self.similarBroadcastTimer.callback.append(self.getSimilarEvents)
self.similarEPGCB = similarEPGCB
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.layoutFinished)
else:
self.fallbackTimer = FallbackTimerList(self, self.layoutFinished)
self.windowTitle = windowTitle
self.isRecording = (
not serviceRef.ref.flags
& eServiceReference.isGroup) and serviceRef.ref.getPath()
self["channel"] = Label()
self["datetime"] = Label()
self["duration"] = Label()
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["epg_eventname"] = ScrollLabel()
self["epg_description"] = ScrollLabel()
self["FullDescription"] = ScrollLabel()
self["key_red"] = StaticText("")
self["key_green"] = StaticText(
"" if self.isRecording else _("Add Timer"))
self.keyGreenAction = self.ADD_TIMER
self["key_menu"] = StaticText(_("MENU"))
self["key_info"] = StaticText(_("INFO"))
self["actions"] = HelpableActionMap(
self, ["OkCancelActions", "EventViewActions"], {
"cancel": (self.close, _("Close Event View screen")),
"ok": (self.close, _("Close Event View screen")),
"contextMenu": (self.doContext, _("Open context menu")),
"timerAdd":
(self.addTimer, _("Add a timer for the current event")),
"pageUp":
(self.pageUp, _("Show previous page of description")),
"pageDown": (self.pageDown, _("Show next page of description"))
},
prio=0,
description=_("Event View Actions"))
self["eventActions"] = HelpableActionMap(
self, ["EventViewActions"], {
"prevEvent": (self.prevEvent, _("Show previous event")),
"nextEvent": (self.nextEvent, _("Show next event"))
},
prio=0,
description=_("Event View Actions"))
self["eventActions"].setEnabled(callback is not None)
self["similarActions"] = HelpableActionMap(
self, ["EventViewActions"], {
"openSimilarList":
(self.openSimilarList, _("Find similar events in the EPG"))
},
prio=0,
description=_("Event View Actions"))
self["similarActions"].setEnabled(False)
class EventViewBase:
ADD_TIMER = 0
REMOVE_TIMER = 1
def __init__(self,
event,
serviceRef,
callback=None,
similarEPGCB=None,
parent=None,
windowTitle=None):
self.event = event
self.serviceRef = serviceRef
self.callbackMethod = callback
if similarEPGCB is None:
self.similarBroadcastTimer = None
else:
self.similarBroadcastTimer = eTimer()
self.similarBroadcastTimer.callback.append(self.getSimilarEvents)
self.similarEPGCB = similarEPGCB
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.layoutFinished)
else:
self.fallbackTimer = FallbackTimerList(self, self.layoutFinished)
self.windowTitle = windowTitle
self.isRecording = (
not serviceRef.ref.flags
& eServiceReference.isGroup) and serviceRef.ref.getPath()
self["channel"] = Label()
self["datetime"] = Label()
self["duration"] = Label()
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["epg_eventname"] = ScrollLabel()
self["epg_description"] = ScrollLabel()
self["FullDescription"] = ScrollLabel()
self["key_red"] = StaticText("")
self["key_green"] = StaticText(
"" if self.isRecording else _("Add Timer"))
self.keyGreenAction = self.ADD_TIMER
self["key_menu"] = StaticText(_("MENU"))
self["key_info"] = StaticText(_("INFO"))
self["actions"] = HelpableActionMap(
self, ["OkCancelActions", "EventViewActions"], {
"cancel": (self.close, _("Close Event View screen")),
"ok": (self.close, _("Close Event View screen")),
"contextMenu": (self.doContext, _("Open context menu")),
"timerAdd":
(self.addTimer, _("Add a timer for the current event")),
"pageUp":
(self.pageUp, _("Show previous page of description")),
"pageDown": (self.pageDown, _("Show next page of description"))
},
prio=0,
description=_("Event View Actions"))
self["eventActions"] = HelpableActionMap(
self, ["EventViewActions"], {
"prevEvent": (self.prevEvent, _("Show previous event")),
"nextEvent": (self.nextEvent, _("Show next event"))
},
prio=0,
description=_("Event View Actions"))
self["eventActions"].setEnabled(callback is not None)
self["similarActions"] = HelpableActionMap(
self, ["EventViewActions"], {
"openSimilarList":
(self.openSimilarList, _("Find similar events in the EPG"))
},
prio=0,
description=_("Event View Actions"))
self["similarActions"].setEnabled(False)
def layoutFinished(self):
self.setService(self.serviceRef)
self.setEvent(self.event)
def pageUp(self):
self["epg_eventname"].pageUp()
self["epg_description"].pageUp()
self["FullDescription"].pageUp()
def pageDown(self):
self["epg_eventname"].pageDown()
self["epg_description"].pageDown()
self["FullDescription"].pageDown()
def prevEvent(self):
self.callbackMethod(self.setEvent, self.setService, -1)
def nextEvent(self):
self.callbackMethod(self.setEvent, self.setService, +1)
def setService(self, service):
self.serviceRef = service
self["Service"].newService(service.ref)
serviceName = service.getServiceName()
self["channel"].setText(
"%s%s" % (serviceName if serviceName else _("Unknown Service"),
" - %s" % _("Recording") if self.isRecording else ""))
def setEvent(self, event):
self.event = event
self["Event"].newEvent(event)
if event is None:
return
eventName = event.getEventName().strip()
self.setTitle(
eventName if self.windowTitle is None else self.windowTitle)
self["epg_eventname"].setText(eventName)
shortDescription = dropEPGNewLines(event.getShortDescription().strip())
extentedDescription = dropEPGNewLines(
event.getExtendedDescription().strip())
description = [shortDescription, extentedDescription]
if shortDescription == extentedDescription:
del description[1]
if eventName == shortDescription:
del description[0]
description = replaceEPGSeparator(
config.epg.fulldescription_separator.value).join(description)
self["epg_description"].setText(description)
self["FullDescription"].setText(extentedDescription)
begin = event.getBeginTime()
beginTime = localtime(begin)
duration = event.getDuration()
endTime = localtime(begin + duration)
self["datetime"].setText("%s - %s" % (strftime(
"%s, %s" %
(config.usage.date.daylong.value, config.usage.time.short.value),
beginTime), strftime(config.usage.time.short.value, endTime)))
self["duration"].setText(_("%d min") % (duration // 60))
self["key_red"].setText("")
self["similarActions"].setEnabled(False)
if self.similarBroadcastTimer:
self.similarBroadcastTimer.start(25, True)
self.setTimerState()
def addTimer(self):
if self.isRecording or self.event is None:
return
timer, isRecordEvent = self.doesTimerExist()
if timer and isRecordEvent:
menu = [(_("Delete Timer"), "delete"), (_("Edit Timer"), "edit")]
buttons = ["red", "green"]
def timerAction(choice):
if choice is not None:
if choice[1] == "delete":
self.removeTimer(timer)
elif choice[1] == "edit":
self.session.openWithCallback(self.finishedEdit,
TimerEntry, timer)
text = [_("Select action for timer '%s'.") % timer.name]
if timer.repeated:
text.insert(0, _("Attention, this is a repeated timer!"))
self.session.openWithCallback(timerAction,
ChoiceBox,
text="\n".join(text),
list=menu,
keys=buttons)
else:
newEntry = RecordTimerEntry(self.serviceRef,
checkOldTimers=True,
dirname=preferredTimerPath(),
*parseEvent(self.event))
newEntry.justplay = config.recording.timer_default_type.value == "zap"
newEntry.always_zap = config.recording.timer_default_type.value == "zap+record"
self.session.openWithCallback(self.finishedAdd, TimerEntry,
newEntry)
def finishedEdit(self, answer):
if answer[0]:
entry = answer[1]
if entry.external_prev != entry.external:
def removeEditTimer():
entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev
self.removeTimer(entry)
def moveEditTimerError():
entry.external = entry.external_prev
self.onSelectionChanged()
if entry.external:
self.fallbackTimer.addTimer(entry, removeEditTimer,
moveEditTimerError)
else:
newEntry = createRecordTimerEntry(entry)
entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev
self.fallbackTimer.removeTimer(
entry, boundFunction(self.finishedAdd,
(True, newEntry)),
moveEditTimerError)
elif entry.external:
self.fallbackTimer.editTimer(entry, self.setTimerState)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList:
for simulTimer in simulTimerList:
if simulTimer.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(
simulTimer)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList:
self.session.openWithCallback(self.finishedEdit,
TimerSanityConflict,
simulTimerList)
return
else:
self.session.nav.RecordTimer.timeChanged(entry)
if answer is not None and len(answer) > 1:
entry = answer[1]
if not entry.disabled:
self["key_green"].setText(_("Change Timer"))
self.keyGreenAction = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add Timer"))
self.keyGreenAction = self.ADD_TIMER
def finishedAdd(self, answer):
if answer[0]:
entry = answer[1]
if entry.external:
self.fallbackTimer.addTimer(entry, self.setTimerState)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList:
for simulTimer in simulTimerList:
if simulTimer.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(
simulTimer)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList:
if not entry.repeated and not config.recording.margin_before.value and not config.recording.margin_after.value and len(
simulTimerList) > 1:
changeTime = False
conflictBegin = simulTimerList[1].begin
conflictEnd = simulTimerList[1].end
if conflictBegin == entry.end:
entry.end -= 30
changeTime = True
elif entry.begin == conflictEnd:
entry.begin += 30
changeTime = True
elif entry.begin == conflictBegin and (
entry.service_ref and entry.service_ref.ref
and entry.service_ref.ref.flags
& eServiceReference.isGroup):
entry.begin += 30
changeTime = True
if changeTime:
simulTimerList = self.session.nav.RecordTimer.record(
entry)
if simulTimerList:
self.session.openWithCallback(
self.finishSanityCorrection,
TimerSanityConflict, simulTimerList)
self["key_green"].setText(_("Change Timer"))
self.keyGreenAction = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add Timer"))
self.keyGreenAction = self.ADD_TIMER
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def setTimerState(self):
timer, isRecordEvent = self.doesTimerExist()
if isRecordEvent and self.keyGreenAction != self.REMOVE_TIMER:
self["key_green"].setText(_("Change Timer"))
self.keyGreenAction = self.REMOVE_TIMER
elif not isRecordEvent and self.keyGreenAction != self.ADD_TIMER:
self["key_green"].setText(_("Add Timer"))
self.keyGreenAction = self.ADD_TIMER
def doesTimerExist(self):
eventId = self.event.getEventId()
begin = self.event.getBeginTime()
end = begin + self.event.getDuration()
refStr = ":".join(self.serviceRef.ref.toString().split(":")[:11])
isRecordEvent = False
for timer in self.session.nav.RecordTimer.getAllTimersList():
neededRef = ":".join(
timer.service_ref.ref.toString().split(":")[:11]) == refStr
if neededRef and (timer.eit == eventId and
(begin < timer.begin <= end
or timer.begin <= begin <= timer.end)
or timer.repeated
and self.session.nav.RecordTimer.isInRepeatTimer(
timer, self.event)):
isRecordEvent = True
break
else:
timer = None
return timer, isRecordEvent
def removeTimer(self, timer):
if timer.external:
self.fallbackTimer.removeTimer(timer, self.setTimerState)
else:
timer.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(timer)
self["key_green"].setText(_("Add Timer"))
self.keyGreenAction = self.ADD_TIMER
def getSimilarEvents(self):
if not self.event:
return
serviceRef = str(self.serviceRef)
id = self.event.getEventId()
epgcache = eEPGCache.getInstance()
results = epgcache.search(
("NB", 100, eEPGCache.SIMILAR_BROADCASTINGS_SEARCH, serviceRef,
id))
if results:
similar = [_("Similar broadcasts:")]
timeFormat = "%s, %s" % (config.usage.date.long.value,
config.usage.time.short.value)
for result in sorted(results, key=lambda x: x[1]):
similar.append(
"%s - %s" %
(strftime(timeFormat, localtime(result[1])), result[0]))
self["epg_description"].setText(
"%s\n\n%s" %
(self["epg_description"].getText(), "\n".join(similar)))
self["FullDescription"].setText(
"%s\n\n%s" %
(self["FullDescription"].getText(), "\n".join(similar)))
if self.similarEPGCB:
self["key_red"].setText(_("Similar"))
self["similarActions"].setEnabled(True)
def openSimilarList(self):
id = self.event and self.event.getEventId()
serviceRef = str(self.serviceRef)
if id:
self.similarEPGCB(id, serviceRef)
def doContext(self):
if self.event:
if PY2:
menu = [
(p.name, boundFunction(self.runPlugin, p))
for p in plugins.getPlugins(
where=PluginDescriptor.WHERE_EVENTINFO)
if "servicelist" not in p.__call__.func_code.co_varnames
if "selectedevent" not in p.__call__.func_code.co_varnames
]
else:
menu = [
(p.name, boundFunction(self.runPlugin, p))
for p in plugins.getPlugins(
where=PluginDescriptor.WHERE_EVENTINFO)
if "servicelist" not in p.__call__.__code__.co_varnames
if "selectedevent" not in p.__call__.__code__.co_varnames
]
if len(menu) == 1:
menu and menu[0][1]()
elif len(menu) > 1:
def boxAction(choice):
if choice:
choice[1]()
text = "%s: %s" % (_("Select action"),
self.event.getEventName())
self.session.openWithCallback(
boxAction,
ChoiceBox,
text=text,
list=menu,
windowTitle=_("Event View Context Menu"))
def runPlugin(self, plugin):
plugin.__call__(session=self.session,
service=self.serviceRef,
event=self.event,
eventName=self.event.getEventName())
def __init__(self,
event,
Ref,
callback=None,
similarEPGCB=None,
parent=None):
self.similarEPGCB = similarEPGCB
self.cbFunc = callback
self.currentService = Ref
self.isRecording = (not Ref.ref.flags
& eServiceReference.isGroup) and Ref.ref.getPath()
self.event = event
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["epg_eventname"] = ScrollLabel()
self["epg_description"] = ScrollLabel()
self["FullDescription"] = ScrollLabel()
self["datetime"] = Label()
self["channel"] = Label()
self["duration"] = Label()
if self['Event'] == StaticText:
self["key_red"] = StaticText("")
else:
self["key_red"] = Button("")
if similarEPGCB is not None:
self.SimilarBroadcastTimer = eTimer()
self.SimilarBroadcastTimer.callback.append(self.getSimilarEvents)
else:
self.SimilarBroadcastTimer = None
self.key_green_choice = self.ADD_TIMER
if self.isRecording:
if self["Event"] == StaticText:
self["key_green"] = StaticText("")
else:
self["key_green"] = Button("")
else:
if self["Event"] == StaticText:
self["key_green"] = StaticText(_("Add timer"))
else:
self["key_green"] = Button(_("Add timer"))
if self["Event"] == StaticText:
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
else:
self["key_yellow"] = Button("")
self["key_blue"] = Button("")
self["actions"] = ActionMap(
["OkCancelActions", "EventViewActions"], {
"cancel": self.close,
"ok": self.close,
"pageUp": self.pageUp,
"pageDown": self.pageDown,
"prevEvent": self.prevEvent,
"nextEvent": self.nextEvent,
"timerAdd": self.timerAdd,
"openSimilarList": self.openSimilarList,
"contextMenu": self.doContext,
})
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def __init__(self, session, service, zapFunc=None, eventid=None, bouquetChangeCB=None, serviceChangeCB=None, parent=None):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
self.ask_time = -1 #now
self["key_red"] = StaticText("")
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.session = session
if isinstance(service, str) and eventid is not None:
self.type = EPG_TYPE_SIMILAR
self.setTitle(_("Similar EPG"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["key_red"] = StaticText()
self.currentService=service
self.eventid = eventid
self.zapFunc = None
elif isinstance(service, eServiceReference) or isinstance(service, str):
self.setTitle(_("Single EPG"))
self.type = EPG_TYPE_SINGLE
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Select Channel"))
self.currentService=ServiceReference(service)
self.zapFunc = zapFunc
self.sort_type = 0
self.setSortDescription()
else:
self.setTitle(_("Multi EPG"))
self.skinName = "EPGSelectionMulti"
self.type = EPG_TYPE_MULTI
self["key_yellow"] = StaticText(pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = StaticText(pgettext("button label, 'next screen'", "Next"))
self["now_button"] = Pixmap()
self["next_button"] = Pixmap()
self["more_button"] = Pixmap()
self["now_button_sel"] = Pixmap()
self["next_button_sel"] = Pixmap()
self["more_button_sel"] = Pixmap()
self["now_text"] = Label()
self["next_text"] = Label()
self["more_text"] = Label()
self["date"] = Label()
self.services = service
self.zapFunc = zapFunc
self.parent = parent
self["key_green"] = StaticText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGList(type = self.type, selChangedCB = self.onSelectionChanged, timer = session.nav.RecordTimer)
self["actions"] = ActionMap(["EPGSelectActions", "OkCancelActions"],
{
"cancel": self.closeScreen,
"ok": self.eventSelected,
"timerAdd": self.timerAdd,
"yellow": self.yellowButtonPressed,
"blue": self.blueButtonPressed,
"info": self.infoKeyPressed,
"red": self.zapTo,
"menu": self.furtherOptions,
"nextBouquet": self.nextBouquet, # just used in multi epg yet
"prevBouquet": self.prevBouquet, # just used in multi epg yet
"nextService": self.nextService, # just used in single epg yet
"prevService": self.prevService, # just used in single epg yet
"preview": self.eventPreview,
})
self["actions"].csel = self
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
class EPGSelection(Screen):
EMPTY = 0
ADD_TIMER = 1
REMOVE_TIMER = 2
ZAP = 1
def __init__(self, session, service, zapFunc=None, eventid=None, bouquetChangeCB=None, serviceChangeCB=None, parent=None):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
self.ask_time = -1 #now
self["key_red"] = StaticText("")
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.session = session
if isinstance(service, str) and eventid is not None:
self.type = EPG_TYPE_SIMILAR
self.setTitle(_("Similar EPG"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["key_red"] = StaticText()
self.currentService=service
self.eventid = eventid
self.zapFunc = None
elif isinstance(service, eServiceReference) or isinstance(service, str):
self.setTitle(_("Single EPG"))
self.type = EPG_TYPE_SINGLE
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Select Channel"))
self.currentService=ServiceReference(service)
self.zapFunc = zapFunc
self.sort_type = 0
self.setSortDescription()
else:
self.setTitle(_("Multi EPG"))
self.skinName = "EPGSelectionMulti"
self.type = EPG_TYPE_MULTI
self["key_yellow"] = StaticText(pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = StaticText(pgettext("button label, 'next screen'", "Next"))
self["now_button"] = Pixmap()
self["next_button"] = Pixmap()
self["more_button"] = Pixmap()
self["now_button_sel"] = Pixmap()
self["next_button_sel"] = Pixmap()
self["more_button_sel"] = Pixmap()
self["now_text"] = Label()
self["next_text"] = Label()
self["more_text"] = Label()
self["date"] = Label()
self.services = service
self.zapFunc = zapFunc
self.parent = parent
self["key_green"] = StaticText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGList(type = self.type, selChangedCB = self.onSelectionChanged, timer = session.nav.RecordTimer)
self["actions"] = ActionMap(["EPGSelectActions", "OkCancelActions"],
{
"cancel": self.closeScreen,
"ok": self.eventSelected,
"timerAdd": self.timerAdd,
"yellow": self.yellowButtonPressed,
"blue": self.blueButtonPressed,
"info": self.infoKeyPressed,
"red": self.zapTo,
"menu": self.furtherOptions,
"nextBouquet": self.nextBouquet, # just used in multi epg yet
"prevBouquet": self.prevBouquet, # just used in multi epg yet
"nextService": self.nextService, # just used in single epg yet
"prevService": self.prevService, # just used in single epg yet
"preview": self.eventPreview,
})
self["actions"].csel = self
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def nextBouquet(self):
if self.type == EPG_TYPE_SINGLE:
self.session.openWithCallback(self.channelSelectionCallback, ChannelSelection.SimpleChannelSelection, _("Select channel"), True, True, self.currentService.ref, self.parent and self.parent.epg_bouquet)
if self.bouquetChangeCB:
self.bouquetChangeCB(1, self)
def prevBouquet(self):
if self.type == EPG_TYPE_SINGLE:
self.session.openWithCallback(self.channelSelectionCallback, ChannelSelection.SimpleChannelSelection, _("Select channel"), True, True, self.currentService.ref, self.parent and self.parent.epg_bouquet)
if self.bouquetChangeCB:
self.bouquetChangeCB(-1, self)
def nextService(self):
if self.serviceChangeCB:
self.serviceChangeCB(1, self)
def prevService(self):
if self.serviceChangeCB:
self.serviceChangeCB(-1, self)
def enterDateTime(self):
if self.type == EPG_TYPE_MULTI:
global mepg_config_initialized
if not mepg_config_initialized:
config.misc.prev_mepg_time=ConfigClock(default = time())
mepg_config_initialized = True
self.session.openWithCallback(self.onDateTimeInputClosed, TimeDateInput, config.misc.prev_mepg_time )
def furtherOptions(self):
menu = []
text = _("Select action")
event = self["list"].getCurrent()[0]
if event:
menu = [(p.name, boundFunction(self.runPlugin, p)) for p in plugins.getPlugins(where = PluginDescriptor.WHERE_EVENTINFO) \
if 'selectedevent' in p.__call__.func_code.co_varnames]
if menu:
text += ": %s" % event.getEventName()
if self.type == EPG_TYPE_MULTI:
menu.append((_("Goto specific date/time"),self.enterDateTime))
menu.append((_("Timer Overview"), self.openTimerOverview))
if len(menu) == 1:
menu and menu[0][1]()
elif len(menu) > 1:
def boxAction(choice):
if choice:
choice[1]()
self.session.openWithCallback(boxAction, ChoiceBox, title=text, list=menu, windowTitle=_("Further options"))
def runPlugin(self, plugin):
event = self["list"].getCurrent()
plugin(session=self.session, selectedevent=event)
def openTimerOverview(self):
self.session.open(TimerEditList)
def onDateTimeInputClosed(self, ret):
if len(ret) > 1:
if ret[0]:
self.ask_time=ret[1]
self["list"].fillMultiEPG(self.services, ret[1])
def closeScreen(self):
if self.zapFunc:
self.zapFunc(None, zapback = True)
self.close(self.closeRecursive)
def infoKeyPressed(self):
cur = self["list"].getCurrent()
event = cur[0]
service = cur[1]
if event is not None:
if self.type != EPG_TYPE_SIMILAR:
self.session.open(EventViewSimple, event, service, self.eventViewCallback, self.openSimilarList, parent=self.parent)
else:
self.session.open(EventViewSimple, event, service, self.eventViewCallback, parent=self.parent)
def openSimilarList(self, eventid, refstr):
self.session.open(EPGSelection, refstr, None, eventid)
def setServices(self, services):
self.services = services
self.onCreate()
def setService(self, service):
self.currentService = service
self.onCreate()
#just used in multipeg
def onCreate(self):
l = self["list"]
l.recalcEntrySize()
if self.type == EPG_TYPE_MULTI:
l.fillMultiEPG(self.services, self.ask_time)
l.moveToService(Screens.InfoBar.InfoBar.instance and Screens.InfoBar.InfoBar.instance.servicelist.getCurrentSelection() or self.session.nav.getCurrentlyPlayingServiceOrGroup())
elif self.type == EPG_TYPE_SINGLE:
service = self.currentService
self["Service"].newService(service.ref)
if not self.saved_title:
self.saved_title = self.instance.getTitle()
self.setTitle(self.saved_title + ' - ' + service.getServiceName())
l.fillSingleEPG(service)
else:
l.fillSimilarList(self.currentService, self.eventid)
def eventViewCallback(self, setEvent, setService, val):
l = self["list"]
old = l.getCurrent()
if val == -1:
self.moveUp()
elif val == +1:
self.moveDown()
cur = l.getCurrent()
if self.type == EPG_TYPE_MULTI and cur[0] is None and cur[1].ref != old[1].ref:
self.eventViewCallback(setEvent, setService, val)
else:
setService(cur[1])
setEvent(cur[0])
def zapTo(self):
if self.key_red_choice == self.ZAP and self.zapFunc:
self.closeRecursive = True
from Components.ServiceEventTracker import InfoBarCount
if InfoBarCount > 1:
self.eventPreview()
else:
self.zapSelectedService()
self.close(self.closeRecursive)
def zapSelectedService(self, prev=False):
lst = self["list"]
count = lst.getCurrentChangeCount()
if count == 0:
ref = lst.getCurrent()[1]
if ref is not None:
self.zapFunc(ref.ref, preview = prev)
def eventPreview(self):
if self.zapFunc:
# if enabled, then closed whole EPG with EXIT:
# self.closeRecursive = True
self.zapSelectedService(True)
def eventSelected(self):
if self.skinName == "EPGSelectionMulti":
cur = self["list"].getCurrent()
event = cur[0]
ref = cur[1] and cur[1].ref.toString()
if ref and event:
self.session.open(EPGSelection, ref)
else:
self.infoKeyPressed()
def yellowButtonPressed(self):
if self.type == EPG_TYPE_MULTI:
self["list"].updateMultiEPG(-1)
elif self.type == EPG_TYPE_SINGLE:
if self.sort_type == 0:
self.sort_type = 1
else:
self.sort_type = 0
self["list"].sortSingleEPG(self.sort_type)
self.setSortDescription()
def setSortDescription(self):
if self.sort_type == 1:
# TRANSLATORS: This must fit into the header button in the EPG-List
self["key_yellow"].setText(_("Sort time"))
else:
# TRANSLATORS: This must fit into the header button in the EPG-List
self["key_yellow"].setText(_("Sort A-Z"))
def blueButtonPressed(self):
if self.type == EPG_TYPE_MULTI:
self["list"].updateMultiEPG(1)
if self.type == EPG_TYPE_SINGLE:
self.session.openWithCallback(self.channelSelectionCallback, ChannelSelection.SimpleChannelSelection, _("Select channel"), True, True, self.currentService.ref, self.parent and self.parent.epg_bouquet)
def channelSelectionCallback(self, *args):
if args and len(args) == 2:
serviceref, bouquetref = args[:2]
if self.parent:
self.parent.selectBouquet(bouquetref, self)
self.setService(ServiceReference(serviceref))
def removeTimer(self, timer):
if timer.external:
self.fallbackTimer.removeTimer(timer, self.onSelectionChanged)
else:
timer.afterEvent = AFTEREVENT.NONE
self.session.nav.RecordTimer.removeEntry(timer)
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def disableTimer(self, timer, state, repeat=False, record=False):
if repeat:
if record:
title_text = _("Repeating event currently recording.\nWhat do you want to do?")
menu = [(_("Stop current event but not coming events"), "stoponlycurrent"),(_("Stop current event and disable coming events"), "stopall")]
if not timer.disabled:
menu.append((_("Don't stop current event but disable coming events"), "stoponlycoming"))
else:
title_text = _("Attention, this is repeated timer!\nWhat do you want to do?")
menu = [(_("Disable current event but not coming events"), "nextonlystop"),(_("Disable timer"), "simplestop")]
self.session.openWithCallback(boundFunction(self.runningEventCallback, timer, state), ChoiceBox, title=title_text, list=menu)
elif timer.state == state:
if timer.external:
self.fallbackTimer.toggleTimer(timer, self.onSelectionChanged)
else:
timer.disable()
self.session.nav.RecordTimer.timeChanged(timer)
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def runningEventCallback(self, t, state, result):
if result is not None and t.state == state:
findNextRunningEvent = True
findEventNext = False
if result[1] == "nextonlystop":
findEventNext = True
t.disable()
self.session.nav.RecordTimer.timeChanged(t)
t.processRepeated(findNextEvent=True)
t.enable()
if result[1] in ("stoponlycurrent", "stopall"):
findNextRunningEvent = False
t.enable()
t.processRepeated(findRunningEvent=False)
self.session.nav.RecordTimer.doActivate(t)
if result[1] in ("stoponlycoming", "stopall", "simplestop"):
findNextRunningEvent = True
t.disable()
self.session.nav.RecordTimer.timeChanged(t)
t.findRunningEvent = findNextRunningEvent
t.findNextEvent = findEventNext
if result[1] in ("stoponlycurrent", "stopall", "simplestop", "nextonlystop"):
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
def timerAdd(self):
cur = self["list"].getCurrent()
event = cur[0]
if event is None:
return
serviceref = cur[1]
isRecordEvent = isRepeat = firstNextRepeatEvent = isRunning = False
eventid = event.getEventId()
begin = event.getBeginTime()
end = begin + event.getDuration()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and timer.eit == eventid and (begin < timer.begin <= end or timer.begin <= begin <= timer.end):
isRecordEvent = True
break
elif needed_ref and timer.repeated and self.session.nav.RecordTimer.isInRepeatTimer(timer, event):
isRecordEvent = True
break
if isRecordEvent:
isRepeat = timer.repeated
prev_state = timer.state
isRunning = prev_state in (1, 2)
title_text = isRepeat and _("Attention, this is repeated timer!\n") or ""
firstNextRepeatEvent = isRepeat and (begin < timer.begin <= end or timer.begin <= begin <= timer.end) and not timer.justplay
menu = [(_("Delete timer"), "delete"),(_("Edit timer"), "edit")]
buttons = ["red", "green"]
if not isRunning:
if firstNextRepeatEvent and timer.isFindRunningEvent() and not timer.isFindNextEvent():
menu.append((_("Options disable timer"), "disablerepeat"))
else:
menu.append((_("Disable timer"), "disable"))
buttons.append("yellow")
elif prev_state == 2 and firstNextRepeatEvent:
menu.append((_("Options disable timer"), "disablerepeatrunning"))
buttons.append("yellow")
menu.append((_("Timer Overview"), "timereditlist"))
def timerAction(choice):
if choice is not None:
if choice[1] == "delete":
self.removeTimer(timer)
elif choice[1] == "edit":
self.session.openWithCallback(self.finishedEdit, TimerEntry, timer)
elif choice[1] == "disable":
self.disableTimer(timer, prev_state)
elif choice[1] == "timereditlist":
self.session.open(TimerEditList)
elif choice[1] == "disablerepeatrunning":
self.disableTimer(timer, prev_state, repeat=True, record=True)
elif choice[1] == "disablerepeat":
self.disableTimer(timer, prev_state, repeat=True)
self.session.openWithCallback(timerAction, ChoiceBox, title=title_text + _("Select action for timer '%s'.") % timer.name, list=menu, keys=buttons)
else:
newEntry = RecordTimerEntry(serviceref, checkOldTimers = True, dirname = preferredTimerPath(), *parseEvent(event))
self.session.openWithCallback(self.finishedAdd, TimerEntry, newEntry)
def finishedEdit(self, answer):
if answer[0]:
entry = answer[1]
if entry.external_prev != entry.external:
def removeEditTimer():
entry.service_ref, entry.begin, entry.end, entry.external = entry.service_ref_prev, entry.begin_prev, entry.end_prev, entry.external_prev
self.removeTimer(entry)
def moveEditTimerError():
entry.external = entry.external_prev
self.onSelectionChanged()
if entry.external:
self.fallbackTimer.addTimer(entry, removeEditTimer, moveEditTimerError)
else:
newentry = createRecordTimerEntry(entry)
entry.service_ref, entry.begin, entry.end = entry.service_ref_prev, entry.begin_prev, entry.end_prev
self.fallbackTimer.removeTimer(entry, boundFunction(self.finishedAdd, (True, newentry)), moveEditTimerError)
elif entry.external:
self.fallbackTimer.editTimer(entry, self.onSelectionChanged)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(boundFunction(self.finishedEdit, service_ref, begin, end), TimerSanityConflict, simulTimerList)
return
else:
self.session.nav.RecordTimer.timeChanged(entry)
self.onSelectionChanged()
def finishedAdd(self, answer):
print "finished add"
if answer[0]:
entry = answer[1]
if entry.external:
self.fallbackTimer.addTimer(entry, self.onSelectionChanged)
else:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
for x in simulTimerList:
if x.setAutoincreaseEnd(entry):
self.session.nav.RecordTimer.timeChanged(x)
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
if not entry.repeated and not config.recording.margin_before.value and not config.recording.margin_after.value and len(simulTimerList) > 1:
change_time = False
conflict_begin = simulTimerList[1].begin
conflict_end = simulTimerList[1].end
if conflict_begin == entry.end:
entry.end -= 30
change_time = True
elif entry.begin == conflict_end:
entry.begin += 30
change_time = True
elif entry.begin == conflict_begin and (entry.service_ref and entry.service_ref.ref and entry.service_ref.ref.flags & eServiceReference.isGroup):
entry.begin += 30
change_time = True
if change_time:
simulTimerList = self.session.nav.RecordTimer.record(entry)
if simulTimerList is not None:
self.session.openWithCallback(self.finishSanityCorrection, TimerSanityConflict, simulTimerList)
return
cur = self["list"].getCurrent()
event = cur and cur[0]
if event:
begin = event.getBeginTime()
end = begin + event.getDuration()
if begin < entry.begin <= end or entry.begin <= begin <= entry.end:
self["key_green"].setText(_("Change timer"))
self.key_green_choice = self.REMOVE_TIMER
else:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
print "Timeredit aborted"
def finishSanityCorrection(self, answer):
self.finishedAdd(answer)
def moveUp(self):
self["list"].moveUp()
def moveDown(self):
self["list"].moveDown()
def applyButtonState(self, state):
if state == 0:
self["now_button"].hide()
self["now_button_sel"].hide()
self["next_button"].hide()
self["next_button_sel"].hide()
self["more_button"].hide()
self["more_button_sel"].hide()
self["now_text"].hide()
self["next_text"].hide()
self["more_text"].hide()
self["key_red"].setText("")
else:
if state == 1:
self["now_button_sel"].show()
self["now_button"].hide()
else:
self["now_button"].show()
self["now_button_sel"].hide()
if state == 2:
self["next_button_sel"].show()
self["next_button"].hide()
else:
self["next_button"].show()
self["next_button_sel"].hide()
if state == 3:
self["more_button_sel"].show()
self["more_button"].hide()
else:
self["more_button"].show()
self["more_button_sel"].hide()
def onSelectionChanged(self):
cur = self["list"].getCurrent()
if cur is None:
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
if self.key_red_choice != self.EMPTY:
self["key_red"].setText("")
self.key_red_choice = self.EMPTY
return
event = cur[0]
self["Event"].newEvent(event)
if self.type == EPG_TYPE_MULTI:
count = self["list"].getCurrentChangeCount()
if self.ask_time != -1:
self.applyButtonState(0)
elif count > 1:
self.applyButtonState(3)
elif count > 0:
self.applyButtonState(2)
else:
self.applyButtonState(1)
days = [ _("Mon"), _("Tue"), _("Wed"), _("Thu"), _("Fri"), _("Sat"), _("Sun") ]
datestr = ""
if event is not None:
now = time()
beg = event.getBeginTime()
nowTime = localtime(now)
begTime = localtime(beg)
if nowTime[2] != begTime[2]:
datestr = '%s %d.%d.'%(days[begTime[6]], begTime[2], begTime[1])
else:
datestr = '%s %d.%d.'%(_("Today"), begTime[2], begTime[1])
self["date"].setText(datestr)
if cur[1] is None:
self["Service"].newService(None)
else:
self["Service"].newService(cur[1].ref)
if cur[1] is None or cur[1].getServiceName() == "":
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
if self.key_red_choice != self.EMPTY:
self["key_red"].setText("")
self.key_red_choice = self.EMPTY
return
elif self.key_red_choice != self.ZAP and self.zapFunc is not None:
self["key_red"].setText(_("Zap"))
self.key_red_choice = self.ZAP
if event is None:
if self.key_green_choice != self.EMPTY:
self["key_green"].setText("")
self.key_green_choice = self.EMPTY
return
serviceref = cur[1]
eventid = event.getEventId()
begin = event.getBeginTime()
end = begin + event.getDuration()
refstr = ':'.join(serviceref.ref.toString().split(':')[:11])
isRecordEvent = False
for timer in self.session.nav.RecordTimer.getAllTimersList():
needed_ref = ':'.join(timer.service_ref.ref.toString().split(':')[:11]) == refstr
if needed_ref and (timer.eit == eventid and (begin < timer.begin <= end or timer.begin <= begin <= timer.end) or timer.repeated and self.session.nav.RecordTimer.isInRepeatTimer(timer, event)):
isRecordEvent = True
break
if isRecordEvent and self.key_green_choice != self.REMOVE_TIMER:
self["key_green"].setText(_("Remove timer"))
self.key_green_choice = self.REMOVE_TIMER
elif not isRecordEvent and self.key_green_choice != self.ADD_TIMER:
self["key_green"].setText(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
if self.parent and eventid and hasattr(self.parent, "setEvent"):
self.parent.setEvent(serviceref, eventid)
self["list"].l.invalidate()
