def AutoTimerGraphMultiEPG__init__(self, session, services, zapFunc=None, bouquetChangeCB=None, bouquetname=""):
try:
baseGraphMultiEPG__init__(self, session, services, zapFunc, bouquetChangeCB, bouquetname)
except:
baseGraphMultiEPG__init__(self, session, services, zapFunc, bouquetChangeCB)
if config.plugins.autotimer.add_to_graph.value:
def showAutoTimer():
open_list = [
(_("Open standard setup menu"), "setup"),
(_("Add new AutoTimer"), "add"),
(_("Preview for your AutoTimers"), "preview"),
(_("Search new events matching for your AutoTimers"), "search"),
(_("Timers list"), "timerlist"),
]
dlg = self.session.openWithCallback(
self.CallbackToGraphMultiEPG, ChoiceBox, title=_("Select action for AutoTimer:"), list=open_list
)
dlg.setTitle(_("Choice list AutoTimer"))
HelpableScreen.__init__(self)
self["AutoTimeractions"] = HelpableActionMap(
self, "ChannelSelectEditActions", {"contextMenu": (showAutoTimer, _("Choice list AutoTimer"))}, -1
)
self["AutoTimeractions"].csel = self
def initActions(self, csel, enable=True):
if enable:
keys = {
"RED": (boundFunction(self.execColorButton,
KEY_RED), _("Color key red")),
"GREEN": (boundFunction(self.execColorButton,
KEY_GREEN), _("Color key green")),
"YELLOW": (boundFunction(self.execColorButton,
KEY_YELLOW), _("Color key yellow")),
"BLUE": (boundFunction(self.execColorButton,
KEY_BLUE), _("Color key blue")),
"OK": (csel.selectedEntry, _("Play")),
"EXIT": (csel.exit, _("Exit")),
"POWER": (csel.exit, _("Exit")),
"MENUS": (csel.openContextMenu, _("Context menu")),
"MENUL": (csel.openPluginsMenu, _("Plugins menu")),
"INFOS": (csel.showMovieInfoEPG, _("EPG info")),
"INFOL": (csel.showMovieInfoTMDB, _("TMDB info")),
"LEFT": (csel.movie_list.pageUp, _("Cursor page up")),
"RIGHT": (csel.movie_list.pageDown, _("Cursor page down")),
"UP": (csel.movie_list.moveUp, _("Cursor up")),
"DOWN": (csel.movie_list.moveDown, _("Cursor down")),
"CHANNELUP":
(csel.movie_list.moveBouquetPlus, _("Bouquet up")),
"CHANNELDOWN":
(csel.movie_list.moveBouquetMinus, _("Bouquet down")),
"VIDEOS": (csel.toggleSelection, _("Selection on/off")),
"VIDEOL": (csel.unselectAll, _("Selection off")),
"STOP": (csel.stopRecordings, _("Stop recording(s)")),
"NEXT": (csel.nextColorButtonsLevel, _("Color buttons next")),
"PREVIOUS": (csel.previousColorButtonsLevel,
_("Color buttons previous")),
"0": (csel.goHome, _("Home")),
"1": (self.selfTest, _("Selftest")), # pylint: disable=no-member
"8": (csel.showFileManagerProgress,
_("File operations progress")),
"5": (csel.showRecordingInfo, _("Recording Info")),
}
else:
keys = {
"EXIT": (csel.exit, _("Exit")),
}
actions = HelpableActionMap(
csel,
"CockpitActions",
keys,
prio=
-3 # give them a little more priority to win over base class buttons
)
actions.csel = csel
return actions
def AutoTimerGraphMultiEPG__init__(self,
session,
services,
zapFunc=None,
bouquetChangeCB=None,
bouquetname=""):
try:
baseGraphMultiEPG__init__(self, session, services, zapFunc,
bouquetChangeCB, bouquetname)
except:
baseGraphMultiEPG__init__(self, session, services, zapFunc,
bouquetChangeCB)
if config.plugins.autotimer.add_to_graph.value:
def showAutoTimer():
open_list = [
(_("Open standard setup menu"), "setup"),
(_("Add new AutoTimer"), "add"),
(_("Preview for your AutoTimers"), "preview"),
(_("Search new events matching for your AutoTimers"),
"search"),
(_("Timers list"), "timerlist"),
]
dlg = self.session.openWithCallback(
self.CallbackToGraphMultiEPG,
ChoiceBox,
title=_("Select action for AutoTimer:"),
list=open_list)
dlg.setTitle(_("Choice list AutoTimer"))
HelpableScreen.__init__(self)
self["AutoTimeractions"] = HelpableActionMap(
self, "ChannelSelectEditActions", {
"contextMenu": (showAutoTimer, _("Choice list AutoTimer")),
}, -1)
self["AutoTimeractions"].csel = self
def __init__(self, session, services, zapFunc=None, bouquetChangeCB=None, bouquetname=""):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
now = time() - config.epg.histminutes.getValue() * 60
self.ask_time = now - now % (config.misc.graph_mepg.roundTo.getValue() * 60)
self.closeRecursive = False
self["key_red"] = Button("")
self["key_green"] = Button("")
self["key_yellow"] = Button("")
self["key_blue"] = Button(_("Goto"))
self.key_green_choice = self.EMPTY
self.key_red_choice = self.EMPTY
self["timeline_text"] = TimelineText()
self["Event"] = Event()
self.time_lines = [ ]
for x in range(0, MAX_TIMELINES):
pm = Pixmap()
self.time_lines.append(pm)
self["timeline%d"%(x)] = pm
self["timeline_now"] = Pixmap()
self.services = services
self.zapFunc = zapFunc
if bouquetname != "":
Screen.setTitle(self, bouquetname)
self["list"] = EPGList( selChangedCB = self.onSelectionChanged,
timer = self.session.nav.RecordTimer,
time_epoch = config.misc.graph_mepg.prev_time_period.value,
overjump_empty = config.misc.graph_mepg.overjump.value)
HelpableScreen.__init__(self)
self["okactions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.closeScreen, _("Exit EPG")),
"ok": (self.eventSelected, _("Show detailed event info"))
}, -1)
self["okactions"].csel = self
self["epgactions"] = HelpableActionMap(self, "EPGSelectActions",
{
"timerAdd": (self.timerAdd, _("Add/Remove timer for current event")),
"info": (self.infoKeyPressed, _("Show detailed event info")),
"red": (self.zapTo, _("Zap to selected channel")),
"blue": (self.enterDateTime, _("Goto specific data/time")),
"menu": (self.showSetup, _("Setup menu")),
"nextBouquet": (self.nextBouquet, _("Show bouquet selection menu")),
"prevBouquet": (self.prevBouquet, _("Show bouquet selection menu")),
"nextService": (self.nextPressed, _("Goto next page of events")),
"prevService": (self.prevPressed, _("Goto previous page of events"))
}, -1)
self["epgactions"].csel = self
self["inputactions"] = HelpableActionMap(self, "InputActions",
{
"left": (self.leftPressed, _("Goto previous event")),
"right": (self.rightPressed, _("Goto next event")),
"1": (self.key1, _("Set time window to 1 hour")),
"2": (self.key2, _("Set time window to 2 hours")),
"3": (self.key3, _("Set time window to 3 hours")),
"4": (self.key4, _("Set time window to 4 hours")),
"5": (self.key5, _("Set time window to 5 hours")),
"7": (self.prevPage, _("Goto previous page of service")),
"9": (self.nextPage, _("Goto next page of service")),
"8": (self.toTop, _("Goto first service")),
"0": (self.toEnd, _("Goto last service"))
}, -1)
self["inputactions"].csel = self
self.updateTimelineTimer = eTimer()
self.updateTimelineTimer.callback.append(self.moveTimeLines)
self.updateTimelineTimer.start(60 * 1000)
self.onLayoutFinish.append(self.onCreate)
def __init__(self, session, services, zapFunc=None, bouquetChangeCB=None, bouquetname=""):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
now = time() - config.epg.histminutes.value * 60
self.ask_time = now - now % int(config.misc.graph_mepg.roundTo.value)
self["key_red"] = Button("")
self["key_green"] = Button("")
global listscreen
if listscreen:
self["key_yellow"] = Button(_("Normal mode"))
self.skinName="GraphMultiEPGList"
else:
self["key_yellow"] = Button(_("List mode"))
self["key_blue"] = Button(_("Goto"))
self.key_green_choice = self.EMPTY
self.key_red_choice = self.EMPTY
self["timeline_text"] = TimelineText()
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.time_lines = [ ]
for x in list(range(0, MAX_TIMELINES)):
pm = Pixmap()
self.time_lines.append(pm)
self["timeline%d"%(x)] = pm
self["timeline_now"] = Pixmap()
self.services = services
self.zapFunc = zapFunc
if bouquetname != "":
Screen.setTitle(self, bouquetname)
self["list"] = EPGList( selChangedCB = self.onSelectionChanged,
timer = self.session.nav.RecordTimer,
time_epoch = config.misc.graph_mepg.prev_time_period.value,
overjump_empty = config.misc.graph_mepg.overjump.value)
HelpableScreen.__init__(self)
self["okactions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.closeScreen, _("Exit EPG")),
"ok": (self.eventSelected, _("Zap to selected channel, or show detailed event info (depends on configuration)"))
}, -1)
self["okactions"].csel = self
self["epgactions"] = HelpableActionMap(self, "EPGSelectActions",
{
"timerAdd": (self.timerAdd, _("Add/remove change timer for current event")),
"info": (self.infoKeyPressed, _("Show detailed event info")),
"red": (self.zapTo, _("Zap to selected channel")),
"yellow": (self.swapMode, _("Switch between normal mode and list mode")),
"blue": (self.enterDateTime, _("Goto specific data/time")),
"menu": (self.showSetup, _("Setup menu")),
"nextBouquet": (self.nextBouquet, _("Show bouquet selection menu")),
"prevBouquet": (self.prevBouquet, _("Show bouquet selection menu")),
"nextService": (self.nextPressed, _("Goto next page of events")),
"prevService": (self.prevPressed, _("Goto previous page of events")),
"preview": (self.preview, _("Preview selected channel")),
"nextDay": (self.nextDay, _("Goto next day of events")),
"prevDay": (self.prevDay, _("Goto previous day of events"))
}, -1)
self["epgactions"].csel = self
self["inputactions"] = HelpableActionMap(self, "InputActions",
{
"left": (self.leftPressed, _("Go to previous event")),
"right": (self.rightPressed, _("Go to next event")),
"1": (self.key1, _("Set time window to 1 hour")),
"2": (self.key2, _("Set time window to 2 hours")),
"3": (self.key3, _("Set time window to 3 hours")),
"4": (self.key4, _("Set time window to 4 hours")),
"5": (self.key5, _("Set time window to 5 hours")),
"6": (self.key6, _("Set time window to 6 hours")),
"7": (self.prevPage, _("Go to previous page of service")),
"9": (self.nextPage, _("Go to next page of service")),
"8": (self.toTop, _("Go to first service")),
"0": (self.toEnd, _("Go to last service"))
}, -1)
self["inputactions"].csel = self
self.updateTimelineTimer = eTimer()
self.updateTimelineTimer.callback.append(self.moveTimeLines)
self.updateTimelineTimer.start(60 * 1000)
self.onLayoutFinish.append(self.onCreate)
self.previousref = self.session.nav.getCurrentlyPlayingServiceOrGroup()
def __init__(self, session, returnService=None, playerInstance=None):
print("MVC: MovieSelection: __init__")
global instance
instance = self
Screen.__init__(self, session)
EventInfo.__init__(self)
MountPoints.__init__(self)
self.skinName = ["MVCSelection"]
self.skin = Util.readFile(self.getSkin())
self.playerInstance = playerInstance
self.multi_select_index = None
self.lastservice = None
self.cursorDir = 0
self.savedIndex = 0
self["wait"] = Label(_("Reading directory..."))
self["wait"].hide()
self["space_info"] = Label("")
self["sort_mode"] = Label("")
self["list"] = MovieCenter()
if returnService:
self.returnService = returnService
set_current_path = True
for entry in self["list"].list:
if entry[MOVIE_IDX_SERVICE] == self.returnService:
set_current_path = False
break
if set_current_path:
self.current_path = os.path.dirname(returnService.getPath())
self["key_red"] = Button()
self["key_green"] = Button()
self["key_yellow"] = Button()
self["key_blue"] = Button()
self.cover = config.MVC.cover.value
helptext = self.initButtons()
self["actions"] = HelpableActionMap(
self,
"PluginMovieSelectionActions",
{
"MVCOK": (self.entrySelected, _("Play selected movie(s)")),
"MVCEXIT": (self.abort, _("Close plugin")),
# "MVCEXITpowerdown": (self.abortAndPowerDown, _("Close plugin and do power button action")),
"MVCMENU": (self.openMenu, _("Open menu")),
"MVCINFO": (self.showEventInformation, _("Show event info")),
"MVCINFOL":
(self.openInfoLong,
_("IMDBSearch / MVC-TMDBInfo / TMDBInfo / TMBDInfo / CSFDInfo"
)),
"MVCRed": (self.redFunc, helptext[0]), # redhelptext),
"MVCGREEN":
(self.greenFuncShort, helptext[2]), # greenhelptext),
"MVCYELLOW":
(self.yellowFunc, helptext[4]), # yellowhelptext),
"MVCBLUE": (self.blueFunc, helptext[6]), # bluehelptext),
"MVCREDL":
(self.redFuncLong, helptext[1]), # redlonghelptext),
"MVCGREENL":
(self.greenFuncLong, helptext[3]), # greenlonghelptext),
"MVCYELLOWL":
(self.yellowFuncLong, helptext[5]), # yellowlonghelptext),
"MVCBlueL":
(self.blueFuncLong, helptext[7]), # bluelonghelptext),
"MVCLeft": (self.pageUp, _("Move cursor page up")),
"MVCRight": (self.pageDown, _("Move cursor page down")),
"MVCUp": (self.moveUp, _("Move cursor up")),
"MVCDown": (self.moveDown, _("Move cursor down")),
"MVCBqtPlus":
(self.bqtPlus,
_("Move cursor to the top / Move cursor x entries up / Switch Folders in Movie Home (up)"
)),
"MVCBqtMnus":
(self.bqtMnus,
_("Move cursor to the end / Move cursor x entries down / Switch Folders in Movie Home (down)"
)),
"MVCVIDEOB":
(self.toggleSelectionList, _("Toggle service selection")),
"MVCVIDEOL":
(self.resetSelectionList, _("Remove service selection")),
"MVCAUDIO":
(self.openMenuPlugins, _("Available plugins menu")),
"MVCTV": (self.openTimerList, _("Open Timer List")),
"MVCRADIO": (self.resetProgress, _("Reset movie progress")),
"MVCTEXT": (self.multiSelect, _("Start / end multiselection")),
"0": (self.MVCKey0, _("Movie home")),
},
prio=
-3 # give them a little more priority to win over base class buttons
)
self["actions"].csel = self
HelpableScreen.__init__(self)
if self.current_path is None:
self.current_path = config.MVC.movie_homepath.value
self.last_current_path = None
self.selection_list = [] # Used for file operations
self.hide_miniTV = False
# Key press short long handling
#TODO We have to rework this key press handling in order to allow different user defined color key functions
self.toggle = True # Used for long / short key press detection: Toggle sort mode / order, Toggle selection / reset selection
self.move = True
self.delayTimer = eTimer()
self.delayTimer_conn = self.delayTimer.timeout.connect(
self.updateInfoDelayed)
self.coverTimer = eTimer()
self.coverTimer_conn = self.coverTimer.timeout.connect(
self.showCoverDelayed)
self.onShow.append(self.onDialogShow)
self.onHide.append(self.onDialogHide)
self["list"].onSelectionChanged.append(self.selectionChanged)
def __init__(self, session, service, zapFunc = None, eventid = None, bouquetChangeCB = None, serviceChangeCB = None, EPGtype = None, StartBouquet = None, StartRef = None, bouquetname = ''):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.longbuttonpressed = False
self.zapFunc = zapFunc
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
graphic = False
if EPGtype == 'single':
self.type = EPG_TYPE_SINGLE
elif EPGtype == 'infobar':
self.type = EPG_TYPE_INFOBAR
elif EPGtype == 'enhanced':
self.type = EPG_TYPE_ENHANCED
elif EPGtype == 'graph':
self.type = EPG_TYPE_GRAPH
if config.epgselection.graph_type_mode.getValue() == "graphics":
graphic = True
elif EPGtype == 'infobargraph':
self.type = EPG_TYPE_INFOBARGRAPH
if config.epgselection.infobar_type_mode.getValue() == "graphics":
graphic = True
elif EPGtype == 'multi':
self.type = EPG_TYPE_MULTI
else:
self.type = EPG_TYPE_SIMILAR
if not self.type == EPG_TYPE_SINGLE:
self.StartBouquet = StartBouquet
self.StartRef = StartRef
self.bouquetname = bouquetname
self.servicelist = None
self.ask_time = -1
self.closeRecursive = False
self.eventviewDialog = None
self.eventviewWasShown = False
self.currch = None
self.session.pipshown = False
if plugin_PiPServiceRelation_installed:
self.pipServiceRelation = getRelationDict()
else:
self.pipServiceRelation = {}
self['Service'] = ServiceEvent()
self['Event'] = Event()
self.key_green_choice = self.EMPTY
self['key_red'] = Button(_('IMDb Search'))
self['key_green'] = Button(_('Add Timer'))
self['key_yellow'] = Button(_('EPG Search'))
self['key_blue'] = Button(_('Add AutoTimer'))
self['okactions'] = HelpableActionMap(self, 'OkCancelActions',
{
'cancel': (self.closeScreen, _('Exit EPG')),
'OK': (self.OK, _('Zap to channel (setup in menu)')),
'OKLong': (self.OKLong, _('Zap to channel and close (setup in menu)'))
}, -1)
self['okactions'].csel = self
self['colouractions'] = HelpableActionMap(self, 'ColorActions',
{
'red': (self.redButtonPressed, _('IMDB search for current event')),
'redlong': (self.redlongButtonPressed, _('Sort EPG List')),
'green': (self.greenButtonPressed, _('Add/Remove timer for current event')),
'yellow': (self.yellowButtonPressed, _('Search for similar events')),
'greenlong': (self.showTimerList, _('Show Timer List')),
'blue': (self.blueButtonPressed, _('Add a auto timer for current event')),
'bluelong': (self.bluelongButtonPressed, _('Show AutoTimer List'))
}, -1)
self['colouractions'].csel = self
self['recordingactions'] = HelpableActionMap(self, 'InfobarInstantRecord',
{
'ShortRecord': (self.doRecordTimer, _('Add a record timer for current event')),
'LongRecord': (self.doZapTimer, _('Add a zap timer for current event'))
}, -1)
self['recordingactions'].csel = self
if self.type == EPG_TYPE_SIMILAR:
self.currentService = service
self.eventid = eventid
self['epgactions'] = HelpableActionMap(self, 'EPGSelectActions',
{
'info': (self.Info, _('Show detailed event info')),
'infolong': (self.InfoLong, _('Show single epg for current channel')),
'menu': (self.createSetup, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
elif self.type == EPG_TYPE_SINGLE:
self.currentService = ServiceReference(service)
self['epgactions'] = HelpableActionMap(self, 'EPGSelectActions',
{
'info': (self.Info, _('Show detailed event info')),
'epg': (self.Info, _('Show detailed event info')),
'menu': (self.createSetup, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
self['cursoractions'] = HelpableActionMap(self, 'DirectionActions',
{
'left': (self.prevPage, _('Move up a page')),
'right': (self.nextPage, _('Move down a page')),
'up': (self.moveUp, _('Goto previous channel')),
'down': (self.moveDown, _('Goto next channel'))
}, -1)
self['cursoractions'].csel = self
elif self.type == EPG_TYPE_INFOBAR or self.type == EPG_TYPE_ENHANCED:
if self.type == EPG_TYPE_INFOBAR:
self.skinName = 'QuickEPG'
self['epgactions'] = HelpableActionMap(self, 'EPGSelectActions',
{
'nextBouquet': (self.nextBouquet, _('Goto next bouquet')),
'prevBouquet': (self.prevBouquet, _('Goto previous bouquet')),
'nextService': (self.nextPage, _('Move down a page')),
'prevService': (self.prevPage, _('Move up a page')),
'input_date_time': (self.enterDateTime, _('Goto specific data/time')),
'info': (self.Info, _('Show detailed event info')),
'infolong': (self.InfoLong, _('Show single epg for current channel')),
'menu': (self.createSetup, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
self['cursoractions'] = HelpableActionMap(self, 'DirectionActions',
{
'left': (self.prevService, _('Goto previous channel')),
'right': (self.nextService, _('Goto next channel')),
'up': (self.moveUp, _('Goto previous channel')),
'down': (self.moveDown, _('Goto next channel'))
}, -1)
self['cursoractions'].csel = self
elif self.type == EPG_TYPE_ENHANCED:
self['epgactions'] = HelpableActionMap(self, 'EPGSelectActions',
{
'nextBouquet': (self.nextBouquet, _('Goto next bouquet')),
'prevBouquet': (self.prevBouquet, _('Goto previous bouquet')),
'nextService': (self.nextService, _('Goto next channel')),
'prevService': (self.prevService, _('Goto previous channel')),
'input_date_time': (self.enterDateTime, _('Goto specific data/time')),
'info': (self.Info, _('Show detailed event info')),
'infolong': (self.InfoLong, _('Show single epg for current channel')),
'menu': (self.createSetup, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
self['cursoractions'] = HelpableActionMap(self, 'DirectionActions',
{
'left': (self.prevPage, _('Move up a page')),
'right': (self.nextPage, _('Move down a page')),
'up': (self.moveUp, _('Goto previous channel')),
'down': (self.moveDown, _('Goto next channel'))
}, -1)
self['cursoractions'].csel = self
self['inputactions'] = HelpableNumberActionMap(self, 'NumberActions',
{
'1': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'2': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'3': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'4': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'5': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'6': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'7': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'8': (self.keyNumberGlobal, _('enter number to jump to channel.')),
'9': (self.keyNumberGlobal, _('enter number to jump to channel.'))
}, -1)
self['inputactions'].csel = self
self.list = []
self.servicelist = service
self.currentService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
elif self.type == EPG_TYPE_GRAPH or self.type == EPG_TYPE_INFOBARGRAPH:
if self.type == EPG_TYPE_GRAPH:
if not config.epgselection.graph_pig.getValue():
self.skinName = 'GraphicalEPG'
else:
self.skinName = 'GraphicalEPGPIG'
elif self.type == EPG_TYPE_INFOBARGRAPH:
self.skinName = 'GraphicalInfoBarEPG'
now = time() - int(config.epg.histminutes.getValue()) * 60
if self.type == EPG_TYPE_GRAPH:
self.ask_time = self.ask_time = now - now % (int(config.epgselection.graph_roundto.getValue()) * 60)
elif self.type == EPG_TYPE_INFOBARGRAPH:
self.ask_time = self.ask_time = now - now % (int(config.epgselection.infobar_roundto.getValue()) * 60)
self.closeRecursive = False
self['lab1'] = Label(_('Wait please while gathering data...'))
self['timeline_text'] = TimelineText(type=self.type,graphic=graphic)
self['Event'] = Event()
self['primetime'] = Label(_('PRIMETIME'))
self['change_bouquet'] = Label(_('CHANGE BOUQUET'))
self['jump'] = Label(_('JUMP 24 HOURS'))
self['page'] = Label(_('PAGE UP/DOWN'))
self.time_lines = []
for x in range(0, MAX_TIMELINES):
pm = Pixmap()
self.time_lines.append(pm)
self['timeline%d' % x] = pm
self['timeline_now'] = Pixmap()
self.services = service
self.curBouquet = bouquetChangeCB
self.updateTimelineTimer = eTimer()
self.updateTimelineTimer.callback.append(self.moveTimeLines)
self.updateTimelineTimer.start(60000)
self['epgactions'] = HelpableActionMap(self, 'EPGSelectActions',
{
'nextService': (self.nextService, _('Jump forward 24 hours')),
'prevService': (self.prevService, _('Jump back 24 hours')),
'nextBouquet': (self.nextBouquet, _('Goto next bouquet')),
'prevBouquet': (self.prevBouquet, _('Goto previous bouquet')),
'input_date_time': (self.enterDateTime, _('Goto specific data/time')),
'info': (self.Info, _('Show detailed event info')),
'infolong': (self.InfoLong, _('Show single epg for current channel')),
'tv': (self.togglePIG, _('Toggle Picture In Graphics')),
'menu': (self.createSetup, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
self['cursoractions'] = HelpableActionMap(self, 'DirectionActions',
{
'left': (self.leftPressed, _('Goto previous event')),
'right': (self.rightPressed, _('Goto next event')),
'up': (self.moveUp, _('Goto previous channel')),
'down': (self.moveDown, _('Goto next channel'))
}, -1)
self['cursoractions'].csel = self
self['input_actions'] = HelpableNumberActionMap(self, 'NumberActions',
{
'1': (self.keyNumberGlobal, _('Reduce time scale')),
'2': (self.keyNumberGlobal, _('Page up')),
'3': (self.keyNumberGlobal, _('Increase time scale')),
'4': (self.keyNumberGlobal, _('page left')),
'5': (self.keyNumberGlobal, _('Jump to current time')),
'6': (self.keyNumberGlobal, _('Page right')),
'7': (self.keyNumberGlobal, _('No of items switch (increase or reduced)')),
'8': (self.keyNumberGlobal, _('Page down')),
'9': (self.keyNumberGlobal, _('Jump to prime time')),
'0': (self.keyNumberGlobal, _('Move to home of list'))
}, -1)
self['input_actions'].csel = self
elif self.type == EPG_TYPE_MULTI:
self.skinName = 'EPGSelectionMulti'
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.curBouquet = bouquetChangeCB
self['epgactions'] = HelpableActionMap(self, 'EPGSelectActions',
{
'nextService': (self.nextPage, _('Move down a page')),
'prevService': (self.prevPage, _('Move up a page')),
'nextBouquet': (self.nextBouquet, _('Goto next bouquet')),
'prevBouquet': (self.prevBouquet, _('Goto previous bouquet')),
'input_date_time': (self.enterDateTime, _('Goto specific data/time')),
'info': (self.Info, _('Show detailed event info')),
'infolong': (self.InfoLong, _('Show single epg for current channel')),
'menu': (self.createSetup, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
self['cursoractions'] = HelpableActionMap(self, 'DirectionActions',
{
'left': (self.leftPressed, _('Move up a page')),
'right': (self.rightPressed, _('Move down a page')),
'up': (self.moveUp, _('Goto previous channel')),
'down': (self.moveDown, _('Goto next channel'))
}, -1)
self['cursoractions'].csel = self
if self.type == EPG_TYPE_GRAPH:
time_epoch=config.epgselection.graph_prevtimeperiod.getValue()
elif self.type == EPG_TYPE_INFOBARGRAPH:
time_epoch=config.epgselection.infobar_prevtimeperiod.getValue()
else:
time_epoch=None
self['list'] = EPGList(type=self.type, selChangedCB=self.onSelectionChanged, timer=session.nav.RecordTimer, time_epoch=time_epoch, overjump_empty=config.epgselection.overjump.getValue(), graphic=graphic)
self.refreshTimer = eTimer()
self.refreshTimer.timeout.get().append(self.refreshData)
self.listTimer = eTimer()
self.listTimer.timeout.get().append(self.hidewaitingtext)
self.onLayoutFinish.append(self.onCreate)
def __init__(self, session, *args, **kwargs):
Screen.__init__(self, session)
if not isinstance(self.skinName, list):
self.skinName = [self.skinName]
self.skinName.append("EPGSelection")
if isinstance(self, HelpableScreen):
HelpableScreen.__init__(self)
self.searchargs = args
self.currSearch = ""
self.longbuttonpressed = False
# XXX: we lose sort begin/end here
self["key_yellow"] = Button(_("New Search"))
self["key_blue"] = Button(_("Add AutoTimer"))
# begin stripped copy of EPGSelection.__init__
self.ChoiceBoxDialog = None
self.bouquetChangeCB = None
self.serviceChangeCB = None
self.ask_time = -1 # now
self.closeRecursive = False
self.saved_title = None
self.lastAsk = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["number"] = Label()
self["number"].hide()
self.type = EPG_TYPE_SINGLE
self.currentService = None
self.zapFunc = None
self.currch = None
self.sort_type = 0
self.eventviewDialog = None
self["key_red"] = Button(_("IMDb Search"))
self["key_green"] = Button(_("Add Timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGSearchList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self["dialogactions"] = HelpableActionMap(self, "WizardActions", {
"back": (self.closeChoiceBoxDialog, _("Close dialog")),
}, -1)
self["dialogactions"].csel = self
self["dialogactions"].setEnabled(False)
self["okactions"] = HelpableActionMap(
self, "OkCancelActions", {
"cancel": (self.closeScreen, _("Exit EPG Search")),
"OK": (self.epgsearchOK, _("Zap to channel")),
"OKLong":
(self.epgsearchOKLong, _("Show detailed event information"))
}, -1)
self["okactions"].csel = self
self["colouractions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.redButtonPressed,
_("IMDB search for highlighted event")),
"green": (self.timerAdd,
_("Add/remove/edit timer for highlighted event")),
"yellow": (self.yellowButtonPressed, _("Enter new search")),
"yellowlong": (self.showHistory, _("Show search history")),
"blue": (self.exportAutoTimer,
_("Add an AutoTimer for highlighted event")),
"bluelong":
(self.blueButtonPressedLong, _("Show AutoTimer list"))
}, -1)
self["colouractions"].csel = self
self["recordingactions"] = HelpableActionMap(
self, "InfobarInstantRecord", {
"ShortRecord": (self.doRecordTimer,
_("Add a record timer for highlighted event")),
"LongRecord":
(self.doZapTimer, _("Add a zap timer for highlighted event"))
}, -1)
self["recordingactions"].csel = self
self["epgactions"] = HelpableActionMap(
self, "EPGSelectActions", {
"nextBouquet": (self.nextPage, _("Move down a page")),
"prevBouquet": (self.prevPage, _("Move up a page")),
"nextService": (self.prevPage, _("Move up a page")),
"prevService": (self.nextPage, _("Move down a page")),
"epg": (self.Info, _("Show detailed event information")),
"info": (self.Info, _("Show detailed event information")),
"infolong":
(self.infoKeyPressed, _("Show detailed event information")),
"menu": (self.menu, _("Setup menu"))
}, -1)
self["epgactions"].csel = self
self["epgcursoractions"] = HelpableActionMap(
self, "DirectionActions", {
"left": (self.prevPage, _("Move up a page")),
"right": (self.nextPage, _("Move down a page")),
"up": (self.moveUp, _("Move up")),
"down": (self.moveDown, _("Move down"))
}, -1)
self["epgcursoractions"].csel = self
self.openHistory = kwargs.get("openHistory", False)
self.onLayoutFinish.append(self.onCreate)
# end stripped copy of EPGSelection.__init__
# Partnerbox
if PartnerBoxIconsEnabled:
EPGSelection.PartnerboxInit(self, False)
self.refreshTimer = eTimer()
self.refreshTimer.callback.append(self.refreshlist)
self.startTimer = eTimer()
self.startTimer.callback.append(self.startUp)
self.startTimer.start(10, 1)
self.searchStartTimer = eTimer()
# Hook up actions for yttrailer if installed
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
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
})
def __init__(self, session, *args):
Screen.__init__(self, session)
self.skinName = ["EPGSearch", "EPGSelection"]
self.searchargs = args
self.currSearch = ""
self.longbuttonpressed = False
# XXX: we lose sort begin/end here
self["key_yellow"] = Button(_("New Search"))
self["key_blue"] = Button(_("Add AutoTimer"))
# begin stripped copy of EPGSelection.__init__
self.ChoiceBoxDialog = None
self.bouquetChangeCB = None
self.serviceChangeCB = None
self.ask_time = -1 #now
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["number"] = Label()
self["number"].hide()
self.type = EPG_TYPE_SINGLE
self.currentService=None
self.zapFunc = None
self.currch = None
self.sort_type = 0
self.eventviewDialog = None
self["key_red"] = Button(_("IMDb Search"))
self["key_green"] = Button(_("Add Timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGSearchList(type = self.type, selChangedCB = self.onSelectionChanged, timer = session.nav.RecordTimer)
self['dialogactions'] = HelpableActionMap(self, 'WizardActions',
{
'back': (self.closeChoiceBoxDialog, _('Close dialog')),
}, -1)
self['dialogactions'].csel = self
self["dialogactions"].setEnabled(False)
self['okactions'] = HelpableActionMap(self, 'OkCancelActions',
{
'cancel': (self.closeScreen, _('Exit EPG')),
'OK': (self.epgsearchOK, _('Zap to channel (setup in menu)')),
'OKLong': (self.epgsearchOKLong, _('Zap to channel and close (setup in menu)'))
}, -1)
self['okactions'].csel = self
self['colouractions'] = HelpableActionMap(self, 'ColorActions',
{
'red': (self.redButtonPressed, _('IMDB search for current event')),
'green': (self.timerAdd, _('Add/Remove timer for current event')),
'yellow': (self.yellowButtonPressed, _('Search for similar events')),
'blue': (self.exportAutoTimer, _('Add a auto timer for current event')),
'bluelong': (self.blueButtonPressed, _('Show AutoTimer List'))
}, -1)
self['colouractions'].csel = self
self['recordingactions'] = HelpableActionMap(self, 'InfobarInstantRecord',
{
'ShortRecord': (self.doRecordTimer, _('Add a record timer for current event')),
'LongRecord': (self.doZapTimer, _('Add a zap timer for current event'))
}, -1)
self['recordingactions'].csel = self
self['epgactions'] = HelpableActionMap(self, 'EPGSelectActions',
{
'nextBouquet': (self.nextBouquet, _('Goto next bouquet')),
'prevBouquet': (self.prevBouquet, _('Goto previous bouquet')),
'nextService': (self.nextService, _('Move down a page')),
'prevService': (self.prevService, _('Move up a page')),
'epg': (self.Info, _('Show detailed event info')),
'info': (self.Info, _('Show detailed event info')),
'infolong': (self.infoKeyPressed, _('Show single epg for current channel')),
'menu': (self.menu, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
self['epgcursoractions'] = HelpableActionMap(self, 'DirectionActions',
{
'left': (self.prevPage, _('Move up a page')),
'right': (self.nextPage, _('Move down a page')),
'up': (self.moveUp, _('Goto previous channel')),
'down': (self.moveDown, _('Goto next channel'))
}, -1)
self['epgcursoractions'].csel = self
self.onLayoutFinish.append(self.onCreate)
# end stripped copy of EPGSelection.__init__
# Partnerbox
if PartnerBoxIconsEnabled:
EPGSelection.PartnerboxInit(self, False)
self.refreshTimer = eTimer()
self.refreshTimer.timeout.get().append(self.refreshlist)
# Hook up actions for yttrailer if installed
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
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
})
def __init__(self, session, *args):
Screen.__init__(self, session)
self.skinName = ["EPGSearch", "EPGSelection"]
self.searchargs = args
self.currSearch = ""
self.longbuttonpressed = False
# XXX: we lose sort begin/end here
self["key_yellow"] = Button(_("New Search"))
self["key_blue"] = Button(_("Add AutoTimer"))
# begin stripped copy of EPGSelection.__init__
self.ChoiceBoxDialog = None
self.bouquetChangeCB = None
self.serviceChangeCB = None
self.ask_time = -1 #now
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["number"] = Label()
self["number"].hide()
self.type = EPG_TYPE_SINGLE
self.currentService = None
self.zapFunc = None
self.currch = None
self.sort_type = 0
self.eventviewDialog = None
self["key_red"] = Button(_("IMDb Search"))
self["key_green"] = Button(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGSearchList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self['dialogactions'] = HelpableActionMap(self, 'WizardActions', {
'back': (self.closeChoiceBoxDialog, _('Close dialog')),
}, -1)
self['dialogactions'].csel = self
self["dialogactions"].setEnabled(False)
self['okactions'] = HelpableActionMap(
self, 'OkCancelActions', {
'cancel': (self.closeScreen, _('Exit EPG')),
'OK': (self.epgsearchOK, _('Zap to channel (setup in menu)')),
'OKLong': (self.epgsearchOKLong,
_('Zap to channel and close (setup in menu)'))
}, -1)
self['okactions'].csel = self
self['colouractions'] = HelpableActionMap(
self, 'ColorActions', {
'red':
(self.redButtonPressed, _('IMDB search for current event')),
'green':
(self.timerAdd, _('Add/Remove timer for current event')),
'yellow':
(self.yellowButtonPressed, _('Search for similar events')),
'blue': (self.exportAutoTimer,
_('Add a auto timer for current event')),
'bluelong':
(self.bluelongButtonPressed, _('Show AutoTimer List'))
}, -1)
self['colouractions'].csel = self
self['recordingactions'] = HelpableActionMap(
self, 'InfobarInstantRecord', {
'ShortRecord': (self.doRecordTimer,
_('Add a record timer for current event')),
'LongRecord':
(self.doZapTimer, _('Add a zap timer for current event'))
}, -1)
self['recordingactions'].csel = self
self['epgactions'] = HelpableActionMap(
self, 'EPGSelectActions', {
'nextBouquet': (self.nextBouquet, _('Goto next bouquet')),
'prevBouquet': (self.prevBouquet, _('Goto previous bouquet')),
'nextService': (self.nextService, _('Move down a page')),
'prevService': (self.prevService, _('Move up a page')),
'epg': (self.Info, _('Show detailed event info')),
'info': (self.Info, _('Show detailed event info')),
'infolong': (self.infoKeyPressed,
_('Show single epg for current channel')),
'menu': (self.menu, _('Setup menu'))
}, -1)
self['epgactions'].csel = self
self['epgcursoractions'] = HelpableActionMap(
self, 'DirectionActions', {
'left': (self.prevPage, _('Move up a page')),
'right': (self.nextPage, _('Move down a page')),
'up': (self.moveUp, _('Goto previous channel')),
'down': (self.moveDown, _('Goto next channel'))
}, -1)
self['epgcursoractions'].csel = self
self.onLayoutFinish.append(self.onCreate)
# end stripped copy of EPGSelection.__init__
# Partnerbox
if PartnerBoxIconsEnabled:
EPGSelection.PartnerboxInit(self, False)
self.refreshTimer = eTimer()
self.refreshTimer.timeout.get().append(self.refreshlist)
# Hook up actions for yttrailer if installed
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
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
})
def __init__(self, session, *args, **kwargs):
Screen.__init__(self, session)
self.skinName = [self.skinName, "EPGSelection"]
if isinstance(self, HelpableScreen):
HelpableScreen.__init__(self)
self.searchargs = args
self.currSearch = ""
self.longbuttonpressed = False
# XXX: we lose sort begin/end here
self["key_yellow"] = Button(_("New Search"))
self["key_blue"] = Button(_("Add AutoTimer"))
# begin stripped copy of EPGSelection.__init__
self.ChoiceBoxDialog = None
self.bouquetChangeCB = None
self.serviceChangeCB = None
self.ask_time = -1 # now
self.closeRecursive = False
self.saved_title = None
self.lastAsk = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["number"] = Label()
self["number"].hide()
self.type = EPG_TYPE_SINGLE
self.currentService = None
self.zapFunc = None
self.currch = None
self.sort_type = 0
self.eventviewDialog = None
self["key_red"] = Button(_("IMDb Search"))
self["key_green"] = Button(_("Add Timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGSearchList(type=self.type, selChangedCB=self.onSelectionChanged, timer=session.nav.RecordTimer)
self["dialogactions"] = HelpableActionMap(self, "WizardActions", {
"back": (self.closeChoiceBoxDialog, _("Close dialog")),
}, -1)
self["dialogactions"].csel = self
self["dialogactions"].setEnabled(False)
self["okactions"] = HelpableActionMap(self, "OkCancelActions", {
"cancel": (self.closeScreen, _("Exit EPG Search")),
"OK": (self.epgsearchOK, _("Zap to channel")),
"OKLong": (self.epgsearchOKLong, _("Show detailed event information"))
}, -1)
self["okactions"].csel = self
self["colouractions"] = HelpableActionMap(self, "ColorActions", {
"red": (self.redButtonPressed, _("IMDB search for highlighted event")),
"green": (self.timerAdd, _("Add/remove/edit timer for highlighted event")),
"yellow": (self.yellowButtonPressed, _("Enter new search")),
"yellowlong": (self.showHistory, _("Show search history")),
"blue": (self.exportAutoTimer, _("Add an AutoTimer for highlighted event")),
"bluelong": (self.blueButtonPressedLong, _("Show AutoTimer list"))
}, -1)
self["colouractions"].csel = self
self["recordingactions"] = HelpableActionMap(self, "InfobarInstantRecord", {
"ShortRecord": (self.doRecordTimer, _("Add a record timer for highlighted event")),
"LongRecord": (self.doZapTimer, _("Add a zap timer for highlighted event"))
}, -1)
self["recordingactions"].csel = self
self["epgactions"] = HelpableActionMap(self, "EPGSelectActions", {
"nextBouquet": (self.nextPage, _("Move down a page")),
"prevBouquet": (self.prevPage, _("Move up a page")),
"nextService": (self.prevPage, _("Move up a page")),
"prevService": (self.nextPage, _("Move down a page")),
"epg": (self.Info, _("Show detailed event information")),
"info": (self.Info, _("Show detailed event information")),
"infolong": (self.infoKeyPressed, _("Show detailed event information")),
"menu": (self.menu, _("Setup menu"))
}, -1)
self["epgactions"].csel = self
self["epgcursoractions"] = HelpableActionMap(self, "DirectionActions", {
"left": (self.prevPage, _("Move up a page")),
"right": (self.nextPage, _("Move down a page")),
"up": (self.moveUp, _("Move up")),
"down": (self.moveDown, _("Move down"))
}, -1)
self["epgcursoractions"].csel = self
self.openHistory = kwargs.get("openHistory", False)
self.onLayoutFinish.append(self.onCreate)
# end stripped copy of EPGSelection.__init__
# Partnerbox
if PartnerBoxIconsEnabled:
EPGSelection.PartnerboxInit(self, False)
self.refreshTimer = eTimer()
self.refreshTimer.callback.append(self.refreshlist)
self.startTimer = eTimer()
self.startTimer.callback.append(self.startUp)
self.startTimer.start(10, 1)
self.searchStartTimer = eTimer()
# Hook up actions for yttrailer if installed
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
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
})
def __init__(self, session):
Screen.__init__(self, session)
SelectionEventInfo.__init__(self)
CoolWide = getDesktop(0).size().width()
skinpath = str(resolveFilename)
self.skinName = "MovieSelectionSP"
if CoolWide == 720:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/Suomipoeka/CoolSkin/MovieSelectionSP_720.xml"
elif CoolWide == 1024:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/Suomipoeka/CoolSkin/MovieSelectionSP_1024.xml"
else:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/Suomipoeka/CoolSkin/MovieSelectionSP_1280.xml"
Cool = open(skin)
self.skin = Cool.read()
Cool.close()
self.wasClosed = True
self.playerInstance = None
self.selectIdx = -1
self.cursorDir = 0
self.currentGrnText = _("Alpha sort")
self["wait"] = Label(_("Reading directory..."))
self["list"] = MovieList()
self["key_red"] = Button()
self["key_green"] = Button()
self["key_yellow"] = Button()
self["key_blue"] = Button()
global gMS
gMS = self
self["actions"] = HelpableActionMap(
self, "PluginMovieSelectionActions", {
"bOK": (self.movieSelected, _("Play selected movie(s)")),
"bOKL": (self.unUsed, "-"),
"bEXIT": (self.abort, _("Close movie list")),
"bMENU": (self.openMenu, _("Open menu")),
"bINFO": (self.showEventInformation, _("Show event info")),
"bINFOL": (self.unUsed, "-"),
"bRed": (self.deleteFile, _("Delete file or empty dir")),
"bGreen": (self.toggleSort, _("Toggle sort mode")),
"bYellow": (self.moveMovie, _("Move selected movie(s)")),
"bBlue":
(self.blueFunc, _("Movie home / Play last (configurable)")),
"bRedL": (self.unUsed, "-"),
"bGreenL": (self.unUsed, "-"),
"bYellowL": (self.openScriptMenu, _("Open shell script menu")),
"bBlueL": (self.openBookmarks, _("Open bookmarks")),
"bLeftUp": (self.keyPress, _("Move cursor page up")),
"bRightUp": (self.keyPress, _("Move cursor page down")),
"bUpUp": (self.keyPressU, _("Move cursor up")),
"bDownUp": (self.keyPressD, _("Move cursor down")),
"bBqtPlus": (self.bouquetPlus, _("Move cursor 1/2 page up")),
"bBqtMnus":
(self.bouquetMinus, _("Move cursor 1/2 page down")),
"bArrowR": (self.unUsed, "-"),
"bArrowRL": (self.unUsed, "-"),
"bArrowL": (self.unUsed, "-"),
"bArrowLL": (self.unUsed, "-"),
"bVIDEO":
(self.selectionToggle, _("Toggle service selection")),
"bAUDIO": (self.openMenuPlugins, _("Available plugins menu")),
"bAUDIOL": (self.unUsed, "-"),
"bMENUL": (self.openMenuPlugins, _("Available plugins menu")),
"bTV": (self.reloadList, _("Reload movie file list")),
"bTVL": (self.unUsed, "-"),
"bRADIO": (self.viewedToggle, _("Toggle viewed / not viewed")),
"bRADIOL": (self.unUsed, "-"),
"bTEXT": (self.multiSelect, _("Start / end multiselection")),
"bTEXTL": (self.unUsed, "-")
})
self["actions"].csel = self
HelpableScreen.__init__(self)
self.currentPathSel = config.suomipoeka.movie_homepath.value
self.parentStack = []
self.onExecBegin.append(self.onDialogShow)
def __init__(self, session, services, zapFunc=None, bouquetChangeCB=None, bouquetname=""):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
now = time() - config.epg.histminutes.getValue() * 60
self.ask_time = now - now % int(config.misc.graph_mepg.roundTo.getValue())
self["key_red"] = Button("")
self["key_green"] = Button("")
global listscreen
if listscreen:
self["key_yellow"] = Button(_("Normal mode"))
self.skinName="GraphMultiEPGList"
else:
self["key_yellow"] = Button(_("List mode"))
self["key_blue"] = Button(_("Goto"))
self.key_green_choice = self.EMPTY
self.key_red_choice = self.EMPTY
self["timeline_text"] = TimelineText()
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.time_lines = [ ]
for x in range(0, MAX_TIMELINES):
pm = Pixmap()
self.time_lines.append(pm)
self["timeline%d"%(x)] = pm
self["timeline_now"] = Pixmap()
self.services = services
self.zapFunc = zapFunc
if bouquetname != "":
Screen.setTitle(self, bouquetname)
self["list"] = EPGList( selChangedCB = self.onSelectionChanged,
timer = self.session.nav.RecordTimer,
time_epoch = config.misc.graph_mepg.prev_time_period.value,
overjump_empty = config.misc.graph_mepg.overjump.value)
HelpableScreen.__init__(self)
self["okactions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.closeScreen, _("Exit EPG")),
"ok": (self.eventSelected, _("Zap to selected channel, or show detailed event info (depends on configuration)"))
}, -1)
self["okactions"].csel = self
self["epgactions"] = HelpableActionMap(self, "EPGSelectActions",
{
"timerAdd": (self.timerAdd, _("Add/remove change timer for current event")),
"info": (self.infoKeyPressed, _("Show detailed event info")),
"red": (self.zapTo, _("Zap to selected channel")),
"yellow": (self.swapMode, _("Switch between normal mode and list mode")),
"blue": (self.enterDateTime, _("Goto specific date/time")),
"menu": (self.furtherOptions, _("Further Options")),
"nextBouquet": (self.nextBouquet, self.getKeyNextBouquetHelptext),
"prevBouquet": (self.prevBouquet, self.getKeyPrevBouquetHelptext),
"nextService": (self.nextPressed, _("Goto next page of events")),
"prevService": (self.prevPressed, _("Goto previous page of events")),
"preview": (self.preview, _("Preview selected channel")),
"nextDay": (self.nextDay, _("Goto next day of events")),
"prevDay": (self.prevDay, _("Goto previous day of events"))
}, -1)
self["epgactions"].csel = self
self["inputactions"] = HelpableActionMap(self, "InputActions",
{
"left": (self.leftPressed, _("Go to previous event")),
"right": (self.rightPressed, _("Go to next event")),
"1": (self.key1, _("Set time window to 1 hour")),
"2": (self.key2, _("Set time window to 2 hours")),
"3": (self.key3, _("Set time window to 3 hours")),
"4": (self.key4, _("Set time window to 4 hours")),
"5": (self.key5, _("Set time window to 5 hours")),
"6": (self.key6, _("Set time window to 6 hours")),
"7": (self.prevPage, _("Go to previous page of service")),
"9": (self.nextPage, _("Go to next page of service")),
"8": (self.toTop, _("Go to first service")),
"0": (self.toEnd, _("Go to last service"))
}, -1)
self["inputactions"].csel = self
self.updateTimelineTimer = eTimer()
self.updateTimelineTimer.callback.append(self.moveTimeLines)
self.updateTimelineTimer.start(60 * 1000)
self.onLayoutFinish.append(self.onCreate)
self.previousref = self.session.nav.getCurrentlyPlayingServiceOrGroup()
