def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
for x in parent:
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get('level', 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
self.addMenu(list, x)
count += 1
elif x.tag == 'id':
menuID = x.get('val')
count = 0
if menuID is not None:
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ', ')), x[4]))
count += 1
self.menuID = menuID
if config.ParentalControl.configured.value:
ProtectedScreen.__init__(self)
if menuID is not None:
for l in plugins.getPluginsForMenu(menuID):
plugin_menuid = l[2]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
if len(l) > 4 and l[4]:
list.append(
(l[0], boundFunction(l[1], self.session,
self.close), l[2], l[3] or 50))
else:
list.append((l[0], boundFunction(l[1],
self.session), l[2], l[3]
or 50))
self.skinName = []
if menuID is not None:
self.skinName.append('menu_' + menuID)
self.skinName.append('Menu')
self.menuID = menuID
ProtectedScreen.__init__(self)
if config.usage.sort_menus.value:
list.sort()
else:
list.sort(key=lambda x: int(x[3]))
self['menu'] = List(list)
self['actions'] = NumberActionMap(
['OkCancelActions', 'MenuActions', 'NumberActions'], {
'ok': self.okbuttonClick,
'cancel': self.closeNonRecursive,
'menu': self.closeRecursive,
'1': self.keyNumberGlobal,
'2': self.keyNumberGlobal,
'3': self.keyNumberGlobal,
'4': self.keyNumberGlobal,
'5': self.keyNumberGlobal,
'6': self.keyNumberGlobal,
'7': self.keyNumberGlobal,
'8': self.keyNumberGlobal,
'9': self.keyNumberGlobal
})
a = parent.get('title', '').encode('UTF-8') or None
a = a and _(a)
if a is None:
a = _(parent.get('text', '').encode('UTF-8'))
self['title'] = StaticText(a)
Screen.setTitle(self, a)
self.menu_title = a
return
def __init__(self, session, infobar):
Screen.__init__(self, session)
self.infobar = infobar or self.session.infobar
self.wait = eTimer()
self.wait.timeout.get().append(self.resyncSubtitles)
self['videofps'] = Label('')
sub = self.infobar.selected_subtitle
if sub[0] == 0:
menu = [
getConfigMenuItem('config.subtitles.dvb_subtitles_yellow'),
getConfigMenuItem('config.subtitles.dvb_subtitles_centered'),
getConfigMenuItem('config.subtitles.dvb_subtitles_backtrans'),
getConfigMenuItem(
'config.subtitles.dvb_subtitles_original_position'),
getConfigMenuItem('config.subtitles.subtitle_position'),
getConfigMenuItem(
'config.subtitles.subtitle_bad_timing_delay'),
getConfigMenuItem(
'config.subtitles.subtitle_noPTSrecordingdelay')
]
elif sub[0] == 1:
menu = [
getConfigMenuItem('config.subtitles.ttx_subtitle_colors'),
getConfigMenuItem(
'config.subtitles.ttx_subtitle_original_position'),
getConfigMenuItem('config.subtitles.subtitle_fontsize'),
getConfigMenuItem('config.subtitles.subtitle_position'),
getConfigMenuItem('config.subtitles.subtitle_rewrap'),
getConfigMenuItem('config.subtitles.subtitle_borderwidth'),
getConfigMenuItem('config.subtitles.subtitle_alignment'),
getConfigMenuItem(
'config.subtitles.subtitle_bad_timing_delay'),
getConfigMenuItem(
'config.subtitles.subtitle_noPTSrecordingdelay')
]
else:
menu = [
getConfigMenuItem('config.subtitles.pango_subtitles_delay'),
getConfigMenuItem('config.subtitles.pango_subtitle_colors'),
getConfigMenuItem(
'config.subtitles.pango_subtitle_fontswitch'),
getConfigMenuItem('config.subtitles.colourise_dialogs'),
getConfigMenuItem('config.subtitles.subtitle_fontsize'),
getConfigMenuItem('config.subtitles.subtitle_position'),
getConfigMenuItem('config.subtitles.subtitle_alignment'),
getConfigMenuItem('config.subtitles.subtitle_rewrap'),
getConfigMenuItem('config.subtitles.pango_subtitle_removehi'),
getConfigMenuItem('config.subtitles.subtitle_borderwidth'),
getConfigMenuItem('config.subtitles.pango_subtitles_fps')
]
self['videofps'].setText(
_('Video: %s fps') % self.getFps().rstrip('.000'))
ConfigListScreen.__init__(self,
menu,
self.session,
on_change=self.changedEntry)
self['actions'] = NumberActionMap(['SetupActions'], {
'cancel': self.cancel,
'ok': self.ok
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session, title="", **kwargs):
Screen.__init__(self, session)
self.setTitle(_(title))
self.keys_list = []
self.shiftkeys_list = []
self.lang = language.getLanguage()
self.nextLang = None
self.shiftMode = False
self.selectedKey = 0
self.smsChar = None
self.sms = NumericalTextInput(self.smsOK)
self.key_bg = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_bg.png"))
self.key_sel = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_sel.png"))
self.key_backspace = LoadPixmap(path=resolveFilename(
SCOPE_ACTIVE_SKIN, "buttons/vkey_backspace.png"))
self.key_all = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_all.png"))
self.key_clr = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_clr.png"))
self.key_esc = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_esc.png"))
self.key_ok = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_ok.png"))
self.key_shift = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_shift.png"))
self.key_shift_sel = LoadPixmap(path=resolveFilename(
SCOPE_ACTIVE_SKIN, "buttons/vkey_shift_sel.png"))
self.key_space = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_space.png"))
self.key_left = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_left.png"))
self.key_right = LoadPixmap(
path=resolveFilename(SCOPE_ACTIVE_SKIN, "buttons/vkey_right.png"))
self.keyImages = {
"BACKSPACE": self.key_backspace,
"ALL": self.key_all,
"EXIT": self.key_esc,
"OK": self.key_ok,
"SHIFT": self.key_shift,
"SPACE": self.key_space,
"LEFT": self.key_left,
"RIGHT": self.key_right
}
self.keyImagesShift = {
"BACKSPACE": self.key_backspace,
"CLEAR": self.key_clr,
"EXIT": self.key_esc,
"OK": self.key_ok,
"SHIFT": self.key_shift_sel,
"SPACE": self.key_space,
"LEFT": self.key_left,
"RIGHT": self.key_right
}
self["country"] = StaticText("")
self["header"] = Label()
self["text"] = Input(currPos=len(
kwargs.get("text", "").decode("utf-8", 'ignore')),
allMarked=False,
**kwargs)
self["list"] = VirtualKeyBoardList([])
self["actions"] = NumberActionMap(
[
"OkCancelActions", "WizardActions", "ColorActions",
"KeyboardInputActions", "InputBoxActions", "InputAsciiActions"
], {
"gotAsciiCode": self.keyGotAscii,
"ok": self.okClicked,
"cancel": self.exit,
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down,
"red": self.exit,
"green": self.ok,
"yellow": self.switchLang,
"blue": self.shiftClicked,
"deleteBackward": self.backClicked,
"deleteForward": self.forwardClicked,
"back": self.exit,
"pageUp": self.cursorRight,
"pageDown": self.cursorLeft,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
}, -2)
self.setLang()
self.onExecBegin.append(self.setKeyboardModeAscii)
self.onLayoutFinish.append(self.buildVirtualKeyBoard)
self.onClose.append(self.__onClose)
def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
for x in parent: #walk through the actual nodelist
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addMenu(list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")), x[4]))
count += 1
self.menuID = menuID
if config.ParentalControl.configured.value:
ProtectedScreen.__init__(self)
if menuID is not None:
# plugins
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
if len(l) > 4 and l[4]:
list.append(
(l[0], boundFunction(l[1], self.session,
self.close), l[2], l[3] or 50))
else:
list.append((l[0], boundFunction(l[1],
self.session), l[2], l[3]
or 50))
# for the skin: first try a menu_<menuID>, then Menu
self.skinName = []
if menuID is not None:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
self.menuID = menuID
ProtectedScreen.__init__(self)
# Sort by Weight
if config.usage.sort_menus.value:
list.sort()
else:
list.sort(key=lambda x: int(x[3]))
self["menu"] = List(list)
self["actions"] = NumberActionMap(
["OkCancelActions", "MenuActions", "NumberActions"], {
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
a = parent.get("title", "").encode("UTF-8") or None
a = a and _(a)
if a is None:
a = _(parent.get("text", "").encode("UTF-8"))
self["title"] = StaticText(a)
Screen.setTitle(self, a)
self.menu_title = a
def __init__(self, session, text = "", filename = "", currDir = None, bookmarks = None, userMode = False, windowTitle = _("Select Location"), minFree = None, autoAdd = False, editDir = False, inhibitDirs = [], inhibitMounts = []):
# Init parents
Screen.__init__(self, session)
NumericalTextInput.__init__(self, handleTimeout = False)
HelpableScreen.__init__(self)
# Set useable chars
self.setUseableChars(u'1234567890abcdefghijklmnopqrstuvwxyz')
# Quickselect Timer
self.qs_timer = eTimer()
self.qs_timer.callback.append(self.timeout)
self.qs_timer_type = 0
# Initialize Quickselect
self.curr_pos = -1
self.quickselect = ""
# Set Text
self["text"] = Label(text)
self["textbook"] = Label(_("Bookmarks"))
# Save parameters locally
self.text = text
self.filename = filename
self.minFree = minFree
self.realBookmarks = bookmarks
self.bookmarks = bookmarks and bookmarks.value[:] or []
self.userMode = userMode
self.autoAdd = autoAdd
self.editDir = editDir
self.inhibitDirs = inhibitDirs
# Initialize FileList
self["filelist"] = FileList(currDir, showDirectories = True, showFiles = False, inhibitMounts = inhibitMounts, inhibitDirs = inhibitDirs)
# Initialize BookList
self["booklist"] = MenuList(self.bookmarks)
# Buttons
self["key_green"] = Button(_("OK"))
self["key_yellow"] = Button(_("Rename"))
self["key_blue"] = Button(_("Remove Bookmark"))
self["key_red"] = Button(_("Cancel"))
# Background for Buttons
self["green"] = Pixmap()
self["yellow"] = Pixmap()
self["blue"] = Pixmap()
self["red"] = Pixmap()
# Initialize Target
self["target"] = Label()
if self.userMode:
self.usermodeOn()
# Custom Action Handler
class LocationBoxActionMap(HelpableActionMap):
def __init__(self, parent, context, actions = { }, prio=0):
HelpableActionMap.__init__(self, parent, context, actions, prio)
self.box = parent
def action(self, contexts, action):
# Reset Quickselect
self.box.timeout(force = True)
return HelpableActionMap.action(self, contexts, action)
# Actions that will reset quickselect
self["WizardActions"] = LocationBoxActionMap(self, "WizardActions",
{
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down,
"ok": (self.ok, _("select")),
"back": (self.cancel, _("Cancel")),
}, -2)
self["ColorActions"] = LocationBoxActionMap(self, "ColorActions",
{
"red": self.cancel,
"green": self.select,
"yellow": self.changeName,
"blue": self.addRemoveBookmark,
}, -2)
self["EPGSelectActions"] = LocationBoxActionMap(self, "EPGSelectActions",
{
"prevBouquet": (self.switchToBookList, _("switch to bookmarks")),
"nextBouquet": (self.switchToFileList, _("switch to filelist")),
}, -2)
self["MenuActions"] = LocationBoxActionMap(self, "MenuActions",
{
"menu": (self.showMenu, _("menu")),
}, -2)
# Actions used by quickselect
self["NumberActions"] = NumberActionMap(["NumberActions"],
{
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
})
# Run some functions when shown
self.onShown.extend((
boundFunction(self.setTitle, windowTitle),
self.updateTarget,
self.showHideRename,
))
self.onLayoutFinish.append(self.switchToFileListOnStart)
# Make sure we remove our callback
self.onClose.append(self.disableTimer)
def __init__(self, session, infobar):
Screen.__init__(self, session)
self.skin = QuickSubtitlesConfigMenu.skin
self.infobar = infobar or self.session.infobar
self.wait = eTimer()
self.wait.timeout.get().append(self.resyncSubtitles)
self.resume = eTimer()
self.resume.timeout.get().append(self.resyncSubtitlesResume)
self.service = self.session.nav.getCurrentlyPlayingServiceReference()
servicepath = self.service and self.service.getPath()
if servicepath and servicepath.startswith(
"/") and self.service.toString().startswith("1:"):
info = eServiceCenter.getInstance().info(self.service)
self.service_string = info and info.getInfoString(
self.service, iServiceInformation.sServiceref)
else:
self.service_string = self.service.toString()
self.center_dvb_subs = ConfigYesNo(
default=(eDVBDB.getInstance().getFlag(
eServiceReference(self.service_string))
& self.FLAG_CENTER_DVB_SUBS) and True)
self.center_dvb_subs.addNotifier(self.setCenterDvbSubs)
self["videofps"] = Label("")
sub = self.infobar.selected_subtitle
if sub[0] == 0: # dvb
menu = [
getConfigMenuItem("config.subtitles.dvb_subtitles_yellow"),
getConfigMenuItem("config.subtitles.dvb_subtitles_backtrans"),
getConfigMenuItem(
"config.subtitles.dvb_subtitles_original_position"),
(_("Center DVB subtitles"), self.center_dvb_subs),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem(
"config.subtitles.subtitle_bad_timing_delay"),
getConfigMenuItem(
"config.subtitles.subtitle_noPTSrecordingdelay"),
]
elif sub[0] == 1: # teletext
menu = [
getConfigMenuItem("config.subtitles.ttx_subtitle_colors"),
getConfigMenuItem(
"config.subtitles.ttx_subtitle_original_position"),
getConfigMenuItem("config.subtitles.ttx_subtitle_position"),
getConfigMenuItem("config.subtitles.subtitle_fontsize"),
getConfigMenuItem("config.subtitles.subtitle_rewrap"),
getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
getConfigMenuItem("config.subtitles.showbackground"),
getConfigMenuItem("config.subtitles.subtitle_alignment"),
getConfigMenuItem(
"config.subtitles.subtitle_bad_timing_delay"),
getConfigMenuItem(
"config.subtitles.subtitle_noPTSrecordingdelay"),
]
else: # pango
menu = [
getConfigMenuItem("config.subtitles.pango_subtitles_delay"),
getConfigMenuItem("config.subtitles.pango_subtitle_colors"),
getConfigMenuItem(
"config.subtitles.pango_subtitle_fontswitch"),
getConfigMenuItem("config.subtitles.colourise_dialogs"),
getConfigMenuItem("config.subtitles.subtitle_fontsize"),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem("config.subtitles.subtitle_alignment"),
getConfigMenuItem("config.subtitles.subtitle_rewrap"),
getConfigMenuItem("config.subtitles.pango_subtitle_removehi"),
getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
getConfigMenuItem("config.subtitles.showbackground"),
getConfigMenuItem("config.subtitles.pango_subtitles_fps"),
]
self["videofps"].setText(
_("Video: %s fps") % (self.getFps().rstrip(".000")))
ConfigListScreen.__init__(self,
menu,
self.session,
on_change=self.changedEntry)
self["actions"] = NumberActionMap(["SetupActions"], {
"cancel": self.cancel,
"ok": self.ok,
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session):
self.session = session
Screen.__init__(self, self.session)
ProtectedScreen.__init__(self)
# Lets get a list of elements for the config list
self.list = [
getConfigListEntry(_("Enabled"),
config.plugins.KiddyTimer.enabled),
getConfigListEntry(_("PIN"), config.plugins.KiddyTimer.pin),
getConfigListEntry(_("Don't monitor TV started before"),
config.plugins.KiddyTimer.monitorStartTime),
getConfigListEntry(_("Don't monitor TV started after"),
config.plugins.KiddyTimer.monitorEndTime),
getConfigListEntry(_("Style of timer"),
config.plugins.KiddyTimer.timerStyle),
getConfigListEntry(
_("Timeout for activation dialog"),
config.plugins.KiddyTimer.activationDialogTimeout)
]
for i in range(0, 7):
self.list.append(
getConfigListEntry(
KTglob.DAYNAMES[i],
config.plugins.KiddyTimer.dayTimes[i].timeValue))
ConfigListScreen.__init__(self, self.list)
self["config"].list = self.list
self.skin_path = KTglob.plugin_path
self.kiddyTimerStopped = False
# Temporarily stop timer as long as we are in the setup screen
if kiddyTimer.active:
self.kiddyTimerStopped = True
kiddyTimer.stopTimer()
# Plugin Information
self.remainingTime = config.plugins.KiddyTimer.remainingTime.value
sRemainingTime = KTglob.getTimeFromSeconds(self.remainingTime, True)
self["PluginInfo"] = Label(
_("Plugin: %(plugin)s , Version: %(version)s") %
dict(plugin=KTglob.PLUGIN_BASE, version=KTglob.PLUGIN_VERSION))
self["RemainingTime"] = Label(_("Remaining time: %s") % sRemainingTime)
self["LastDayStarted"] = Label(
_("Last day started: %s") %
config.plugins.KiddyTimer.lastStartDay.getValue())
# BUTTONS
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("Save"))
self["key_yellow"] = Button(_("Reset clock"))
self["key_blue"] = Button(_("Move clock"))
self["setupActions"] = NumberActionMap(
["SetupActions", "ColorActions"], {
"save": self.save,
"cancel": self.cancel,
"green": self.save,
"red": self.cancel,
"ok": self.save,
"blue": self.keyPositioner,
"yellow": self.resetTimer
}, -2)
def __init__(self, session):
Screen.__init__(self, session)
self.skinName = ["DmmBlindscanScreen", "Blindscan", "Setup"]
Screen.setTitle(self, _("Blind scan for DVB-S2 tuners"))
self.updateSatList()
self.service = session.nav.getCurrentService()
self.feinfo = None
self.is_c_band_scan = False
self.is_Ku_band_scan = False
self.user_defined_lnb_scan = False
self.user_defined_lnb_lo_freq = 0
frontendData = None
# make config
self.legacy = True
for slot in nimmanager.nim_slots:
if slot.canBeCompatible("DVB-S"):
try:
slot.config.dvbs
self.legacy = False
except:
self.legacy = True
break
if self.service is not None:
self.feinfo = self.service.frontendInfo()
frontendData = self.feinfo and self.feinfo.getAll(True)
self.createConfig(frontendData)
del self.feinfo
del self.service
try:
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
except:
self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceReference()
self["actions"] = NumberActionMap(["SetupActions"],
{
"cancel": self.keyCancel,
}, -2)
self["actions2"] = NumberActionMap(["SetupActions"],
{
"ok": self.keyGo,
"save": self.keyGo,
}, -2)
self["actions2"].setEnabled(False)
self["key_red"] = StaticText(_("Exit"))
self["key_green"] = StaticText("")
self["description"] = Label("")
self.list = []
ConfigListScreen.__init__(self, self.list)
if self.scan_nims.value == "": # no usable nims were found (handled in createConfig())
self["introduction"] = Label(_("Please setup your tuner configuration."))
else:
self.createSetup()
self["introduction"] = Label(_("Press OK to start the scan."))
if not self.selectionChanged in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.selectionChanged)
self.selectionChanged()
def __init__(self, session, title="", text=""):
#VirtualKeyBoard.__init__(self, session, title, text) Changed by Topfi, added parameter names
VirtualKeyBoard.__init__(self, session, title=title, text=text)
NumericalTextInput.__init__(self, nextFunc=self.nextFunc)
SkinResolutionHelper.__init__(self)
self.configText = None
if config.AdvancedMovieSelection.keyboard.value == "virtual":
use = self.KEYBOARD
elif config.AdvancedMovieSelection.keyboard.value == "numerical":
use = self.NUM_KEYB
else:
use = self.BOTH
if not use & self.KEYBOARD:
# hide the keyboard
self["list"].hide()
# overwrite VirtualKeyBoard actions
# make sure not overwrite any action of base class
self["actions"] = ActionMap(
[
"OkCancelActions", "WizardActions", "ColorActions",
"KeyboardInputActions", "InputBoxActions",
"InputAsciiActions"
], {
"ok": self.__ok,
"cancel": self.__cancel,
"left": self.dummy,
"right": self.dummy,
"up": self.dummy,
"down": self.dummy,
"red": self.__cancel,
"green": self.__ok,
"yellow": self.dummy,
"deleteBackward": self.dummy,
"back": self.dummy
}, -2)
if use & self.NUM_KEYB:
self.timer = eTimer()
self.timer.callback.append(self.timeout)
self.configText = ConfigText("", False)
if text:
self.configText.text = text
self.configText.marked_pos = len(text)
self["config_actions"] = NumberActionMap(
["SetupActions", "InputAsciiActions", "KeyboardInputActions"],
{
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
}, -1) # to prevent left/right overriding the listbox
if use & self.KEYBOARD:
self.selectedKey = self.getKeyIndex(u"OK")
self.onLayoutFinish.append(self.__onLayoutFinish)
self.onClose.append(self.__onClose)
def __init__(self, session, infobar=None, page=PAGE_AUDIO):
Screen.__init__(self, session)
self["streams"] = List([], enableWrapAround=True)
self["key_red"] = Boolean(False)
self["key_green"] = Boolean(False)
self["key_yellow"] = Boolean(True)
self["key_blue"] = Boolean(False)
self["key_left"] = Pixmap()
self["key_right"] = Pixmap()
self["switchdescription"] = Label(
_("Switch between Audio-, Subtitlepage"))
self["summary_description"] = StaticText("")
self.protectContextMenu = True
ConfigListScreen.__init__(self, [])
self.infobar = infobar or self.session.infobar
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evUpdatedInfo: self.__updatedInfo})
self.cached_subtitle_checked = False
self.__selected_subtitle = None
self["actions"] = NumberActionMap(
[
"ColorActions", "OkCancelActions", "DirectionActions",
"MenuActions", "InfobarAudioSelectionActions",
"InfobarSubtitleSelectionActions"
], {
"red": self.keyRed,
"green": self.keyGreen,
"yellow": self.keyYellow,
"subtitleSelection": self.keyAudioSubtitle,
"audioSelection": self.keyAudioSubtitle,
"blue": self.keyBlue,
"ok": self.keyOk,
"cancel": self.cancel,
"up": self.keyUp,
"down": self.keyDown,
"volumeUp": self.volumeUp,
"volumeDown": self.volumeDown,
"volumeMute": self.volumeMute,
"menu": self.openAutoLanguageSetup,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
}, -2)
self.settings = ConfigSubsection()
choicelist = [(PAGE_AUDIO, ""), (PAGE_SUBTITLES, "")]
self.settings.menupage = ConfigSelection(choices=choicelist,
default=page)
self.onLayoutFinish.append(self.__layoutFinished)
def __init__(self, session, infobar):
Screen.__init__(self, session)
self.infobar = infobar or self.session.infobar
self.wait = eTimer()
self.wait.timeout.get().append(self.resyncSubtitles)
self.resume = eTimer()
self.resume.timeout.get().append(self.resyncSubtitlesResume)
self["videofps"] = Label("")
sub = self.infobar.selected_subtitle
if sub[0] == 0: # dvb
menu = [
getConfigMenuItem("config.subtitles.dvb_subtitles_yellow"),
getConfigMenuItem("config.subtitles.dvb_subtitles_backtrans"),
getConfigMenuItem(
"config.subtitles.dvb_subtitles_original_position"),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem(
"config.subtitles.subtitle_bad_timing_delay"),
getConfigMenuItem(
"config.subtitles.subtitle_noPTSrecordingdelay"),
]
elif sub[0] == 1: # teletext
menu = [
getConfigMenuItem("config.subtitles.ttx_subtitle_colors"),
getConfigMenuItem(
"config.subtitles.ttx_subtitle_original_position"),
getConfigMenuItem("config.subtitles.subtitle_fontsize"),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem("config.subtitles.subtitle_rewrap"),
getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
getConfigMenuItem("config.subtitles.subtitle_alignment"),
getConfigMenuItem(
"config.subtitles.subtitle_bad_timing_delay"),
getConfigMenuItem(
"config.subtitles.subtitle_noPTSrecordingdelay"),
]
else: # pango
menu = [
getConfigMenuItem("config.subtitles.pango_subtitles_delay"),
getConfigMenuItem("config.subtitles.pango_subtitle_colors"),
getConfigMenuItem(
"config.subtitles.pango_subtitle_fontswitch"),
getConfigMenuItem("config.subtitles.colourise_dialogs"),
getConfigMenuItem("config.subtitles.subtitle_fontsize"),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem("config.subtitles.subtitle_alignment"),
getConfigMenuItem("config.subtitles.subtitle_rewrap"),
getConfigMenuItem("config.subtitles.pango_subtitle_removehi"),
getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
getConfigMenuItem("config.subtitles.pango_subtitles_fps"),
]
self["videofps"].setText(
_("Video: %s fps") % (self.getFps().rstrip(".000")))
ConfigListScreen.__init__(self,
menu,
self.session,
on_change=self.changedEntry)
self["actions"] = NumberActionMap(
["SetupActions"], {
"cancel": self.cancel,
"ok": self.ok,
"1": self.keyNumber,
"3": self.keyNumber,
"4": self.keyNumber,
"6": self.keyNumber,
"7": self.keyNumber,
"9": self.keyNumber,
"0": self.keyNumber,
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self,
session,
title="",
list=[],
keys=None,
selection=0,
skin_name=[],
reorderConfig="",
windowTitle=None):
Screen.__init__(self, session)
if isinstance(skin_name, str):
skin_name = [skin_name]
self.skinName = skin_name + ["ChoiceBox"]
self.reorderConfig = reorderConfig
self["autoresize"] = Label("") # do not remove, used for autoResize()
self["description"] = Label()
self["text"] = Label(title)
self.list = []
self.summarylist = []
if keys is None:
self.__keys = [
"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red",
"green", "yellow", "blue"
] + (len(list) - 14) * [""]
else:
self.__keys = keys + (len(list) - len(keys)) * [""]
self.keymap = {}
pos = 0
if self.reorderConfig:
self.config_type = eval("config.misc.pluginlist." +
self.reorderConfig)
if self.config_type.value:
prev_list = zip(list, self.__keys)
new_list = []
for x in self.config_type.value.split(","):
for entry in prev_list:
if entry[0][0] == x:
new_list.append(entry)
prev_list.remove(entry)
list = zip(*(new_list + prev_list))
list, self.__keys = list[0], list[1]
number = 1
new_keys = []
for x in self.__keys:
if (not x or x.isdigit()) and number <= 10:
new_keys.append(str(number % 10))
number += 1
else:
new_keys.append(not x.isdigit() and x or "")
self.__keys = new_keys
for x in list:
strpos = str(self.__keys[pos])
self.list.append(ChoiceEntryComponent(key=strpos, text=x))
if self.__keys[pos] != "":
self.keymap[self.__keys[pos]] = list[pos]
self.summarylist.append((self.__keys[pos], x[0]))
pos += 1
self["list"] = ChoiceList(list=self.list, selection=selection)
self["summary_list"] = StaticText()
self["summary_selection"] = StaticText()
self.updateSummary(selection)
self["actions"] = NumberActionMap(
[
"WizardActions", "InputActions", "ColorActions",
"DirectionActions", "MenuActions"
], {
"ok": self.go,
"back": self.cancel,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
"red": self.keyRed,
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"up": self.up,
"down": self.down,
"moveUp": self.additionalMoveUp,
"moveDown": self.additionalMoveDown,
"menu": self.setDefaultChoiceList
}, -1)
self.setTitle(windowTitle or _("Select"))
def __init__(self, session, args=0):
global x, y
self.skin = dreamIRCMainMenu.skin
Screen.__init__(self, session)
self.menu = args
self.pipe = MessagePipe()
self.account = AccountManager(self.session)
self.list = []
self.menuList = []
self.connected = False
self["buddy"] = BuddyWindow("")
self["chat"] = ChatWindow("")
self["input"] = Input("")
self["buddy.desc"] = Label(_("User Online"))
self["input.desc"] = Label(
_("Type your text here and press OK to send:"))
self["chat.desc"] = ChanName(_("ChatBox"))
self["connect.desc"] = Label(_("Connect"))
self["disconnect.desc"] = Label(_("Disconnect"))
self["settings.desc"] = Label(_("Settings"))
if y >= 720:
self["blue.desc"] = Label(_("virtual Keyboard"))
else:
self["blue.desc"] = Label(_("virtual Keyb."))
self["green.pic"] = Pixmap()
self["red.pic"] = Pixmap()
self["yellow.pic"] = Pixmap()
self["blue.pic"] = Pixmap()
self["actions"] = NumberActionMap(
[
"dreamIRCActions", "InputBoxActions", "InputAsciiActions",
"KeyboardInputActions"
], {
"gotAsciiCode": self.gotAsciiCode,
"red": self.redPressed,
"green": self.greenPressed,
"yellow": self.yellowPressed,
"blue": self.bluePressed,
"ok": self.go,
"cancel": self.closePlugin,
"back": self.closePlugin,
"right": self.keyRight,
"left": self.keyLeft,
"up": self["chat"].pageUp,
"down": self["chat"].pageDown,
"buddyUp": self["buddy"].pageUp,
"buddyDown": self["buddy"].pageDown,
"home": self.keyHome,
"end": self.keyEnd,
"delete": self.keyDelete,
"deleteForward": self.keyDeleteForward,
"deleteBackward": self.keyDeleteBackward,
"tab": self.keyTab,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
}, -1)
rcinput = eRCInput.getInstance()
rcinput.setKeyboardMode(rcinput.kmAscii)
self.checkStatus()
def __init__(self, session):
Screen.__init__(self, session)
self.setTitle(_("Plugin Browser"))
ProtectedScreen.__init__(self)
self.firsttime = True
self["key_red"] = self["red"] = Label(_("Remove plugins"))
self["key_green"] = self["green"] = Label(_("Download plugins"))
self["key_blue"] = self["blue"] = Label(_("Hold plugins"))
self.list = []
self["list"] = PluginList(self.list)
if config.usage.sort_pluginlist.getValue():
self["list"].list.sort()
self["actions"] = ActionMap(
["SetupActions", "WizardActions", "EPGSelectActions"], {
"ok": self.save,
"back": self.close,
"menu": self.menu,
})
self["PluginDownloadActions"] = ActionMap(["ColorActions"], {
"red": self.delete,
"green": self.download,
"blue": self.toogle
})
self["DirectionActions"] = ActionMap(["DirectionActions"], {
"moveUp": self.moveUp,
"moveDown": self.moveDown
})
self["NumberActions"] = NumberActionMap(
["NumberActions"], {
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
})
self["HelpActions"] = ActionMap(["HelpActions"], {
"displayHelp": self.showHelp,
})
self.help = False
self.number = 0
self.nextNumberTimer = eTimer()
self.nextNumberTimer.callback.append(self.okbuttonClick)
self.onFirstExecBegin.append(self.checkWarnings)
self.onShown.append(self.updateList)
self.onChangedEntry = []
self["list"].onSelectionChanged.append(self.selectionChanged)
self.onLayoutFinish.append(self.saveListsize)
if config.pluginfilter.userfeed.getValue() != "http://":
if not os.path.exists("/etc/opkg/user-feed.conf"):
CreateFeedConfig()
def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
count = 0
for x in parent: #walk through the actual nodelist
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
self.addMenu(list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
description = x.get("description",
"").encode("UTF-8") or None
description = description and _(description)
menupng = MenuEntryPixmap(menuID, self.png_cache,
lastMenuID)
list.append((x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")),
x[4], description, menupng))
count += 1
if menuID is not None:
# plugins
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
description = plugins.getDescriptionForMenuEntryID(
menuID, plugin_menuid)
menupng = MenuEntryPixmap(l[2], self.png_cache, lastMenuID)
list.append((l[0], boundFunction(l[1],
self.session), l[2], l[3]
or 50, description, menupng))
# for the skin: first try a menu_<menuID>, then Menu
self.skinName = []
if menuID is not None:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
# Sort by Weight
list.sort(key=lambda x: int(x[3]))
self._list = List(list)
self._list.onSelectionChanged.append(self._onSelectionChanged)
self["menu"] = self._list
self["pixmap"] = Pixmap()
self["description"] = StaticText()
self["actions"] = NumberActionMap(
["OkCancelActions", "MenuActions", "NumberActions"], {
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
a = parent.get("title", "").encode("UTF-8") or None
a = a and _(a)
if a is None:
a = _(parent.get("text", "").encode("UTF-8"))
self["title"] = StaticText(a)
self.menu_title = a
self.onLayoutFinish.append(self._onLayoutFinish)
def __init__(self, session, params={}):
# Skin generator
maxWidth = 0
pX = 40
pY = 60
dY = 10
skinItems = ''
self.icons = []
self.list = params['list']
self.withAcceptButton = params.get('with_accept_button', False)
self.statusText = params.get('status_text', '')
statusTextHight = params.get('status_text_hight', 80)
# calcl maxWidth size
for idx in range(len(self.list)):
item = self.list[idx]
if item['label_size'][0] > maxWidth: maxWidth = item['label_size'][0]
if item['input_size'][0] > maxWidth: maxWidth = item['input_size'][0]
maxWidth += pX*2
if len(self.statusText):
skinItems = '<widget name="statustext" position="10,%d" zPosition="2" size="%d,%d" valign="center" halign="center" font="Regular;22" transparent="1" />' % (pY+dY, maxWidth-20, statusTextHight)
pY += statusTextHight + dY*2
for idx in range(len(self.list)):
item = self.list[idx]
if 'icon_path' in item:
self["cover_%d"%idx] = Cover2()
self.icons.append({'name':"cover_%d"%idx, 'path':item['icon_path']})
else:
self["text_%d"%idx] = Label(item.get('title', ''))
self["input_%d"%idx] = Input(**item['input'])
self["border_%d"%idx] = Label("")
if item.get('useable_chars', None) is not None:
self["input_%d"%idx].setUseableChars(item['useable_chars'])
if 'icon_path' in item:
skinItems += '<widget name="cover_%d" position="%d,%d" size="%d,%d" zPosition="8" />' % (idx, (maxWidth - item['label_size'][0]) / 2, pY, item['label_size'][0], item['label_size'][1])
else:
skinItems += '<widget name="text_%d" position="%d,%d" size="%d,%d" font="%s" zPosition="2" />' % (idx, 10, pY, item['label_size'][0], item['label_size'][1], item['label_font'])
pY += dY + item['label_size'][1]
skinItems += '<widget name="input_%d" position="%d,%d" size="%d,%d" font="%s" zPosition="2" />' % (idx, pX, pY, item['input_size'][0], item['input_size'][1], item['input_font'])
skinItems += '<widget name="border_%d" position="%d,%d" size="%d,%d" font="%s" zPosition="1" transparent="0" backgroundColor="#331F93B9" />' % (idx, pX-5, pY-5, item['input_size'][0]+10, item['input_size'][1]+10, item['input_font'])
if 0 == idx:
self['marker'] = Cover3()
skinItems += '<widget name="marker" zPosition="2" position="10,%d" size="16,16" transparent="1" alphatest="blend" />' % (pY + (item['input_size'][1]-16) / 2)
skinItems += '<widget name="marker_%d" zPosition="1" position="10,%d" size="16,16" transparent="1" alphatest="blend" />' % (idx, pY + (item['input_size'][1]-16) / 2)
self['marker_%d'%idx] = Cover3()
pY += dY*2 + item['input_size'][1]
if self.withAcceptButton:
skinItems += '<widget name="accept_button" position="10,%d" zPosition="2" size="%d,50" valign="center" halign="center" font="Regular;22" foregroundColor="#00FFFFFF" backgroundColor="#320F0F0F" />' % (pY, maxWidth-20)
pY += dY*2 + 50
self.skin = """
<screen name="IPTVMultipleInputBox" position="center,center" size="%d,%d" title="%s">
<widget name="key_red" position="10,10" zPosition="2" size="%d,35" valign="center" halign="left" font="Regular;22" transparent="1" foregroundColor="red" />
<widget name="key_ok" position="10,10" zPosition="2" size="%d,35" valign="center" halign="center" font="Regular;22" transparent="1" foregroundColor="white" />
<widget name="key_green" position="10,10" zPosition="2" size="%d,35" valign="center" halign="right" font="Regular;22" transparent="1" foregroundColor="green" />
%s
</screen>
""" % (maxWidth, pY, params.get('title', _("Input")), maxWidth-20, maxWidth-20, maxWidth-20, skinItems)
self["key_green"] = Label(params.get('accep_label', _("Save")))
self["key_ok"] = Label(_("OK"))
self["key_red"] = Label(_("Cancel"))
if len(self.statusText):
self["statustext"] = Label(str(self.statusText))
if self.withAcceptButton:
self["accept_button"] = Label(params.get('accep_label', _("Verify")))
self.params = params
Screen.__init__(self, session)
self.onShown.append(self.onStart)
self.onClose.append(self.__onClose)
self["actions"] = NumberActionMap(["ColorActions", "WizardActions", "InputBoxActions", "InputAsciiActions", "KeyboardInputActions"],
{
"gotAsciiCode": self.gotAsciiCode,
"green" : self.keySave,
"ok" : self.keyOK,
"red" : self.keyCancel,
"back" : self.keyCancel,
"left" : self.keyLeft,
"right" : self.keyRight,
"up" : self.keyUp,
"down" : self.keyDown,
"right" : self.keyRight,
"home" : self.keyHome,
"end" : self.keyEnd,
"deleteForward" : self.keyDelete,
"deleteBackward": self.keyBackspace,
"tab": self.keyTab,
"toggleOverwrite": self.keyInsert,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
}, -1)
self.idx = 0
self.activeInput = "input_0"
self.markerPixmap = [LoadPixmap(GetIconDir('radio_button_on.png')), LoadPixmap(GetIconDir('radio_button_off.png'))]
self.started = False
def __init__(self, session, parent):
Screen.__init__(self, session)
self.sort_mode = False
self.selected_entry = None
self.sub_menu_sort = None
self["green"] = Label()
self["yellow"] = Label()
self["blue"] = Label()
m_list = []
menuID = None
for x in parent: #walk through the actual nodelist
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(m_list, x)
count += 1
elif x.tag == 'menu':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addMenu(m_list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
m_list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")), x[4]))
count += 1
self.menuID = menuID
if menuID is not None:
# plugins
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in m_list:
if x[2] == plugin_menuid:
m_list.remove(x)
break
if len(l) > 4 and l[4]:
m_list.append(
(l[0], boundFunction(l[1], self.session,
self.close), l[2], l[3] or 50))
else:
m_list.append(
(l[0], boundFunction(l[1], self.session), l[2], l[3]
or 50))
# for the skin: first try a menu_<menuID>, then Menu
self.skinName = []
if menuID is not None:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
self.menuID = menuID
ProtectedScreen.__init__(self)
if config.plugins.infopanel_usermenus is not None and menuID == "mainmenu":
plugin_list = []
id_list = []
for l in plugins.getPlugins([
PluginDescriptor.WHERE_PLUGINMENU,
PluginDescriptor.WHERE_EXTENSIONSMENU,
PluginDescriptor.WHERE_EVENTINFO
]):
l.id = (l.name.lower()).replace(' ', '_')
if l.id not in id_list:
id_list.append(l.id)
plugin_list.append(
(l.name, boundFunction(l.__call__,
session), l.id, 200))
addlist = config.plugins.infopanel_usermenus.value
addlist = addlist.split(',')
for entry in plugin_list:
if entry[2] in addlist:
list.append(entry)
self.list = list
# Sort by Weight
#if config.usage.sort_menus.value:
# list.sort()
#else:
if config.usage.menu_sort_mode.value == "user" and menuID == "mainmenu":
plugin_list = []
id_list = []
for l in plugins.getPlugins([
PluginDescriptor.WHERE_PLUGINMENU,
PluginDescriptor.WHERE_EXTENSIONSMENU,
PluginDescriptor.WHERE_EVENTINFO
]):
l.id = (l.name.lower()).replace(' ', '_')
if l.id not in id_list:
id_list.append(l.id)
plugin_list.append(
(l.name, boundFunction(l.__call__,
session), l.id, 200))
self.list = m_list
if menuID is not None and config.usage.menu_sort_mode.value == "user":
self.sub_menu_sort = NoSave(ConfigDictionarySet())
self.sub_menu_sort.value = config.usage.menu_sort_weight.getConfigValue(
self.menuID, "submenu") or {}
idx = 0
for x in self.list:
entry = list(self.list.pop(idx))
m_weight = self.sub_menu_sort.getConfigValue(
entry[2], "sort") or entry[3]
entry.append(m_weight)
self.list.insert(idx, tuple(entry))
self.sub_menu_sort.changeConfigValue(entry[2], "sort",
m_weight)
idx += 1
self.full_list = list(m_list)
if config.usage.menu_sort_mode.value == "a_z":
# Sort by Name
m_list.sort(key=self.sortByName)
elif config.usage.menu_sort_mode.value == "user":
self["blue"].setText(_("Edit mode on"))
self.hide_show_entries()
m_list = self.list
else:
# Sort by Weight
m_list.sort(key=lambda x: int(x[3]))
self["menu"] = List(m_list)
self["menu"].enableWrapAround = True
if config.usage.menu_sort_mode.value == "user":
self["menu"].onSelectionChanged.append(self.selectionChanged)
self["actions"] = NumberActionMap(
["OkCancelActions", "MenuActions", "NumberActions"], {
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"0": self.resetSortOrder,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
if config.usage.menu_sort_mode.value == "user":
self["MoveActions"] = ActionMap(
["WizardActions"], {
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
}, -1)
self["EditActions"] = ActionMap(
["ColorActions"], {
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
})
a = six.ensure_str(parent.get("title", "")) or None
a = a and _(a)
if a is None:
a = _(six.ensure_str(parent.get("text", "")))
else:
t_history.reset()
self["title"] = StaticText(a)
Screen.setTitle(self, a)
self.menu_title = a
self["thistory"] = StaticText(t_history.thistory)
history_len = len(t_history.thistory)
self["title0"] = StaticText('')
self["title1"] = StaticText('')
self["title2"] = StaticText('')
if history_len < 13:
self["title0"] = StaticText(a)
elif history_len < 21:
self["title0"] = StaticText('')
self["title1"] = StaticText(a)
else:
self["title0"] = StaticText('')
self["title1"] = StaticText('')
self["title2"] = StaticText(a)
if (t_history.thistory == ''):
t_history.thistory = str(a) + ' > '
else:
t_history.thistory = t_history.thistory + str(a) + ' > '
def __init__(self, session):
Screen.__init__(self, session)
self["red"] = Pixmap()
self["green"] = Pixmap()
self["yellow"] = Pixmap()
self["blue"] = Pixmap()
self["red_text"] = Label()
self["green_text"] = Label()
self["yellow_text"] = Label()
self["blue_text"] = Label()
self["current_status"] = Label()
self.is_active = self.session.nav.SleepTimer.isActive()
if self.is_active:
self["current_status"].setText(
_("Timer status:") + " " + _("Enabled"))
else:
self["current_status"].setText(
_("Timer status:") + " " + _("Disabled"))
if self.is_active:
self.time = self.session.nav.SleepTimer.getCurrentSleepTime()
else:
self.time = config.SleepTimer.defaulttime.value
self["input"] = Input(text=str(self.time),
maxSize=False,
type=Input.NUMBER)
self.status = True
self.updateColors()
self["pretext"] = Label(_("Shutdown STB after"))
self["aftertext"] = Label(_("minutes"))
self["actions"] = NumberActionMap(
[
"SleepTimerEditorActions", "TextEntryActions",
"KeyboardInputActions"
], {
"exit": self.cancel,
"select": self.select,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
"selectLeft": self.selectLeft,
"selectRight": self.selectRight,
"left": self.selectLeft,
"right": self.selectRight,
"home": self.selectHome,
"end": self.selectEnd,
"deleteForward": self.deleteForward,
"deleteBackward": self.deleteBackward,
"disableTimer": self.disableTimer,
"toggleAction": self.toggleAction,
"toggleAsk": self.toggleAsk,
"useServiceTime": self.useServiceTime
}, -1)
def __init__(self,
session,
showSteps=True,
showStepSlider=True,
showList=True,
showConfig=True):
Screen.__init__(self, session)
self.isLastWizard = False # can be used to skip a "goodbye"-screen in a wizard
self.stepHistory = []
self.wizard = {}
parser = make_parser()
if not isinstance(self.xmlfile, list):
self.xmlfile = [self.xmlfile]
# print "Reading ", self.xmlfile
wizardHandler = self.parseWizard(self.wizard)
parser.setContentHandler(wizardHandler)
for xmlfile in self.xmlfile:
if xmlfile[0] != '/':
parser.parse(eEnv.resolve('${datadir}/enigma2/') + xmlfile)
else:
parser.parse(xmlfile)
self.showSteps = showSteps
self.showStepSlider = showStepSlider
self.showList = showList
self.showConfig = showConfig
self.doingVKeyCallback = False
self.numSteps = len(self.wizard)
self.currStep = self.getStepWithID("start") + 1
self.timeoutTimer = eTimer()
self.timeoutTimer.callback.append(self.timeoutCounterFired)
self["text"] = Label()
if showConfig:
self["config"] = ConfigList([], session=session)
if self.showSteps:
self["step"] = Label()
if self.showStepSlider:
self["stepslider"] = Slider(1, self.numSteps)
if self.showList:
self.list = []
self["list"] = List(self.list, enableWrapAround=True)
self["list"].onSelectionChanged.append(self.selChanged)
#self["list"] = MenuList(self.list, enableWrapAround = True)
self.onShown.append(self.updateValues)
self.configInstance = None
self.currentConfigIndex = None
Wizard.instance = self
self.lcdCallbacks = []
self.disableKeys = False
self["actions"] = NumberActionMap(
[
"WizardActions", "DirectionActions", "NumberActions",
"ColorActions", "SetupActions", "InputAsciiActions",
"KeyboardInputActions"
], {
"gotAsciiCode": self.keyGotAscii,
"ok": self.ok,
"back": self.back,
"left": self.left,
"right": self.right,
"up": self.up,
"down": self.down,
"red": self.red,
"green": self.green,
"yellow": self.yellow,
"blue": self.blue,
"deleteBackward": self.deleteBackward,
"deleteForward": self.deleteForward,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
}, -1)
self["VirtualKB"] = NumberActionMap(
["VirtualKeyboardActions"], {
"showVirtualKeyboard": self.KeyText,
}, -2)
self["VirtualKB"].setEnabled(False)
def __init__(self, session):
Screen.__init__(self, session)
if config.ParentalControl.configured.value:
ProtectedScreen.__init__(self)
Screen.setTitle(self, _("Plugin Browser"))
ProtectedScreen.__init__(self)
self.firsttime = True
self.sort_mode = False
self.selected_plugin = None
self["key_red"] = self["red"] = Label(_("Remove plugins"))
self["key_green"] = self["green"] = Label(_("Download plugins"))
self["key_yellow"] = self["yellow"] = Label(_("PluginInstallWizard"))
self["key_blue"] = self["blue"] = Label(_("PluginDeinstallWizard"))
self["key_info"] = self["key_Info"] = Label(_(""))
self.list = []
self["list"] = PluginList(self.list)
self["actions"] = ActionMap(["SetupActions", "WizardActions"],
{
"ok": self.keyOk,
"back": self.keyCancel,
"menu": self.menu,
})
self["PluginDownloadActions"] = ActionMap(["SetupActions", "ColorActions"],
{
"red": self.delete,
"green": self.download,
"blue": self.keyBlue,
"yellow": self.wizardinstall,
"info": self.keyInfo,
})
self["SoftwareActions"] = ActionMap(["SetupActions", "ColorActions"],
{
"red": self.keyRed,
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"info": self.keyInfo,
})
self["MoveActions"] = ActionMap(["WizardActions"],
{
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
}, -1
)
self["NumberAction"] = NumberActionMap(["NumberActions"],
{
"0": self.resetSortOrder,
}, -1
)
self["PluginDownloadActions"].setEnabled(True)
self["SoftwareActions"].setEnabled(False)
self.onFirstExecBegin.append(self.checkWarnings)
self.onShown.append(self.updateList)
self.onChangedEntry = []
self["list"].onSelectionChanged.append(self.selectionChanged)
self.onLayoutFinish.append(self.saveListsize)
if config.pluginfilter.userfeed.value != "http://":
if not os.path.exists("/etc/opkg/user-feed.conf"):
CreateFeedConfig()
def __init__(self,
session,
slotid,
action,
handler=eDVBCI_UI.getInstance(),
wait_text="",
screen_data=None):
Screen.__init__(self, session)
print "MMIDialog with action" + str(action)
self.mmiclosed = False
self.tag = None
self.slotid = slotid
self.timer = eTimer()
self.timer.callback.append(self.keyCancel)
#else the skins fails
self["title"] = Label("")
self["subtitle"] = Label("")
self["bottom"] = Label("")
self["entries"] = ConfigList([])
self["actions"] = NumberActionMap(
["SetupActions", "MenuActions"],
{
"ok": self.okbuttonClick,
"cancel": self.keyCancel,
"menu": self.forceExit,
#for PIN
"left": self.keyLeft,
"right": self.keyRight,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
},
-1)
self.action = action
self.screen_data = screen_data
self.is_pin_list = -1
self.handler = handler
if wait_text == "":
self.wait_text = _("wait for ci...")
else:
self.wait_text = wait_text
if action == 2: #start MMI
handler.startMMI(self.slotid)
self.showWait()
elif action == 3: #mmi already there (called from infobar)
self.showScreen()
def __init__(self, session, infobar):
Screen.__init__(self, session)
self.infobar = infobar or self.session.infobar
self.wait = eTimer()
self.wait.timeout.get().append(self.resyncSubtitles)
self["videofps"] = Label("")
sub = self.infobar.selected_subtitle
if sub[0] == 0: # dvb
menu = [
getConfigListEntry(
findSetupText("config.subtitles.dvb_subtitles_yellow"),
config.subtitles.dvb_subtitles_yellow),
getConfigListEntry(
findSetupText("config.subtitles.dvb_subtitles_centered"),
config.subtitles.dvb_subtitles_centered),
getConfigListEntry(
findSetupText("config.subtitles.dvb_subtitles_backtrans"),
config.subtitles.dvb_subtitles_backtrans),
getConfigListEntry(
findSetupText(
"config.subtitles.dvb_subtitles_original_position"),
config.subtitles.dvb_subtitles_original_position),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_position"),
config.subtitles.subtitle_position),
getConfigListEntry(
findSetupText(
"config.subtitles.subtitle_bad_timing_delay"),
config.subtitles.subtitle_bad_timing_delay),
getConfigListEntry(
findSetupText(
"config.subtitles.subtitle_noPTSrecordingdelay"),
config.subtitles.subtitle_noPTSrecordingdelay),
]
elif sub[0] == 1: # teletext
menu = [
getConfigListEntry(
findSetupText("config.subtitles.ttx_subtitle_colors"),
config.subtitles.ttx_subtitle_colors),
getConfigListEntry(
findSetupText(
"config.subtitles.ttx_subtitle_original_position"),
config.subtitles.ttx_subtitle_original_position),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_fontsize"),
config.subtitles.subtitle_fontsize),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_position"),
config.subtitles.subtitle_position),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_rewrap"),
config.subtitles.subtitle_rewrap),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_borderwidth"),
config.subtitles.subtitle_borderwidth),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_alignment"),
config.subtitles.subtitle_alignment),
getConfigListEntry(
findSetupText(
"config.subtitles.subtitle_bad_timing_delay"),
config.subtitles.subtitle_bad_timing_delay),
getConfigListEntry(
findSetupText(
"config.subtitles.subtitle_noPTSrecordingdelay"),
config.subtitles.subtitle_noPTSrecordingdelay),
]
else: # pango
menu = [
getConfigListEntry(
findSetupText("config.subtitles.pango_subtitles_delay"),
config.subtitles.pango_subtitles_delay),
getConfigListEntry(
findSetupText("config.subtitles.pango_subtitles_yellow"),
config.subtitles.pango_subtitles_yellow),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_fontsize"),
config.subtitles.subtitle_fontsize),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_position"),
config.subtitles.subtitle_position),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_alignment"),
config.subtitles.subtitle_alignment),
getConfigListEntry(
findSetupText("config.subtitles.subtitle_rewrap"),
config.subtitles.subtitle_rewrap),
]
self["videofps"].setText(
_("Video: %s fps") % (self.getFps().rstrip(".000")))
ConfigListScreen.__init__(self,
menu,
self.session,
on_change=self.changedEntry)
self["actions"] = NumberActionMap(["SetupActions"], {
"cancel": self.finish,
"ok": self.finish,
}, -2)
def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
for x in parent: #walk through the actual nodelist
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
self.addMenu(list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")), x[4]))
count += 1
if menuID is not None:
# plugins
bhorder = []
if fileExists(resolveFilename(SCOPE_SKIN, 'menuorder.bh')):
file = open(resolveFilename(SCOPE_SKIN, 'menuorder.bh'), 'r')
for line in file.readlines():
parts = line.strip().split()
res = (parts[0], parts[1])
bhorder.append(res)
file.close()
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
weight = l[3]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
for y in bhorder:
if y[0] == plugin_menuid:
weight = int(y[1])
list.append((l[0], boundFunction(l[1],
self.session), l[2], weight
or 50))
# for the skin: first try a menu_<menuID>, then Menu
self.skinName = []
if menuID is not None:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
# Sort by Weight
list.sort(key=lambda x: int(x[3]))
self["menu"] = List(list)
self["actions"] = NumberActionMap(
["OkCancelActions", "MenuActions", "NumberActions"], {
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
a = parent.get("title", "").encode("UTF-8") or None
a = a and _(a)
if a is None:
a = _(parent.get("text", "").encode("UTF-8"))
self["title"] = StaticText(a)
self.menu_title = a
def __init__(self, session, menu_path = ""):
Screen.__init__(self, session)
self.menu_path = menu_path
screentitle = _("Plugin Browser")
if config.usage.show_menupath.value == 'large':
self.menu_path += screentitle
title = self.menu_path
self["menu_path_compressed"] = StaticText("")
self.menu_path += ' / '
elif config.usage.show_menupath.value == 'small':
title = screentitle
condtext = ""
if self.menu_path and not self.menu_path.endswith(' / '):
condtext = self.menu_path + " >"
elif self.menu_path:
condtext = self.menu_path[:-3] + " >"
self["menu_path_compressed"] = StaticText(condtext)
self.menu_path += screentitle + ' / '
else:
title = screentitle
self["menu_path_compressed"] = StaticText("")
Screen.setTitle(self, title)
ProtectedScreen.__init__(self)
self.firsttime = True
self["key_red"] = Button(_("Remove plugins"))
self["key_green"] = Button(_("Download plugins"))
self.list = []
self["list"] = PluginList(self.list)
if config.usage.sort_pluginlist.value:
self["list"].list.sort()
self["actions"] = ActionMap(["WizardActions", "MenuActions"],
{
"ok": self.save,
"back": self.close,
"menu": self.openSetup,
})
self["PluginDownloadActions"] = ActionMap(["ColorActions"],
{
"red": self.delete,
"green": self.download
})
self["DirectionActions"] = ActionMap(["DirectionActions"],
{
"shiftUp": self.moveUp,
"shiftDown": self.moveDown
})
self["NumberActions"] = NumberActionMap(["NumberActions"],
{
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
})
self.number = 0
self.nextNumberTimer = eTimer()
self.nextNumberTimer.callback.append(self.okbuttonClick)
self.onFirstExecBegin.append(self.checkWarnings)
self.onShown.append(self.updateList)
self.onChangedEntry = []
self["list"].onSelectionChanged.append(self.selectionChanged)
self.onLayoutFinish.append(self.saveListsize)
def __init__(self, session, dvd_device=None, dvd_filelist=None, args=None):
if not dvd_filelist: dvd_filelist = []
Screen.__init__(self, session)
InfoBarBase.__init__(self)
InfoBarNotifications.__init__(self)
InfoBarCueSheetSupport.__init__(self,
actionmap="MediaPlayerCueSheetActions")
InfoBarShowHide.__init__(self)
InfoBarAudioSelection.__init__(self)
InfoBarSubtitleSupport.__init__(self)
HelpableScreen.__init__(self)
self.save_infobar_seek_config()
self.change_infobar_seek_config()
InfoBarSeek.__init__(self)
InfoBarPVRState.__init__(self)
self.oldService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.session.nav.stopService()
self["audioLabel"] = Label("n/a")
self["subtitleLabel"] = Label("")
self["angleLabel"] = Label("")
self["chapterLabel"] = Label("")
self["anglePix"] = Pixmap()
self["anglePix"].hide()
self.last_audioTuple = None
self.last_subtitleTuple = None
self.last_angleTuple = None
self.totalChapters = 0
self.currentChapter = 0
self.totalTitles = 0
self.currentTitle = 0
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStopped: self.__serviceStopped,
iPlayableService.evUser: self.__timeUpdated,
iPlayableService.evUser + 1: self.__statePlay,
iPlayableService.evUser + 2: self.__statePause,
iPlayableService.evUser + 3: self.__osdFFwdInfoAvail,
iPlayableService.evUser + 4: self.__osdFBwdInfoAvail,
iPlayableService.evUser + 5: self.__osdStringAvail,
iPlayableService.evUser + 6: self.__osdAudioInfoAvail,
iPlayableService.evUser + 7: self.__osdSubtitleInfoAvail,
iPlayableService.evUser + 8: self.__chapterUpdated,
iPlayableService.evUser + 9: self.__titleUpdated,
iPlayableService.evUser + 11: self.__menuOpened,
iPlayableService.evUser + 12: self.__menuClosed,
iPlayableService.evUser + 13: self.__osdAngleInfoAvail
})
self["DVDPlayerDirectionActions"] = ActionMap(
["DirectionActions"],
{
#MENU KEY DOWN ACTIONS
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
#MENU KEY REPEATED ACTIONS
"leftRepeated": self.doNothing,
"rightRepeated": self.doNothing,
"upRepeated": self.doNothing,
"downRepeated": self.doNothing,
#MENU KEY UP ACTIONS
"leftUp": self.doNothing,
"rightUp": self.doNothing,
"upUp": self.doNothing,
"downUp": self.doNothing,
})
self["OkCancelActions"] = ActionMap(["OkCancelActions"], {
"ok": self.keyOk,
"cancel": self.keyCancel,
})
self["DVDPlayerPlaybackActions"] = HelpableActionMap(
self,
"DVDPlayerActions",
{
#PLAYER ACTIONS
"dvdMenu": (self.enterDVDMenu, _("show DVD main menu")),
"toggleInfo":
(self.toggleInfo,
_("toggle time, chapter, audio, subtitle info")),
"nextChapter":
(self.nextChapter, _("forward to the next chapter")),
"prevChapter":
(self.prevChapter, _("rewind to the previous chapter")),
"nextTitle":
(self.nextTitle, _("jump forward to the next title")),
"prevTitle":
(self.prevTitle, _("jump back to the previous title")),
"tv": (self.askLeavePlayer,
_("exit DVD player or return to file browser")),
"dvdAudioMenu":
(self.enterDVDAudioMenu, _("(show optional DVD audio menu)")),
"AudioSelection":
(self.enterAudioSelection, _("Select audio track")),
"nextAudioTrack":
(self.nextAudioTrack, _("switch to the next audio track")),
"nextSubtitleTrack":
(self.nextSubtitleTrack,
_("switch to the next subtitle language")),
"nextAngle": (self.nextAngle, _("switch to the next angle")),
"seekBeginning":
self.seekBeginning,
},
-2)
self["NumberActions"] = NumberActionMap(
["NumberActions"], {
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
})
self.onClose.append(self.__onClose)
try:
from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
hotplugNotifier.append(self.hotplugCB)
except:
pass
self.autoplay = dvd_device or dvd_filelist
if dvd_device:
self.physicalDVD = True
else:
self.scanHotplug()
self.dvd_filelist = dvd_filelist
self.onFirstExecBegin.append(self.opened)
self.service = None
self.in_menu = False
def __init__(self, session, parent):
Screen.__init__(self, session)
list = []
menuID = None
for x in parent: #walk through the actual nodelist
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if item_level <= config.usage.setup_level.index:
self.addItem(list, x)
count += 1
elif x.tag == 'menu':
self.addMenu(list, x)
count += 1
elif x.tag == "id":
menuID = x.get("val")
count = 0
if menuID is not None:
# menuupdater?
if menuupdater.updatedMenuAvailable(menuID):
for x in menuupdater.getUpdatedMenu(menuID):
if x[1] == count:
list.append(
(x[0],
boundFunction(self.runScreen,
(x[2], x[3] + ", ")), x[4]))
count += 1
if menuID is not None:
# plugins
for l in plugins.getPluginsForMenu(menuID):
# check if a plugin overrides an existing menu
plugin_menuid = l[2]
for x in list:
if x[2] == plugin_menuid:
list.remove(x)
break
if len(l) > 4 and l[4]:
list.append(
(l[0], boundFunction(l[1], self.session,
self.close), l[2], l[3] or 50))
else:
list.append((l[0], boundFunction(l[1],
self.session), l[2], l[3]
or 50))
# for the skin: first try a menu_<menuID>, then Menu
self.skinName = []
if menuID is not None:
self.skinName.append("menu_" + menuID)
self.skinName.append("Menu")
self.menuID = menuID
ProtectedScreen.__init__(self)
# Sort by Weight
if config.usage.sort_menus.value:
list.sort()
else:
list.sort(key=lambda x: int(x[3]))
if config.usage.menu_show_numbers.value:
list = [(str(x[0] + 1) + " " + x[1][0], x[1][1], x[1][2])
for x in enumerate(list)]
self["menu"] = List(list)
self["actions"] = NumberActionMap(
["OkCancelActions", "MenuActions", "NumberActions"], {
"ok": self.okbuttonClick,
"cancel": self.closeNonRecursive,
"menu": self.closeRecursive,
"0": self.keyNumberGlobal,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal
})
a = parent.get("title", "").encode("UTF-8") or None
a = a and _(a) or _(parent.get("text", "").encode("UTF-8"))
self.menu_title = a
global menu_path
self.menu_path_compressed = menu_path
if menu_path == "":
menu_path += a
elif not menu_path.endswith(a):
menu_path += " / " + a
global full_menu_path
full_menu_path = menu_path + ' / '
if config.usage.show_menupath.value == 'large':
Screen.setTitle(self, menu_path)
self["title"] = StaticText(menu_path)
self["menu_path_compressed"] = StaticText("")
elif config.usage.show_menupath.value == 'small':
Screen.setTitle(self, a)
self["title"] = StaticText(a)
self["menu_path_compressed"] = StaticText(
self.menu_path_compressed and self.menu_path_compressed + " >"
or "")
else:
Screen.setTitle(self, a)
self["title"] = StaticText(a)
self["menu_path_compressed"] = StaticText("")
self.number = 0
self.nextNumberTimer = eTimer()
self.nextNumberTimer.callback.append(self.okbuttonClick)
def __init__(self, session, servicelist=None):
Screen.__init__(self, session)
self.session = session
if SystemInfo.get(
"NumVideoDecoders", 1
) > 1 and config.plugins.virtualzap.usepip.value and config.plugins.virtualzap.showpipininfobar.value:
self.skinName = "VirtualZap"
self.pipAvailable = True
else:
self.skinName = "VirtualZapNoPiP"
self.pipAvailable = (
SystemInfo.get("NumVideoDecoders", 1) > 1
) and config.plugins.virtualzap.usepip.value and not config.plugins.virtualzap.showpipininfobar.value
self.epgcache = eEPGCache.getInstance()
self.CheckForEPG = eTimer()
self.CheckForEPG_conn = self.CheckForEPG.timeout.connect(
self.CheckItNow)
self["NowChannel"] = Label()
self["NowEPG"] = Label()
self["NextEPG"] = Label()
self["NowTime"] = Label()
self["NextTime"] = Label()
self["actions"] = ActionMap(
[
"OkCancelActions", "DirectionActions",
"ChannelSelectBaseActions", "ChannelSelectEPGActions",
"ColorActions"
], {
"ok": self.ok,
"cancel": self.closing,
"right": self.nextService,
"left": self.prevService,
"nextBouquet": self.showFavourites,
"prevBouquet": self.openServiceList,
"showEPGList": self.openEventView,
"blue": self.standardPiP,
"yellow": self.switchAndStandardPiP,
"down": self.switchChannelDown,
"up": self.switchChannelUp,
}, -2)
self["actions2"] = NumberActionMap(
["NumberActions"], {
"0": self.swap,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
}, -1)
self.onLayoutFinish.append(self.onLayoutReady)
# PiP
if self.pipAvailable:
# activate PiP support
if config.plugins.virtualzap.usepip.value and not config.plugins.virtualzap.showpipininfobar.value:
# activate standard PiP
self["video"] = VideoWindow()
else:
# show PiP in Infobar
self["video"] = VideoWindow(
fb_width=getDesktop(0).size().width(),
fb_height=getDesktop(0).size().height())
self.currentPiP = ""
else:
# no PiP
self["video"] = Label()
# this is the servicelist from ChannelSelectionBase
self.servicelist = servicelist
# save orig. method of zap in servicelist
self.servicelist_orig_zap = self.servicelist.zap
# when displaying ChannelSelection, do not zap when pressing "ok", so new method is needed
self.servicelist.zap = self.servicelist_overwrite_zap
# overwrite the actionmap of ChannelSelection
self.servicelist["actions"] = ActionMap(
["OkCancelActions"], {
"cancel": self.cancelChannelSelection,
"ok": self.servicelist.channelSelected,
})
# temp. vars, needed when pressing cancel in ChannelSelection
self.curSelectedRef = None
self.curSelectedBouquet = None
# needed, because if we won't zap, we have to go back to the current bouquet and service
self.curRef = ServiceReference(self.servicelist.getCurrentSelection())
self.curBouquet = self.servicelist.getRoot()
# start with last used service
if config.plugins.virtualzap.saveLastService.value:
# get service and bouquet ref
ref = eServiceReference(config.plugins.virtualzap.curref.value)
bouquet = eServiceReference(
config.plugins.virtualzap.curbouquet.value)
if ref.valid() and bouquet.valid():
# select bouquet and ref in servicelist
self.setServicelistSelection(bouquet, ref)
# prepare exitTimer
self.exitTimer = eTimer()
self.exitTimer_conn = self.exitTimer.timeout.connect(self.standardPiP)
# reverse changes of ChannelSelection when closing plugin
self.onClose.append(self.__onClose)
# if PiPServiceRelation is installed, get relation dict
if plugin_PiPServiceRelation_installed:
self.pipServiceRelation = getRelationDict()
else:
self.pipServiceRelation = {}
def __init__(self, session, infobar):
Screen.__init__(self, session)
self.skin = QuickSubtitlesConfigMenu.skin
self.infobar = infobar or self.session.infobar
self.wait = eTimer()
self.wait.timeout.get().append(self.resyncSubtitles)
self["videofps"] = Label("")
sub = self.infobar.selected_subtitle
if sub[0] == 0: # dvb
menu = [
getConfigMenuItem("config.subtitles.subtitle_fontcolor"),
getConfigMenuItem("config.subtitles.dvb_subtitles_centered"),
getConfigMenuItem("config.subtitles.subtitle_bgopacity"),
getConfigMenuItem(
"config.subtitles.subtitle_original_position"),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem(
"config.subtitles.subtitle_bad_timing_delay"),
getConfigMenuItem(
"config.subtitles.subtitle_noPTSrecordingdelay"),
]
elif sub[0] == 1: # teletext
menu = [
getConfigMenuItem("config.subtitles.subtitle_fontcolor"),
getConfigMenuItem("config.subtitles.subtitle_fontsize"),
getConfigMenuItem("config.subtitles.subtitle_opacity"),
getConfigMenuItem("config.subtitles.subtitle_bgcolor"),
getConfigMenuItem("config.subtitles.subtitle_bgopacity"),
getConfigMenuItem("config.subtitles.subtitle_edgestyle"),
getConfigMenuItem("config.subtitles.subtitle_edgestyle_level"),
getConfigMenuItem(
"config.subtitles.subtitle_original_position"),
getConfigMenuItem("config.subtitles.subtitle_alignment"),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem("config.subtitles.subtitle_rewrap"),
getConfigMenuItem(
"config.subtitles.subtitle_bad_timing_delay"),
getConfigMenuItem(
"config.subtitles.subtitle_noPTSrecordingdelay"),
]
else: # pango
menu = [
getConfigMenuItem("config.subtitles.subtitle_fontcolor"),
getConfigMenuItem("config.subtitles.subtitle_fontsize"),
getConfigMenuItem("config.subtitles.subtitle_opacity"),
getConfigMenuItem("config.subtitles.subtitle_bgcolor"),
getConfigMenuItem("config.subtitles.subtitle_bgopacity"),
getConfigMenuItem("config.subtitles.subtitle_edgestyle"),
getConfigMenuItem("config.subtitles.subtitle_edgestyle_level"),
getConfigMenuItem(
"config.subtitles.subtitle_original_position"),
getConfigMenuItem("config.subtitles.subtitle_alignment"),
getConfigMenuItem("config.subtitles.subtitle_position"),
getConfigMenuItem(
"config.subtitles.pango_subtitle_fontswitch"),
getConfigMenuItem("config.subtitles.colourise_dialogs"),
getConfigMenuItem("config.subtitles.subtitle_rewrap"),
getConfigMenuItem("config.subtitles.pango_subtitles_delay"),
getConfigMenuItem("config.subtitles.pango_subtitles_fps"),
]
self["videofps"].setText(
_("Video: %s fps") % (self.getFps().rstrip(".000")))
ConfigListScreen.__init__(self,
menu,
self.session,
on_change=self.changedEntry)
self["actions"] = NumberActionMap(["SetupActions"], {
"cancel": self.cancel,
"ok": self.ok,
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self,
session,
title="",
list=None,
keys=None,
selection=0,
skin_name=None,
text="",
reorderConfig="",
windowTitle=None,
var="",
callbackList=None):
# list is in the format (<display text>, [<parameters to pass to close callback>,])
# callbackList is in the format (<display text>, <callback func>, [<parameters>,])
self.isCallbackList = bool(callbackList)
list = list or callbackList
if not list: list = []
if not skin_name: skin_name = []
Screen.__init__(self, session)
if isinstance(skin_name, str):
skin_name = [skin_name]
self.skinName = skin_name + ["ChoiceBox"]
self.reorderConfig = reorderConfig
self["text"] = Label()
self.var = ""
if reorderConfig:
self["key_menu"] = StaticText(_("MENU"))
self["key_previous"] = StaticText(_("PREVIOUS"))
self["key_next"] = StaticText(_("NEXT"))
if title:
title = _(title)
if len(title) < 55 and title.find('\n') == -1:
self.setTitle(title)
elif title.find('\n') != -1:
temptext = title.split('\n')
if len(temptext[0]) < 55:
self.setTitle(temptext[0])
count = 2
labeltext = ""
while len(temptext) >= count:
if labeltext:
labeltext += '\n'
labeltext = labeltext + temptext[count - 1]
count += 1
self["text"].setText(labeltext)
else:
self["text"].setText(title)
else:
self["text"].setText(title)
elif text:
self["text"].setText(_(text))
self["description"] = Label()
self.list = []
self.summarylist = []
if keys is None:
self.__keys = [
"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red",
"green", "yellow", "blue"
] + (len(list) - 14) * [""]
else:
self.__keys = keys + (len(list) - len(keys)) * [""]
self.keymap = {}
pos = 0
if self.reorderConfig:
self.config_type = getattr(config.misc.pluginlist,
self.reorderConfig)
if self.config_type.value:
prev_list = zip(list, self.__keys)
new_list = []
for x in self.config_type.value.split(","):
for entry in prev_list:
if entry[0][0] == x:
new_list.append(entry)
prev_list.remove(entry)
list = zip(*(new_list + prev_list))
list, self.__keys = list[0], list[1]
number = 1
new_keys = []
for x in self.__keys:
if (not x or x.isdigit()) and number <= 10:
new_keys.append(str(number % 10))
number += 1
else:
new_keys.append(not x.isdigit() and x or "")
self.__keys = new_keys
for x in list:
if x:
strpos = str(self.__keys[pos])
self.list.append(ChoiceEntryComponent(key=strpos, text=x))
if self.__keys[pos] != "":
self.keymap[self.__keys[pos]] = list[pos]
self.summarylist.append((self.__keys[pos], x[0]))
pos += 1
self["list"] = ChoiceList(list=self.list, selection=selection)
self["summary_list"] = StaticText()
self["summary_selection"] = StaticText()
self.updateSummary(selection)
self["actions"] = NumberActionMap(
[
"WizardActions", "InputActions", "ColorActions",
"DirectionActions", "MenuActions"
], {
"ok": self.go,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
"red": self.keyRed,
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"up": self.up,
"down": self.down,
"left": self.left,
"right": self.right,
"shiftUp": self.additionalMoveUp,
"shiftDown": self.additionalMoveDown,
"menu": self.setDefaultChoiceList,
"back": self.cancel
},
prio=-2)
def __init__(self,
session,
title="",
list=None,
keys=None,
selection=0,
skin_name=None,
text=""):
self.setTitle(_("Choice Box"))
if not list: list = []
if not skin_name: skin_name = []
Screen.__init__(self, session)
if isinstance(skin_name, str):
skin_name = [skin_name]
self.skinName = skin_name + ["ChoiceBox"]
self["text"] = Label()
if title:
title = _(title)
if len(title) < 55 and title.find('\n') == -1:
Screen.setTitle(self, title)
elif title.find('\n') != -1:
temptext = title.split('\n')
if len(temptext[0]) < 55:
Screen.setTitle(self, temptext[0])
count = 2
labeltext = ""
while len(temptext) >= count:
if labeltext:
labeltext += '\n'
labeltext = labeltext + temptext[count - 1]
count += 1
print 'count', count
self["text"].setText(labeltext)
else:
self["text"] = Label(title)
else:
self["text"] = Label(title)
elif text:
self["text"] = Label(_(text))
self.list = []
self.summarylist = []
if keys is None:
self.__keys = [
"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "red",
"green", "yellow", "blue"
] + (len(list) - 10) * ["dummy"]
else:
self.__keys = keys + (len(list) - len(keys)) * ["dummy"]
self.keymap = {}
pos = 0
for x in list:
strpos = str(self.__keys[pos])
self.list.append(ChoiceEntryComponent(key=strpos, text=x))
if self.__keys[pos] != "":
self.keymap[self.__keys[pos]] = list[pos]
self.summarylist.append((self.__keys[pos], x[0]))
pos += 1
self["list"] = ChoiceList(list=self.list, selection=selection)
self["summary_list"] = StaticText()
self["summary_selection"] = StaticText()
self.updateSummary(selection)
self["actions"] = NumberActionMap(
["WizardActions", "InputActions", "ColorActions"], {
"ok": self.go,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
"red": self.keyRed,
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"up": self.up,
"down": self.down,
"left": self.left,
"right": self.right
}, -1)
self["cancelaction"] = NumberActionMap(
["WizardActions", "InputActions", "ColorActions"], {
"back": self.cancel,
}, -1)
