def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.edittext = _("Press OK to edit the settings.")
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Select"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["introduction"] = StaticText(self.edittext)
self.devices = [(iInputDevices.getDeviceName(x),x) for x in iInputDevices.getDeviceList()]
print "[InputDeviceSelection] found devices :->", len(self.devices),self.devices
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.close, _("Exit input device selection.")),
"ok": (self.okbuttonClick, _("Select input device.")),
}, -2)
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"red": (self.close, _("Exit input device selection.")),
"green": (self.okbuttonClick, _("Select input device.")),
}, -2)
self.currentIndex = 0
self.list = []
self["list"] = List(self.list)
self.updateList()
self.onLayoutFinish.append(self.layoutFinished)
self.onClose.append(self.cleanup)
def __init__(self, session):
self.liste = []
self.size = config.plugins.piconmanager.size.value
self.creator = config.plugins.piconmanager.creator.value
self.bit = config.plugins.piconmanager.bit.value
self.server = config.plugins.piconmanager.server.value
Screen.__init__(self, session)
HelpableScreen.__init__(self)
ConfigListScreen.__init__(self, self.liste, on_change = self.load_list)
self.setTitle(_("PiconManagerMod - Settings"))
self["key_green"] = Label(_("OK"))
self["key_red"] = Label(_("Cancel"))
self["SetupActions"] = HelpableActionMap(self, "SetupActions",
{
"cancel": (self.cancel,_("Cancel")),
"ok": (self.save,_("OK and exit")),
}, -1)
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"green": (self.save,_("OK and exit")),
"red": (self.cancel,_("Cancel")),
}, -1)
self.onLayoutFinish.append(self.load_list)
def __init__(self, session, favoriteEvents):
self.session = session
self.favoriteEvents = favoriteEvents
if size_width >= 1280 and len(self.favoriteEvents) > 3:
self.skin = skinPTMhdfull
else:
self.skin = skinPTMsd
Screen.__init__(self, session)
self.list = [ ]
self["list"] = ResultList(self.list)
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Accept"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["text_left"] = StaticText(_("Favorite"))
self["text_right"] = StaticText(_("Solution"))
HelpableScreen.__init__(self)
self["SetupActions"] = HelpableActionMap(self, "SetupActions",
{
"cancel": (self.buttonCancel, _("Close")),
"ok": (self.buttonOK, _("Accept the events as shown")),
}, -1)
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"red": (self.buttonCancel, _("Close")),
"green": (self.buttonAccept, _("Accept the events as shown")),
}, -1)
self.visible = True
self.onLayoutFinish.append(self.buildEventList)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.setTitle(_("Configure nameservers"))
self.backupNameserverList = iNetwork.getNameserverList()[:]
print "backup-list:", self.backupNameserverList
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Add"))
self["key_yellow"] = StaticText(_("Delete"))
self["introduction"] = StaticText(_("Press OK to activate the settings."))
self.createConfig()
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.cancel, _("Exit nameserver configuration")),
"ok": (self.ok, _("Activate current configuration")),
})
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"red": (self.cancel, _("Exit nameserver configuration")),
"green": (self.add, _("Add a nameserver entry")),
"yellow": (self.remove, _("Remove a nameserver entry")),
})
self["actions"] = NumberActionMap(["SetupActions"],
{
"ok": self.ok,
}, -2)
self.list = []
ConfigListScreen.__init__(self, self.list)
self.createSetup()
def __init__(self, session, parent):
size_w = getDesktop(0).size().width()
size_h = getDesktop(0).size().height()
self.skin = """<screen position="0,0" size="%i,%i" flags="wfNoBorder" title="LastFMSaveScreen" >
<widget name="cover" position="50,50" size="%i,%i" />
</screen>""" % (size_w, size_h, self.coverartsize[0], self.coverartsize[1])
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.imageconverter = ImageConverter(self.coverartsize[0], self.coverartsize[1], self.setCoverArt)
self.session = session
self.streamplayer = parent.streamplayer
self.parent = parent
self["cover"] = MovingPixmap()
self["actions"] = HelpableActionMap(self, ["WizardActions", "ShortcutActions"], {
"ok": (self.action_exit, _("Exit screensaver")),
"back": (self.action_exit, _("Exit screensaver")),
"red": (self.parent.action_startstop, _("Start/stop streaming")),
"green": (self.parent.skipTrack, _("Skip current track")),
"yellow": (self.parent.love, _("Mark track as loved")),
"blue": (self.parent.banTrack, _("Ban track, never play"))
}, prio=-1, description=config.plugins.LastFM.name.value + " " + _("Screensaver"))
self.onLayoutFinish.append(self.update)
self.updatetimer = eTimer()
self.updatetimer.timeout.get().append(self.update)
self.updatetimer.start(1000)
if config.plugins.LastFM.sreensaver.coverartanimation.value:
self.startmovingtimer = eTimer()
self.startmovingtimer.timeout.get().append(self.movePixmap)
self.startmovingtimer.start(config.plugins.LastFM.sreensaver.coverartinterval.value * 1000)
def __init__(self, session, args = None):
#self.skin = CurlyTx.skin
Screen.__init__(self, session)
HelpableScreen.__init__(self)
#self.skinName = [ "CurlyTx", "Setup" ]
self["text"] = ScrollLabel("foo")
self["key_red"] = StaticText(_("Settings"))
self["key_green"] = StaticText(_("Reload"))
self["key_yellow"] = StaticText(_("Prev"))
self["key_blue"] = StaticText(_("Next"))
self["actions"] = ActionMap(
["WizardActions", "ColorActions", "InputActions", "InfobarEPGActions"], {
"ok": self.close,
"back": self.close,
"up": self.pageUp,
"down": self.pageDown,
"red": self.showSettings,
"green": self.reload,
"yellow": self.prevPage,
"blue": self.nextPage,
"showEventInfo": self.showHeader
}, -1)
self.loadHelp()
self.loadButtons()
self.onLayoutFinish.append(self.afterLayout)
def __init__(self, session, initDir, title, seriesName=''):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.fullpath = ""
self.initDir = initDir
self.title = title
self.seriesNames = seriesName
self.skin = None
self["actions"] = HelpableActionMap(self, "SerienRecorderActions", {
"cancel": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"left": (self.keyLeft, "zur vorherigen Seite blättern"),
"right": (self.keyRight, "zur nächsten Seite blättern"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"ok": (self.keyOk, "ins ausgewählte Verzeichnis wechseln"),
"green": (self.keyGreen, "ausgewähltes Verzeichnis übernehmen"),
"red": (self.keyRed, "ausgewähltes Verzeichnis löschen"),
"yellow": (self.keyYellow, "auf globales Aufnahmeverzeichnis zurücksetzen"),
"blue": (self.keyBlue, "neues Verzeichnis anlegen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["SerienRecorderActions", ], {
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
if config.plugins.serienRec.showAllButtons.value:
setMenuTexts(self)
self.updateFile()
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self, session, args = None):
Screen.__init__(self, session)
InfoBarAudioSelection.__init__(self)
InfoBarAspectSelection.__init__(self)
InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
InfoBarNotifications.__init__(self)
InfoBarBase.__init__(self)
InfoBarScreenSaver.__init__(self)
InfoBarSubtitleSupport.__init__(self)
HelpableScreen.__init__(self)
InfoBarResolutionSelection.__init__(self)
self.summary = None
self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
self.playlistparsers = {}
self.addPlaylistParser(PlaylistIOM3U, "m3u")
self.addPlaylistParser(PlaylistIOPLS, "pls")
self.addPlaylistParser(PlaylistIOInternal, "e2pls")
# 'None' is magic to start at the list of mountpoints
try:
defaultDir = config.mediaplayer.defaultDir.value
except:
Load_defaults()
defaultDir = config.mediaplayer.defaultDir.value
self.filelist = FileList(defaultDir, matchingPattern = "(?i)^.*\.(mp2|mp3|ogg|ts|trp|mts|m2ts|wav|wave|m3u|pls|e2pls|mpg|vob|avi|divx|m4v|mkv|mp4|m4a|dat|flac|flv|mov|dts|3gp|3g2|asf|wmv|wma|webm)", useServiceRef = True, additionalExtensions = "4098:m3u 4098:e2pls 4098:pls")
self["filelist"] = self.filelist
self.playlist = MyPlayList()
self.is_closing = False
self.hiding = False
self.delname = ""
self.playlistname = ""
self["playlist"] = self.playlist
self["PositionGauge"] = ServicePositionGauge(self.session.nav)
self["currenttext"] = Label("")
self["artisttext"] = Label(_("Artist")+':')
self["artist"] = Label("")
self["titletext"] = Label(_("Title")+':')
self["title"] = Label("")
self["albumtext"] = Label(_("Album")+':')
self["album"] = Label("")
self["yeartext"] = Label(_("Year")+':')
self["year"] = Label("")
self["genretext"] = Label(_("Genre")+':')
self["genre"] = Label("")
self["coverArt"] = MediaPixmap()
self["repeat"] = MultiPixmap()
self.seek_target = None
try:
from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
hotplugNotifier.append(self.hotplugCB)
except Exception, ex:
print "[MediaPlayer] No hotplug support", ex
def __init__(self, session, withTVPlanner=False):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.withTVPlanner = withTVPlanner
print "[SerienRecorder] 0__init__ withTVPlanner:", withTVPlanner
self.autoCheckRunning = False
self["actions"] = HelpableActionMap(self, "SerienRecorderActions", {
"red": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"cancel": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"menu": (self.recSetup, "Menü für globale Einstellungen öffnen"),
"3" : (self.showProposalDB, "Liste der Serien/Staffel-Starts anzeigen"),
"6" : (self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7" : (self.showWishlist, "Merkzettel (vorgemerkte Folgen) anzeigen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["SerienRecorderActions" ,], {
"displayHelp" : self.showHelp,
"displayHelp_long" : self.showManual,
}, 0)
self.setupSkin()
self.logliste = []
self.points = ""
self.readLogTimer = eTimer()
self.readLogTimer_conn = None
self.onLayoutFinish.append(self.setSkinProperties)
self.onLayoutFinish.append(self.startCheck)
self.onClose.append(self.__onClose)
def __init__(self, session, args = 0):
self.skin = fstabViewerScreen.skin
self.session = session
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self['entryinfo'] = Label()
self['edit'] = Label(_('Edit'))
self['cancelist'] = Label(_('Cancel'))
self['addentry'] = Label(_('Add entry'))
self['run'] = Label(_('Run mount -a'))
self['restore'] = Label('')
self['menulist'] = fstabMenuList([])
self.fstabEntryList = []
self['ColorActions'] = HelpableActionMap(self, 'ColorActions', {'green': (self.addEntry, _('Add entry')),
'yellow': (self.restoreBackUp, _('Restore backup fstab')),
'blue': (self.mountall, _('Run mount -a')),
'red': (self.close, _('Close plugin'))}, -1)
self['OkCancelActions'] = HelpableActionMap(self, 'OkCancelActions', {'cancel': (self.close, _('Close plugin')),
'ok': (self.openEditScreen, _('Open editor'))}, -1)
self.setTitle(_('fstab-Editor'))
self.builderror = False
if fileExists('/etc/fstab'):
self.buildScreen()
if fileExists('/etc/fstab.backup') or fileExists('/etc/fstab-opkg'):
self['restore'].setText(_('Restore fstab'))
self['menulist'].onSelectionChanged.append(self.selectionChanged)
def __init__(self, *args, **kwargs):
baseMethods.Menu__init__(self, *args, **kwargs) # using the base initializer saves us a few cycles
HelpableScreen.__init__(self)
self.skinName = "SortableMenu"
self.setTitle(_("Main menu"))
# XXX: not nice, but makes our life a little easier
l = [(x[0], x[1], x[2], menuWeights.get(x, supportHiding=False), menuWeights.isHidden(x)) for x in self["menu"].list]
l.sort(key=itemgetter(3))
self["menu"] = SortableMenuList(l)
self["key_blue"] = StaticText(_("hide entry"))
self["DirectionActions"] = ActionMap(["DirectionActions"],
{
"left": boundFunction(self.doMove, self["menu"].pageUp),
"right": boundFunction(self.doMove, self["menu"].pageDown),
"up": boundFunction(self.doMove, self["menu"].up),
"down": boundFunction(self.doMove, self["menu"].down),
}, -1
)
self["MenuSortActions"] = HelpableActionMap(self, "MenuSortActions",
{
"ignore": lambda: None, # we need to overwrite some regular actions :-)
"toggleSelection": (self.toggleSelection, _("toggle selection")),
"selectEntry": (self.okbuttonClick, _("enter menu")),
"hideEntry": (self.hideEntry, _("hide entry")),
}, -1
)
self.selected = -1
def __init__(self, session):
printl("", self, "S")
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.cfglist = []
ConfigListScreen.__init__(self, self.cfglist, session, on_change = self._changed)
self._session = session
self._hasChanged = False
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
self["help"] = StaticText()
self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "DPS_Settings"],
{
"green": self.keySave,
"red": self.keyCancel,
"cancel": self.keyCancel,
"ok": self.ok,
"left": self.keyLeft,
"right": self.keyRight,
"bouquet_up": self.keyBouquetUp,
"bouquet_down": self.keyBouquetDown,
}, -2)
self.createSetup()
self["config"].onSelectionChanged.append(self.updateHelp)
printl("", self, "C")
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):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.skin = JobManagerConfigScreen.skin
self["ButtonGreen"] = Pixmap()
self["TextGreen"] = Label(_("Save"))
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"green": (self.saveConfig, _("Save settings")),
}, -1)
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"ok": (self.openDirSelectScreen, _("Open directory selection screen")),
"cancel": (self.close, _("Close config")),
}, -1)
self.list = []
ConfigListScreen.__init__(self, self.list)
self.list.append(getConfigListEntry(_("Save downloads to: "), config.plugins.JobManager.dlpath))
self["config"].setList(self.list)
def __init__(self, session, plugin_path):
self.skin = xpower.skin
self.session = session
self.ppath = plugin_path
self.setup_title = _("XPower")
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["key_red"] = Button(_("Close"))
self["key_green"] = Button(_("Add/Edit"))
self["key_yellow"] = Button(_("Delete"))
self["key_blue"] = Button(_("Help"))
self.list = []
self["config"] = List(self.list)
self["statusbar"] = Label()
self.text = _("User defined...")
self["XPowerActions"] = HelpableActionMap(self, "XPowerActions",
{
"red": (self.cancel, _("Close plugin")),
"green": (self.keyOK, _("Add/Edit item")),
"yellow": (self.deleteItem, _("Delete selected item")),
"blue": (self.help, _("Help")),
"bouqdn": (self.bouqDown, self.text),
"cancel": (self.cancel, _("Close plugin")),
"ok": (self.keyOK, _("Add/Edit item")),
"menu": (self.showMenu, _("Select power management")),
"shutdown": (self.shutdown, _("Shutdown")),
"wakeup": (self.wakeup, _("WakeUp")),
"abort": (self.abort,_("Abort shutdown / reboot")),
"restart": (self.reboot, _("Reboot")),
"suspend": (self.suspend, _("Suspend")),
"hibernate": (self.hibernate, _("Hibernate")),
}, -1)
self.ipStr = _("IP:")+" "
self.macStr = _("MAC:")+" "
self.menu = []
self.menu.append((_("WakeUp"),"wakeup"))
self.menu.append((_("Suspend"),"suspend"))
self.menu.append((_("Shutdown"),"shutdown"))
self.menu.append((_("Reboot"),"reboot"))
self.menu.append((_("Hibernate"),"hibernate"))
self.menu.append((_("Abort shutdown / reboot"),"abort"))
self.pcinfo = None
self.showPCsList()
self.commandTimer = eTimer()
self.commandTimer.timeout.get().append(self.sendDelayed)
self.onShown.append(self.prepare)
self["config"].onSelectionChanged.append(self.statusbarText)
self.onChangedEntry = []
def __init__(self, session, api=None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
InfoBarNotifications.__init__(self)
if api is None:
if config.plugins.ecasa.last_backend.value == 'picasa':
self.api = PicasaApi(cache=config.plugins.ecasa.cache.value)
else:
self.api = FlickrApi(config.plugins.ecasa.flickr_api_key.value, cache=config.plugins.ecasa.cache.value)
try:
self.api.setCredentials(
config.plugins.ecasa.google_username.value,
config.plugins.ecasa.google_password.value
)
except Exception as e:
AddPopup(
_("Unable to authenticate with Google: %s.") % (e.message),
MessageBox.TYPE_ERROR,
5,
id=AUTHENTICATION_ERROR_ID,
)
else:
self.api = api
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Albums"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Search"))
for i in xrange(self.PICS_PER_PAGE):
self['image%d' % i] = Pixmap()
self['title%d' % i] = StaticText()
self["highlight"] = MovingPixmap()
self["waitingtext"] = Label(_("Please wait... Loading list..."))
self["overviewActions"] = HelpableActionMap(self, "EcasaOverviewActions", {
"up": self.up,
"down": self.down,
"left": self.left,
"right": self.right,
"nextPage": (self.nextPage, _("show next page")),
"prevPage": (self.prevPage, _("show previous page")),
"select": self.select,
"exit":self.close,
"albums":(self.albums, _("show your albums (if logged in)")),
"search":(self.search, _("start a new search")),
"contextMenu":(self.contextMenu, _("open context menu")),
}, -1)
self.offset = 0
self.__highlighted = 0
self.pictures = ()
# thumbnail loader
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.gotPicture)
self.currentphoto = None
self.queue = deque()
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, *args, **kwargs):
baseMethods.Menu__init__(self, *args, **kwargs) # using the base initializer saves us a few cycles
HelpableScreen.__init__(self)
self.skinName = "SortableMenu"
# XXX: not nice, but makes our life a little easier
l = [(x[0], x[1], x[2], menuWeights.get(x)) for x in self["menu"].list]
l.sort(key=lambda x:x[3])
self["menu"] = SortableMenuList(l)
self["WizardActions"] = ActionMap(["WizardActions"],
{
"left": boundFunction(self.doMove, self["menu"].pageUp),
"right": boundFunction(self.doMove, self["menu"].pageDown),
"up": boundFunction(self.doMove, self["menu"].up),
"down": boundFunction(self.doMove, self["menu"].down),
}, -1
)
self["MenuSortActions"] = HelpableActionMap(self, "MenuSortActions",
{
"ignore": lambda: None, # we need to overwrite some regular actions :-)
"toggleSelection": (self.toggleSelection, _("toggle selection")),
"selectEntry": (self.okbuttonClick, _("enter menu")),
}, -1
)
self.selected = -1
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
# Initialize widgets
self["key_green"] = StaticText(_("OK"))
self["key_red"] = StaticText(_("Cancel"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText(_("Run"))
self["plugins"] = StaticText(_("Plugins"))
self["extensions"] = StaticText(_("Extensions"))
self["eventinfo"] = StaticText(_("Eventinfo"))
self["tabbar"] = MultiPixmap()
self["list"] = SelectionList([])
self.selectedList = LIST_PLUGINS
self.updateList()
self["PluginHiderSetupActions"] = HelpableActionMap(self, "PluginHiderSetupActions",
{
"ok": (self["list"].toggleSelection, _("toggle selection")),
"cancel": (self.cancel, _("end editing")),
"green": (self.save, _("save")),
"blue": (self.run, _("run selected plugin")),
"next": (self.next, _("select next tab")),
"previous": (self.previous, _("select previous tab")),
}, -1
)
self.onLayoutFinish.append(self.setCustomTitle)
def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.skin = None
self.conflictsListe = []
self.session = session
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self["actions"] = HelpableActionMap(self, "SerienRecorderActions", {
"cancel": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"left": (self.keyLeft, "zur vorherigen Seite blättern"),
"right": (self.keyRight, "zur nächsten Seite blättern"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"red": (self.keyCancel, "zurück zur vorherigen Ansicht"),
"blue": (self.keyBlue, "alle Einträge aus der Liste endgültig löschen"),
"menu": (self.recSetup, "Menü für globale Einstellungen öffnen"),
"0" : (self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3" : (self.showProposalDB, "Liste der Serien/Staffel-Starts anzeigen"),
"7" : (self.showWishlist, "Merkzettel (vorgemerkte Folgen) anzeigen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["SerienRecorderActions" ,], {
"displayHelp" : self.showHelp,
"displayHelp_long" : self.showManual,
}, 0)
self.setupSkin()
self.onLayoutFinish.append(self.readConflicts)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
ChannelsBase.__init__(self)
self.session = session
self.skinName = [ "SeriesPluginChannelEditor" ]
from plugin import NAME, VERSION
self.setup_title = NAME + " " + _("Channel Editor") + " " + VERSION
# Buttons
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("OK"))
self["key_blue"] = Button(_("Remove"))
self["key_yellow"] = Button(_("Auto match"))
# Define Actions
self["actions_1"] = HelpableActionMap(self, "SetupActions", {
"ok" : (self.keyAdd, _("Show popup to add Stb Channel")),
"cancel" : (self.keyCancel, _("Cancel and close")),
"deleteForward" : (self.keyResetChannelMapping, _("Reset channels")),
}, -1)
self["actions_2"] = HelpableActionMap(self, "DirectionActions", {
"left" : (self.keyLeft, _("Previeous page")),
"right" : (self.keyRight, _("Next page")),
"up" : (self.keyUp, _("One row up")),
"down" : (self.keyDown, _("One row down")),
}, -1)
self["actions_3"] = HelpableActionMap(self, "ColorActions", {
"red" : (self.keyCancel, _("Cancel and close")),
"green" : (self.keySave, _("Save and close")),
"blue" : (self.keyRemove, _("Remove channel")),
"yellow" : (self.tryToMatchChannels, _("Auto match")),
}, -2) # higher priority
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["HelpActions",], {
"displayHelp" : self.showHelp
}, 0)
self.chooseMenuList = MenuList([], enableWrapAround=True, content=eListboxPythonMultiContent)
global TemplatedListFonts
if TemplatedListFonts is not None:
tlf = TemplatedListFonts()
self.chooseMenuList.l.setFont(0, gFont(tlf.face(tlf.MEDIUM), tlf.size(tlf.MEDIUM)))
self.chooseMenuList.l.setItemHeight(30)
else:
self.chooseMenuList.l.setFont(0, gFont('Regular', 20 ))
self.chooseMenuList.l.setItemHeight(25)
self['list'] = self.chooseMenuList
self['list'].show()
self.stbChlist = []
self.webChlist = []
self.stbToWebChlist = []
self.onLayoutFinish.append(self.readChannels)
def __init__(self, session, services):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
# Dict[service] = List of cutlist ids
self.cutlists = dict((k,None) for k in services)
# Dict[id] = Cutfile
self.cutfiles = {}
self.customAT = None
# Buttons
self["key_red"] = StaticText( _("Show") ) #"_("Download") )
self["key_green"] = StaticText( _("Custom") )
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText( _("Remove") )
self["custom_actions"] = HelpableActionMap(self, "CutlistDownloaderActions",
{
"ok": (self.select, _("Show available Cutlists")),
"exit": (self.exit, _("Exit")),
"red": (self.select, _("Show available Cutlists")),
"green": (self.custom, _("Customize search string")),
#"yellow": (self.bestdownload, _("Page up")),
"blue": (self.remove, _("Remove Marker")),
}, -1)
self["list"] = ServiceList( [ (s,'-') for s in self.cutlists.iterkeys()] )
self.onLayoutFinish.append( self.layoutFinished )
def __init__(self, session, api, user="******"):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
InfoBarNotifications.__init__(self)
self.api = api
self.user = user
self["list"] = List()
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText()
self["key_yellow"] = StaticText(_("Change user"))
self["key_blue"] = StaticText(_("User history"))
self["albumviewActions"] = HelpableActionMap(
self,
"EcasaAlbumviewActions",
{
"select": (self.select, _("show album")),
"exit": (self.close, _("Close")),
"users": (self.users, _("Change user")),
"history": (self.history, _("User history")),
},
-1,
)
self.acquireAlbumsForUser(user)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session):
self.skin = CurlyTxSettings.skin
Screen.__init__(self, session)
HelpableScreen.__init__(self)
# self.skinName = [ "CurlyTxSettings", "Setup" ]
self.setup_title = _("Settings")
self["actions"] = ActionMap(
["SetupActions", "ColorActions"],
{
"cancel": self.keyCancel,
"save": self.keySave,
"ok": self.editPage,
"yellow": self.newPage,
"blue": self.deletePage,
},
-2,
)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self["key_yellow"] = StaticText(_("New"))
self["key_blue"] = StaticText(_("Delete"))
ConfigListScreen.__init__(self, self.getConfigList(), session=self.session)
self.loadHelp()
def __init__(self, session, args = 0):
self.skin = fstabViewerScreen.skin
self.session = session
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["entryinfo"] = Label()
self["menulist"] = fstabMenuList([])
self.fstabEntryList = []
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"green": (self.addEntry, _("Add entry")),
"yellow": (self.restoreBackUp, _("Restore back up of fstab")),
"blue": (self.mountall, _("Run mount -a")),
}, -1)
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.close, _("Close plugin")),
"ok": (self.openEditScreen, _("Open editor")),
}, -1)
self.buildScreen()
self["menulist"].onSelectionChanged.append(self.selectionChanged)
def __init__(self, session):
self.session = session
self.session.qPips = None
Screen.__init__(self, session)
FocusShowHide.__init__(self)
HelpableScreen.__init__(self)
self.setTitle(_("Quad PiP Screen"))
self["actions"] = HelpableActionMap(self, "QuadPipSetupActions",
{
"cancel": (self.keyExit, _("Exit quad PiP")),
"ok": (self.keyOk, _("Zap focused channel on full screen")),
"left": (self.keyLeft, _("Select channel audio")),
"right": (self.keyRight, _("Select channel audio")),
"up": (self.keyUp, _("Select channel audio")),
"down": (self.keyDown, _("Select channel audio")),
"channelup" : (self.KeyChannel, _("Show channel selection")),
"channeldown" : (self.KeyChannel, _("Show channel selection")),
"menu" : (self.KeyChannel, _("Show channel selection")),
"channelPrev" : (self.KeyPrev, _("Prev quad PiP channel")),
"channelNext" : (self.KeyNext, _("Next quad PiP channel")),
"red" : (self.KeyRed, _("Show/Hide focus bar")),
}, -1)
self["ch1"] = Label(_(" "))
self["ch2"] = Label(_(" "))
self["ch3"] = Label(_(" "))
self["ch4"] = Label(_(" "))
self["text1"] = Label(_(" Red key : Show/Hide channel name"))
self["text2"] = Label(_(" Menu key : Select quad channel"))
self["focus"] = Slider(-1, -1)
self.currentPosition = 1 # 1~4
self.updatePositionList()
self.skin = QuadPipScreen.skin % (self.session.desktop.size().width(), self.session.desktop.size().height(), \
self.fontSize, self.fontSize, self.fontSize, self.fontSize, \
self.text1Pos[0], self.text1Pos[1], self.text1Pos[2], self.text1Pos[3], self.fontSize, \
self.text2Pos[0], self.text2Pos[1], self.text2Pos[2], self.text2Pos[3], self.fontSize)
self.oldService = None
self.curChannel = None
self.curPlayAudio = -1
global quad_pip_channel_list_instance
self.qpipChannelList = quad_pip_channel_list_instance
self.oldFccEnable = False
self.oldMinitvEanble = False
self.onLayoutFinish.append(self.layoutFinishedCB)
self.notSupportTimer = eTimer()
self.notSupportTimer.callback.append(self.showNotSupport)
self.noChannelTimer = eTimer()
self.noChannelTimer.callback.append(self.noChannelTimerCB)
self.forceToExitTimer = eTimer()
self.forceToExitTimer.callback.append(self.forceToExitTimerCB)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
ChannelsBase.__init__(self)
WebChannels.__init__(self)
self.session = session
self.skinName = [ "SeriesPluginChannelEditor" ]
from plugin import NAME, VERSION
self.setup_title = NAME + " " + _("Channel Editor") + " " + VERSION
# Buttons
self["key_red"] = Button(_("Cancel"))
self["key_green"] = Button(_("OK"))
self["key_blue"] = Button(_("Remove"))
self["key_yellow"] = Button(_("Auto match"))
# Define Actions
self["actions_1"] = HelpableActionMap(self, "SetupActions", {
"ok" : (self.keyAdd, _("Show popup to add Stb Channel")),
"cancel" : (self.keyCancel, _("Cancel and close")),
"deleteForward" : (self.keyResetChannelMapping, _("Reset channels")),
}, -1)
self["actions_2"] = HelpableActionMap(self, "DirectionActions", {
"left" : (self.keyLeft, _("Previeous page")),
"right" : (self.keyRight, _("Next page")),
"up" : (self.keyUp, _("One row up")),
"down" : (self.keyDown, _("One row down")),
}, -1)
self["actions_3"] = HelpableActionMap(self, "ChannelSelectBaseActions", {
"nextBouquet": (self.nextBouquet, _("Next bouquet")),
"prevBouquet": (self.prevBouquet, _("Previous bouquet")),
}, -1)
self["actions_4"] = HelpableActionMap(self, "ColorActions", {
"red" : (self.keyCancel, _("Cancel and close")),
"green" : (self.keySave, _("Save and close")),
"blue" : (self.keyRemove, _("Remove channel")),
"yellow" : (self.tryToMatchChannels, _("Auto match")),
}, -2) # higher priority
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["HelpActions",], {
"displayHelp" : self.showHelp
}, 0)
self['list'] = MatchList()
self['list'].show()
self.stbChlist = []
self.webChlist = []
self.stbToWebChlist = []
self.bouquet = None
self.onLayoutFinish.append(self.readChannels)
self.onShown.append(self.showMessage)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
# Summary
self.setup_title = _("EPGBackup Setup")
self.onChangedEntry = []
self.session = session
self.list = []
ConfigListScreen.__init__(self, self.list, session, on_change = self.changed)
self["config"].onSelectionChanged.append(self._updateHelp)
self._getConfig()
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
self["help"] = StaticText()
# Actions
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"red": (self.keyCancel, _("Close and forget changes")),
"green": (self.keySave, _("Close and save changes")),
}
)
self["MenuActions"] = HelpableActionMap(self, "MenuActions",
{
"menu": (self.menu, _("Open Context Menu"))
}
)
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.keyCancel, _("Close and forget changes")),
}
)
self["ChannelSelectBaseActions"] = HelpableActionMap(self, "ChannelSelectBaseActions",
{
"nextBouquet": (self.pageup, _("Move page up")),
"prevBouquet": (self.pagedown, _("Move page down")),
}
)
self["HelpActions"] = ActionMap(["HelpActions"],
{
"displayHelp": self.showKeyHelp,
}
)
# Trigger change
self.changed()
self.confShowSetupIn = config.plugins.epgbackup.show_setup_in.value
config.plugins.epgbackup.backup_strategy.addNotifier(self.updateVariableHelpText, initial_call = False, immediate_feedback = True)
self.onClose.append(self.removeNotifiers)
self.needsEnigmaRestart = False
self.onLayoutFinish.append(self._layoutFinished)
self["config"].isChanged = self._ConfigisChanged
def __init__(self, session, autotimer):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
# Save autotimer
self.autotimer = autotimer
self.changed = False
# Button Labels
self["key_green"] = StaticText(_("Save"))
self["key_yellow"] = StaticText(_("Delete"))
self["key_blue"] = StaticText(_("Add"))
# Create List of Timers
self["entries"] = AutoTimerList(autotimer.getSortedTupleTimerList())
# Summary
self.onChangedEntry = []
self["entries"].onSelectionChanged.append(self.selectionChanged)
# Define Actions
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"ok": (self.ok, _("Edit selected AutoTimer")),
"cancel": (self.cancel, _("Close and forget changes")),
}
)
self["MenuActions"] = HelpableActionMap(self, "MenuActions",
{
"menu": (self.menu, _("Open Context Menu"))
}
)
self["EPGSelectActions"] = HelpableActionMap(self, "EPGSelectActions",
{
"info": (self.showSearchLog, _("Show last SearchLog")),
}
)
self["InfobarActions"] = HelpableActionMap(self, "InfobarActions",
{
"showTv": (self.showFilterTxt, _("Show AutoTimer FilterTxt")),
}
)
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"red": self.cancel,
"green": (self.save, _("Close and save changes")),
"yellow": (self.remove, _("Remove selected AutoTimer")),
"blue": (self.add, _("Add new AutoTimer")),
}
)
self.onLayoutFinish.append(self.setCustomTitle)
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.cfglist = []
ConfigListScreen.__init__(self, self.cfglist, session, on_change = self._changed)
self._session = session
self._hasChanged = False
self.version = getVersion()
self.controller = None
self.selected = None
self.sampleUse = False
self.aspect = getAspect()
self.old_service = self.session.nav.getCurrentlyPlayingServiceReference()
self["txt_green"] = Label()
self["btn_green"] = Pixmap()
self["statusbar"] = Pixmap()
self["txt_arrows"] = Label()
self["txt_statusbar"] = Label()
self["txt_statusbar_info"] = Label()
self["version"] = StaticText()
self["txt_green"].setText(_("Save"))
self["txt_arrows"].setText(_("Use < > to jump with 10 in slider"))
self["version"].text = self.version
# Disable OSD Transparency
try:
self.can_osd_alpha = open("/proc/stb/video/alpha", "r") and True or False
except:
self.can_osd_alpha = False
if config.plugins.enigmalight.sampleBackground.getValue() == True:
self.showBackground()
self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "EL_Settings"],
{
"green": self.keySave,
"cancel": self.exitTuning,
"ok": self.ok,
"left": self.keyLeft,
"right": self.keyRight,
"bouquet_up": self.keyBouquetUp,
"bouquet_down": self.keyBouquetDown,
"jumpNextMark": self.keyNext,
"jumpPreviousMark": self.keyPrev,
}, -2)
self.createSetup()
log("",self,"Finisch layout..")
#self["config"].onSelectionChanged.append(self.updateHelp)
self.onLayoutFinish.append(self.finishLayout)
def __init__(self, session, title = "", windowTitle = _("Input"), useableChars = None, **kwargs):
Screen.__init__(self, session)
self["text"] = Label(title)
self["input"] = Input(**kwargs)
self["VKeyIcon"] = Pixmap()
self["help_text"] = Label(_("use virtual keyboard for text input"))
self.onShown.append(boundFunction(self.setTitle, windowTitle))
if useableChars is not None:
self["input"].setUseableChars(useableChars)
HelpableScreen.__init__(self)
self["actions"] = NumberActionMap(["InputBoxActions", "InputAsciiActions", "KeyboardInputActions"],
{
"gotAsciiCode": self.gotAsciiCode,
"home": self.keyHome,
"end": self.keyEnd,
"deleteForward": self.keyDelete,
"deleteBackward": self.keyBackspace,
"tab": self.keyTab,
"toggleOverwrite": self.keyInsert,
"showVirtualKeyboard": self.virtualKeyBoard,
"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["WizardActions"] = HelpableActionMap(self, "WizardActions",
{
"ok": (self.go, _("Save")),
"back": (self.cancel,_("Cancel")),
"down": (self.keyTab, _("Tab")),
"left": (self.keyLeft, _("Left")),
"right": (self.keyRight, _("Right")),
}, -1)
self["InfobarSeekActions"] = HelpableActionMap(self, "InfobarSeekActions",
{
"seekBack": (self.keyHome,_("Home")),
"seekFwd": (self.keyEnd,_("End")),
"playpauseService": (self.keyInsert, _("Toggle Insert / Overwrite")),
}, -1)
self["InputBoxActions"] = HelpableActionMap(self, "InputBoxActions",
{
"deleteForward": (self.keyDelete, _("Delete")),
"deleteBackward": (self.keyBackspace, _("Backspace")),
}, -1)
if self["input"].type == Input.TEXT:
self.onExecBegin.append(self.setKeyboardModeAscii)
else:
self.onExecBegin.append(self.setKeyboardModeNone)
def __init__(self, session, fileList, index, path, filename):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["actions"] = HelpableActionMap(self, ["OkCancelActions", "ColorActions", "DirectionActions"], {
"cancel": (self.keyCancel, _("Exit picture viewer")),
"left": (self.keyLeft, _("Show next picture")),
"right": (self.keyRight, _("Show previous picture")),
"blue": (self.keyBlue, _("Start/stop slide show")),
"yellow": (self.keyYellow, _("Show image information")),
}, -1)
self["icon"] = Pixmap()
self["image"] = Pixmap()
self["status"] = Pixmap()
self["message"] = StaticText(_("Please wait, Loading image."))
self.fileList = []
self.currentImage = []
self.lsatIndex = index
self.startIndex = index
self.filename = filename
self.fileListLen = 0
self.currentIndex = 0
self.directoryCount = 0
self.displayNow = True
self.makeFileList(fileList, path)
self.pictureLoad = ePicLoad()
self.pictureLoad.PictureData.get().append(self.finishDecode)
self.slideShowTimer = eTimer()
self.slideShowTimer.callback.append(self.cbSlideShow)
self.onFirstExecBegin.append(self.firstExecBegin)
def __init__(self, session, url):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
Screen.setTitle(self, _("CCcam Share Info"))
self.url = url
self.list = []
self.providers = {}
self.uphop = -1
self.working = True
self["list"] = CCcamShareViewList([])
self["uphops"] = Label()
self["cards"] = Label()
self["providers"] = Label()
self["reshare"] = Label()
self["title"] = Label()
self["actions"] = HelpableNumberActionMap(self, "CCcamInfoActions",
{
"cancel": (self.exit, _("close share view")),
"0": (self.getUphop, _("show cards with uphop 0")),
"1": (self.getUphop, _("show cards with uphop 1")),
"2": (self.getUphop, _("show cards with uphop 2")),
"3": (self.getUphop, _("show cards with uphop 3")),
"4": (self.getUphop, _("show cards with uphop 4")),
"5": (self.getUphop, _("show cards with uphop 5")),
"6": (self.getUphop, _("show cards with uphop 6")),
"7": (self.getUphop, _("show cards with uphop 7")),
"8": (self.getUphop, _("show cards with uphop 8")),
"9": (self.getUphop, _("show cards with uphop 9")),
"green": (self.showAll, _("show all cards")),
"incUphop": (self.incUphop, _("increase uphop by 1")),
"decUphop": (self.decUphop, _("decrease uphop by 1")),
"ok": (self.getServer, _("get the cards' server")),
}, -1)
self.onLayoutFinish.append(self.getProviders)
def __init__(self, session, menu_path="", screenTitle=_("GUI Skin")):
self.hackSkin() # This is a hack to ensure the SkinConverter screen works with the new code.
Screen.__init__(self, session)
HelpableScreen.__init__(self)
if config.usage.show_menupath.value == 'large':
menu_path += screenTitle
title = menu_path
self["menu_path_compressed"] = StaticText("")
elif config.usage.show_menupath.value == 'small':
title = screenTitle
self["menu_path_compressed"] = StaticText(menu_path + " >" if not menu_path.endswith(" / ") else menu_path[:-3] + " >" or "")
else:
title = screenTitle
self["menu_path_compressed"] = StaticText("")
Screen.setTitle(self, title)
self.skinName = ["SkinSelector"]
self.rootDir = resolveFilename(SCOPE_SKIN)
self.config = config.skin.primary_skin
self.xmlList = ["skin.xml"]
self.onChangedEntry = []
self["skins"] = List(enableWrapAround=True)
self["preview"] = Pixmap()
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
self["description"] = StaticText(_("Please wait... Loading list..."))
self["actions"] = HelpableNumberActionMap(self, ["SetupActions", "DirectionActions", "ColorActions"], {
"ok": (self.save, _("Activate the currently selected skin")),
"cancel": (self.cancel, _("Revert to the currently active skin")),
"red": (self.cancel, _("Revert to the currently active skin")),
"green": (self.save, _("Activate the currently selected skin")),
"up": (self.up, _("Move to the previous skin")),
"down": (self.down, _("Move to the next skin")),
"left": (self.left, _("Move to the previous page")),
"right": (self.right, _("Move to the next page"))
}, -1, description=_("Skin Selection Actions"))
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.showPic)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session, saturl):
self.session = session
Screen.__init__(self, session)
self['info'] = Label()
self.saturl = saturl
self['key_red'] = StaticText(_('Exit'))
self['key_yellow'] = StaticText(_('Download'))
self['key_blue'] = StaticText('')
self.satList = []
self['satlist'] = List(self.satList)
HelpableScreen.__init__(self)
self['OkCancelActions'] = HelpableActionMap(
self, 'OkCancelActions', {
'cancel': (self.exit, _('Exit plugin')),
'ok': (self.changeSelection, _('Select/deselect satellite'))
}, -1)
self['ColorActions'] = HelpableActionMap(
self, 'ColorActions', {
'red': (self.exit, _('Exit plugin')),
'yellow': (self.downloadSattelitesFile,
_('Download satellites.xml file')),
'blue':
(self.purgeSattelitesFile, _('Purge satellites.xml file'))
}, -1)
self['ChannelSelectBaseActions'] = HelpableActionMap(
self, 'ChannelSelectBaseActions', {
'nextBouquet': (self.changeSortingUp, _('Sorting up')),
'prevBouquet': (self.changeSortingDown, _('Sorting down'))
}, -1)
self.showAccept = False
self.useTmpFile = False
self.purgePossible = False
self.downloadPossible = True
self.xmlVersion = ''
self.xmlEncoding = ''
self.xmlComment = ''
self['info'].setText('Downloading satellite.xml file..please wait')
self.onShown.append(self.downloadSattelitesFile)
def __init__(self, session, setup, plugin=None, PluginLanguageDomain=None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.setup = setup
self.plugin = plugin
self.pluginLanguageDomain = PluginLanguageDomain
if hasattr(self, "skinName"):
if not isinstance(self.skinName, list):
self.skinName = [self.skinName]
else:
self.skinName = []
if setup:
self.skinName.append("Setup%s" % setup) # DEBUG: Proposed for new setup screens.
self.skinName.append("setup_%s" % setup)
self.skinName.append("Setup")
self.onChangedEntry = []
self.list = []
ConfigListScreen.__init__(self, self.list, session=session, on_change=self.changedEntry, fullUI=True)
self["footnote"] = Label()
self["footnote"].hide()
self["description"] = Label()
self.createSetup()
defaultSetupImage = setups.get("default", "")
setupImage = setups.get(setup, defaultSetupImage)
if setupImage:
print("[Setup] %s image '%s'." % ("Default" if setupImage is defaultSetupImage else "Setup", setupImage))
setupImage = resolveFilename(SCOPE_CURRENT_SKIN, setupImage)
self.setupImage = LoadPixmap(setupImage)
if self.setupImage:
self["setupimage"] = Pixmap()
else:
print("[Setup] Error: Unable to load menu image '%s'!" % setupImage)
else:
self.setupImage = None
if self.layoutFinished not in self.onLayoutFinish:
self.onLayoutFinish.append(self.layoutFinished)
if self.selectionChanged not in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.selectionChanged)
def __init__(self, session):
logger.info("self.return_dir: %s, self.return_path: %s",
self.return_dir, self.return_path)
if self.current_sort_mode is None:
self.current_sort_mode = config.plugins.moviecockpit.list_sort.value
self["list"] = self.movie_list = MovieList(self.current_sort_mode)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
Actions.__init__(self, self)
CutList.__init__(self)
SelfTest.__init__(self)
self.skinName = getSkinName("MovieCockpit")
self["actions"] = self.initActions(
self, self.skinName != getSkinName("NoSupport"))
self["mini_tv"] = Pixmap()
self["pic_loading"] = Pixmap()
self["no_support"] = Label()
self["sort_mode"] = Label()
self.loading = Loading(self["pic_loading"], self.summaries)
self["Service"] = COCServiceEvent(ServiceCenter.getInstance())
self["DiskSpace"] = COCDiskSpace(self)
self["Cover"] = COCCover(self)
self.enable_minit_tv = False
self.last_service = None
self.short_key = True # used for long / short key press detection
self.delay_timer = eTimer()
self.delay_timer_conn = self.delay_timer.timeout.connect(
self.updateInfoDelayed)
self.onShow.append(self.onDialogShow)
self.onHide.append(self.onDialogHide)
self.movie_list.onSelectionChanged.append(self.selectionChanged)
self.updateTitle()
def __init__(self, session, startdir, message="", showDirectories = True, showFiles = True, showMountpoints = True, matchingPattern = "", useServiceRef = False, inhibitDirs = False, inhibitMounts = False, isTop = False, enableWrapAround = False, additionalExtensions = None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText()
self["message"] = StaticText(message)
self.filelist = FileList(startdir, showDirectories = showDirectories, showFiles = showFiles, showMountpoints = showMountpoints, matchingPattern = matchingPattern, useServiceRef = useServiceRef, inhibitDirs = inhibitDirs, inhibitMounts = inhibitMounts, isTop = isTop, enableWrapAround = enableWrapAround, additionalExtensions = additionalExtensions)
self["filelist"] = self.filelist
self["FilelistActions"] = ActionMap(["SetupActions", "ColorActions"],
{
"green": self.use,
"red": self.exit,
"ok": self.ok,
"cancel": self.exit
})
hotplugNotifier.append(self.hotplugCB)
self.onShown.append(self.updateButton)
self.onClose.append(self.removeHotplug)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["key_red"] = StaticText(_("Exit"))
self["key_green"] = StaticText(_("Global"))
self["key_yellow"] = StaticText(_("Mouse"))
self["key_blue"] = StaticText(_("Keyboard"))
self["actions"] = ActionMap(["DirectionActions", "OkCancelActions","ColorActions"], {
"ok" : self.keyRed,
"cancel": self.keyRed,
"red" : self.keyRed,
"green" : self.keyGreen,
"yellow": self.keyYellow,
"blue" : self.keyBlue,
},-2)
self.showHelpTimer = eTimer()
self.showHelpTimer.callback.append(self.cbShowHelpTimerClosed)
self.showHelpTimer.start(500)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session, api, user='******'):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
InfoBarNotifications.__init__(self)
self.api = api
self.user = user
self['list'] = List()
self['key_red'] = StaticText(_("Close"))
self['key_green'] = StaticText()
self['key_yellow'] = StaticText(_("Change user"))
self['key_blue'] = StaticText(_("User history"))
self["albumviewActions"] = HelpableActionMap(
self, "EcasaAlbumviewActions", {
"select": (self.select, _("show album")),
"exit": (self.close, _("Close")),
"users": (self.users, _("Change user")),
"history": (self.history, _("User history")),
}, -1)
self.acquireAlbumsForUser(user)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.setTitle(_("Select Input Device"))
self["deviceActions"] = HelpableActionMap(
self, ["OkCancelActions"], {
"ok": (self.keySelect, _("Select input device")),
"cancel": (self.keyClose, _("Exit input device selection")),
"close": (self.keyCloseRecursive,
_("Exit input device selection and close all menus"))
},
prio=-2,
description=_("Input Device Actions"))
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Select"))
self["introduction"] = StaticText(
_("Press OK to edit the settings of the selected device."))
self["list"] = List()
self.devices = [(inputDevices.getDeviceName(x), x)
for x in inputDevices.getDeviceList()]
# for index, device in enumerate(self.devices):
# print("[InputDeviceSetup] DEBUG: Found device #%d: Event='%s' -> '%s'." % (index, device[1], device[0]))
self.updateList()
def __init__(self, session):
Screen.__init__(self, session)
self.skinName = "wiffi_Setup"
HelpableScreen.__init__(self)
titel1 = "wiffi2e2FS " + _("Settings")
#self.wiffi_ip=str(conf["wiffi_ip"])
self.wiffi_ip = NoSave(
ConfigText(default=str(wiffi_conf["wiffi_ip"]), fixed_size=False))
self.debug = NoSave(ConfigEnableDisable(default=wiffi_conf["debug"]))
self["key_red"] = Label(_("Cancel"))
self["balken"] = Label(
_("Press OK") + ", " + _("Select with left / right") + " " +
_("main") + ", " + _("Infoline") + ", " +
_("Default for full screen and diashow") + ", " + _("Thumbnails"))
self["key_green"] = Label(_("Save"))
self["key_yellow"] = Label("")
self["key_blue"] = Label("")
self["pic_red"] = Pixmap()
self["pic_green"] = Pixmap()
self["pic_yellow"] = Pixmap()
self["pic_blue"] = Pixmap()
self["bgr2"] = Pixmap()
self.onChangedEntry = []
self.session = session
self["pcfsKeyActions"] = HelpableActionMap(
self, "pcfsKeyActions", {
"green": (self.save, _("Save")),
"red": (self.keyCancel, _("Cancel")),
"ok": (self.ok_button, _("edit if possible")),
"cancel": (self.keyCancel, _("Cancel and close")),
}, -2)
self.refresh()
self.setTitle(titel1)
ConfigListScreen.__init__(
self, self.liste,
on_change=self.reloadList) # on_change = self.changedEntry)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.skin = JobManagerFrontEnd.skin
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
"cancel": (self.close, _("Close plugin")),
}, -1)
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.removeJob, _("Delete download")),
"blue": (self.stopSelectedJob, _("Stop download")),
"green": (self.startSelectedJob, _("Start download")),
"yellow": (self.getJobList, _("Refresh GUI")),
}, -1)
self["MovieSelectionActions"] = HelpableActionMap(
self, "MovieSelectionActions", {
"showEventInfo": (self.showErrorLog, _("Show error log")),
"contextMenu": (self.showConfig, _("Show config")),
}, -1)
self.menulist = []
self["ButtonRed"] = Pixmap()
self["ButtonGreen"] = Pixmap()
self["ButtonYellow"] = Pixmap()
self["ButtonBlue"] = Pixmap()
self["TextRed"] = Label(_("Remove download"))
self["TextGreen"] = Label(_("Start download"))
self["TextYellow"] = Label(_("Refresh GUI"))
self["TextBlue"] = Label(_("Stop download"))
self["menulist"] = JobList([])
self.getJobList()
def __init__(self, session):
printl("", self, "S")
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.cfglist = []
ConfigListScreen.__init__(self,
self.cfglist,
session,
on_change=self._changed)
self._hasChanged = False
self["txt_green"] = Label()
self["btn_green"] = Pixmap()
self["help"] = StaticText()
self["setupActions"] = ActionMap(
["SetupActions", "ColorActions", "DPS_Settings"], {
"green": self.keySave,
"red": self.keyCancel,
"cancel": self.keyCancel,
"ok": self.ok,
"left": self.keyLeft,
"right": self.keyRight,
"bouquet_up": self.keyBouquetUp,
"bouquet_down": self.keyBouquetDown,
}, -2)
self.createSetup()
self["config"].onSelectionChanged.append(self.updateHelp)
self.onLayoutFinish.append(self.finishLayout)
printl("", self, "C")
def __init__(self,
session,
event,
serviceRef,
callback=None,
similarEPGCB=None,
parent=None,
windowTitle=None,
skinName=None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
EventViewBase.__init__(self,
event,
serviceRef,
callback=callback,
similarEPGCB=similarEPGCB,
parent=parent,
windowTitle=windowTitle)
self.skinName = ["EventView"]
if skinName:
if isinstance(skinName, str):
self.skinName.insert(0, skinName)
else:
self.skinName = skinName + self.skinname
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.setTitle(_("Select input device"))
self.edittext = _("Press OK to edit the settings.")
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Select"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["introduction"] = StaticText(self.edittext)
self.devices = [(iInputDevices.getDeviceName(x), x)
for x in iInputDevices.getDeviceList()]
print "[InputDeviceSelection] found devices :->", len(
self.devices), self.devices
self["OkCancelActions"] = HelpableActionMap(
self, "OkCancelActions", {
"cancel": (self.close, _("Exit input device selection.")),
"ok": (self.okbuttonClick, _("Select input device.")),
}, -2)
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.close, _("Exit input device selection.")),
"green": (self.okbuttonClick, _("Select input device.")),
}, -2)
self.currentIndex = 0
self.list = []
self["list"] = List(self.list)
self.updateList()
self.onLayoutFinish.append(self.layoutFinished)
self.onClose.append(self.cleanup)
def __init__(self, session, favoriteEvents):
self.session = session
self.skin_path = resolveFilename(SCOPE_PLUGINS,
"Extensions/PrimeTimeManager")
self.favoriteEvents = favoriteEvents
if size_width >= 1280 and len(self.favoriteEvents) > 3:
self.skin = skinPTMhdfull
else:
self.skin = skinPTMsd
Screen.__init__(self, session)
self.list = []
self["list"] = ResultList(self.list)
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Accept"))
self["key_yellow"] = StaticText("")
self["key_blue"] = StaticText("")
self["text_left"] = StaticText(_("Favorite"))
self["text_right"] = StaticText(_("Solution"))
HelpableScreen.__init__(self)
self["SetupActions"] = HelpableActionMap(
self, "SetupActions", {
"cancel": (self.buttonCancel, _("Close")),
"ok": (self.buttonOK, _("Accept the events as shown")),
}, -1)
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.buttonCancel, _("Close")),
"green": (self.buttonAccept, _("Accept the events as shown")),
}, -1)
self.visible = True
self.onLayoutFinish.append(self.buildEventList)
def __init__(self, session, setup, plugin=None, PluginLanguageDomain=None):
Screen.__init__(self, session, mandatoryWidgets=["config", "footnote", "description"])
HelpableScreen.__init__(self)
self.setup = setup
self.plugin = plugin
self.pluginLanguageDomain = PluginLanguageDomain
if not isinstance(self.skinName, list):
self.skinName = [self.skinName]
if setup:
self.skinName.append("setup_%s" % setup)
self.skinName.append("Setup%s" % setup)
self.skinName.append("Setup")
self.list = []
ConfigListScreen.__init__(self, self.list, session=session, on_change=self.changedEntry, fullUI=True)
self["footnote"] = Label()
self["footnote"].hide()
self["description"] = Label()
self.createSetup()
defaultSetupImage = setups.get("default", "")
setupImage = setups.get(setup, defaultSetupImage)
if setupImage:
type = "Default" if setupImage is defaultSetupImage else "Setup"
setupImage = resolveFilename(SCOPE_GUISKIN, setupImage)
print("[Setup] %s image '%s'." % (type, setupImage))
if isfile(setupImage):
self.setupImage = LoadPixmap(setupImage)
if self.setupImage:
self["setupimage"] = Pixmap()
else:
print("[Setup] Error: Unable to load image '%s'!" % setupImage)
else:
print("[Setup] Error: Setup image '%s' is not a file!" % setupImage)
else:
self.setupImage = None
self["config"].onSelectionChanged.append(self.selectionChanged)
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session):
self.skin = CurlyTxSettings.skin
Screen.__init__(self, session)
HelpableScreen.__init__(self)
#self.skinName = [ "CurlyTxSettings", "Setup" ]
self.setup_title = _("Settings")
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"cancel": self.keyCancel,
"save": self.keySave,
"ok": self.editPage,
"yellow": self.newPage,
"blue": self.deletePage
}, -2)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self["key_yellow"] = StaticText(_("New"))
self["key_blue"] = StaticText(_("Delete"))
ConfigListScreen.__init__(self, self.getConfigList(), session=self.session)
self.loadHelp()
def __init__(self, *args, **kwargs):
baseMethods.Menu__init__(
self, *args,
**kwargs) # using the base initializer saves us a few cycles
HelpableScreen.__init__(self)
self.skinName = "SortableMenu"
self.setTitle(_("Main menu"))
# XXX: not nice, but makes our life a little easier
l = [(x[0], x[1], x[2], menuWeights.get(x, supportHiding=False),
menuWeights.isHidden(x)) for x in self["menu"].list]
l.sort(key=itemgetter(3))
self["menu"] = SortableMenuList(l)
self["key_blue"] = StaticText(_("hide entry"))
self["DirectionActions"] = ActionMap(
["DirectionActions"], {
"left": boundFunction(self.doMove, self["menu"].pageUp),
"right": boundFunction(self.doMove, self["menu"].pageDown),
"up": boundFunction(self.doMove, self["menu"].up),
"down": boundFunction(self.doMove, self["menu"].down),
}, -1)
self["MenuSortActions"] = HelpableActionMap(
self,
"MenuSortActions",
{
"ignore":
lambda: None, # we need to overwrite some regular actions :-)
"toggleSelection":
(self.toggleSelection, _("toggle selection")),
"selectEntry": (self.okbuttonClick, _("enter menu")),
"hideEntry": (self.hideEntry, _("hide entry")),
},
-1)
self.selected = -1
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.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, service):
self.skin = CutListEditor.skin
Screen.__init__(self, session)
Screen.setTitle(self, _("Cutlist editor"))
InfoBarSeek.__init__(self, actionmap=["CutlistSeekActions"])
InfoBarCueSheetSupport.__init__(self)
InfoBarBase.__init__(self, steal_current_service=True)
HelpableScreen.__init__(self)
self.old_service = session.nav.getCurrentlyPlayingServiceReference()
self.service = service
session.nav.playService(service)
self.pauseService()
# disable cutlists. we want to freely browse around in the movie
# However, downloading and uploading the cue sheet restores the
# default state, so we need to keep disabling it.
self.cut_state = 2
self.getCuesheet()
# preserve the original cuts to possibly restore them later
self.prev_cuts = self.cut_list[:]
self.last_mark = [
x for x in self.prev_cuts if x[1] == self.CUT_TYPE_LAST
]
self.edited = False
self.MovieSelection = isinstance(
self.session.current_dialog,
MovieSelection) and self.session.current_dialog
self["InLen"] = Label()
self["OutLen"] = Label()
self["Timeline"] = ServicePositionGauge(self.session.nav)
self["cutlist"] = List(self.getCutlist())
self["cutlist"].onSelectionChanged.append(self.selectionChanged)
self["SeekState"] = Label()
self.onPlayStateChanged.append(self.updateStateLabel)
self.updateStateLabel(self.seekstate)
self["key_red"] = Label(_("Start cut"))
self["key_green"] = Label(_("End cut"))
self["key_yellow"] = Label(_("Step back"))
self["key_blue"] = Label(_("Step forward"))
self["SeekActions"].actions.update({"stepFwd": self.stepFwd})
self.helpList.append(
(self["SeekActions"], "CutlistSeekActions", [("stepFwd",
_("Step forward"))]))
desktopSize = getDesktop(0).size()
self["Video"] = VideoWindow(decoder=0,
fb_width=desktopSize.width(),
fb_height=desktopSize.height())
self["actions"] = HelpableActionMap(self, ["CutListEditorActions"], {
"setIn": (self.setIn, _("Make this mark an 'in' point")),
"setOut": (self.setOut, _("Make this mark an 'out' point")),
"setStart":
(self.setStart, _("Make this mark the initial 'in' point")),
"setEnd": (self.setEnd, _("Make this mark the final 'out' point")),
"setMark": (self.setMark, _("Make this mark just a mark")),
"addMark": (self.__addMark, _("Add a mark")),
"removeMark": (self.__removeMark, _("Remove a mark")),
"execute": (self.execute, _("Execute cuts and exit")),
"quickExecute": (self.quickExecute, _("Quick execute...")),
"leave": (self.exit, _("Exit editor")),
"showMenu": (self.showMenu, _("Menu")),
"backMenu": (self.backMenu, _("Restore previous cuts...")),
},
prio=-4)
self.onExecBegin.append(self.showTutorial)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evCuesheetChanged: self.refillList})
# to track new entries we save the last version of the cutlist
self.last_cuts = self.getCutlist()
self.cut_start = None
self.cut_end = None
self.state = CutListContextMenu.SHOW_DELETECUT
self.inhibit_seek = False
self.inhibit_cut = False
self.onClose.append(self.__onClose)
# Use onShown to set the initial list index, since apparently that doesn't
# work from here.
self.onShown.append(self.__onShown)
def __init__(self, session, api=None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
InfoBarNotifications.__init__(self)
if api is None:
if config.plugins.ecasa.last_backend.value == 'picasa':
self.api = PicasaApi(cache=config.plugins.ecasa.cache.value)
else:
self.api = FlickrApi(config.plugins.ecasa.flickr_api_key.value,
cache=config.plugins.ecasa.cache.value)
try:
self.api.setCredentials(
config.plugins.ecasa.google_username.value,
config.plugins.ecasa.google_password.value)
except Exception as e:
AddPopup(
_("Unable to authenticate with Google: %s.") % (e.message),
MessageBox.TYPE_ERROR,
5,
id=AUTHENTICATION_ERROR_ID,
)
else:
self.api = api
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText(_("Albums"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Search"))
for i in range(self.PICS_PER_PAGE):
self['image%d' % i] = Pixmap()
self['title%d' % i] = StaticText()
self["highlight"] = MovingPixmap()
self["waitingtext"] = Label(_("Please wait... Loading list..."))
self["overviewActions"] = HelpableActionMap(
self, "EcasaOverviewActions", {
"up": self.up,
"down": self.down,
"left": self.left,
"right": self.right,
"nextPage": (self.nextPage, _("show next page")),
"prevPage": (self.prevPage, _("show previous page")),
"select": self.select,
"exit": self.close,
"albums": (self.albums, _("show your albums (if logged in)")),
"search": (self.search, _("start a new search")),
"contextMenu": (self.contextMenu, _("open context menu")),
}, -1)
self.offset = 0
self.__highlighted = 0
self.pictures = ()
# thumbnail loader
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.gotPicture)
self.currentphoto = None
self.queue = deque()
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session, args = None):
Screen.__init__(self, session)
InfoBarAudioSelection.__init__(self)
InfoBarAspectSelection.__init__(self)
InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
InfoBarNotifications.__init__(self)
InfoBarBase.__init__(self)
InfoBarScreenSaver.__init__(self)
InfoBarSubtitleSupport.__init__(self)
HelpableScreen.__init__(self)
self.summary = None
self.oldService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.session.nav.stopService()
self.setTitle(_("Media player"))
self.playlistparsers = {}
self.addPlaylistParser(PlaylistIOM3U, "m3u")
self.addPlaylistParser(PlaylistIOPLS, "pls")
self.addPlaylistParser(PlaylistIOInternal, "e2pls")
# 'None' is magic to start at the list of mountpoints
defaultDir = config.mediaplayer.defaultDir.getValue()
self.filelist = FileList(defaultDir, matchingPattern = "(?i)^.*\.(dts|mp3|wav|wave|wv|oga|ogg|flac|m4a|mp2|m2a|wma|ac3|mka|aac|ape|alac|mpg|vob|m4v|mkv|avi|divx|dat|flv|mp4|mov|wmv|asf|3gp|3g2|mpeg|mpe|rm|rmvb|ogm|ogv|m2ts|mts|ts|m3u|e2pls|pls|amr|au|mid|pva|wtv)", useServiceRef = True, additionalExtensions = "4098:m3u 4098:e2pls 4098:pls")
self["filelist"] = self.filelist
self.playlist = MyPlayList()
self.is_closing = False
self.delname = ""
self.playlistname = ""
self["playlist"] = self.playlist
self["PositionGauge"] = ServicePositionGauge(self.session.nav)
self["currenttext"] = Label("")
self["artisttext"] = Label(_("Artist")+':')
self["artist"] = Label("")
self["titletext"] = Label(_("Title")+':')
self["title"] = Label("")
self["albumtext"] = Label(_("Album")+':')
self["album"] = Label("")
self["yeartext"] = Label(_("Year")+':')
self["year"] = Label("")
self["genretext"] = Label(_("Genre")+':')
self["genre"] = Label("")
self["coverArt"] = MediaPixmap()
self["repeat"] = MultiPixmap()
self.seek_target = None
try:
from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
hotplugNotifier.append(self.hotplugCB)
except Exception as ex:
print("[MediaPlayer] No hotplug support", ex)
class MoviePlayerActionMap(NumberActionMap):
def __init__(self, player, contexts = [ ], actions = { }, prio=0):
NumberActionMap.__init__(self, contexts, actions, prio)
self.player = player
def action(self, contexts, action):
self.player.show()
return NumberActionMap.action(self, contexts, action)
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"ok": (self.ok, _("Add file to playlist")),
"cancel": (self.exit, _("Exit mediaplayer")),
}, -2)
self["MediaPlayerActions"] = HelpableActionMap(self, "MediaPlayerActions",
{
"play": (self.xplayEntry, _("Play entry")),
"pause": (self.pauseEntry, _("Pause")),
"stop": (self.stopEntry, _("Stop entry")),
"previous": (self.previousMarkOrEntry, _("Play from previous mark or playlist entry")),
"next": (self.nextMarkOrEntry, _("Play from next mark or playlist entry")),
"menu": (self.showMenu, _("Menu")),
"skipListbegin": (self.skip_listbegin, _("Jump to beginning of list")),
"skipListend": (self.skip_listend, _("Jump to end of list")),
"prevBouquet": (self.prevBouquet, self.prevBouquetHelpText),
"nextBouquet": (self.nextBouquet, self.nextBouquetHelptext),
"delete": (self.deletePlaylistEntry, _("Delete playlist entry")),
"shift_stop": (self.clear_playlist, _("Clear playlist")),
"shift_record": (self.playlist.PlayListShuffle, _("Shuffle playlist")),
"subtitles": (self.subtitleSelection, _("Subtitle selection")),
}, -2)
self["InfobarEPGActions"] = HelpableActionMap(self, "InfobarEPGActions",
{
"showEventInfo": (self.showEventInformation, _("show event details")),
})
self["actions"] = MoviePlayerActionMap(self, ["DirectionActions"],
{
"right": self.rightDown,
"rightRepeated": self.doNothing,
"rightUp": self.rightUp,
"left": self.leftDown,
"leftRepeated": self.doNothing,
"leftUp": self.leftUp,
"up": self.up,
"upRepeated": self.up,
"upUp": self.doNothing,
"down": self.down,
"downRepeated": self.down,
"downUp": self.doNothing,
}, -2)
InfoBarSeek.__init__(self, actionmap = "MediaPlayerSeekActions")
self.mediaPlayerInfoBar = self.session.instantiateDialog(MediaPlayerInfoBar)
self.onClose.append(self.delMPTimer)
self.onClose.append(self.__onClose)
self.onShow.append(self.timerHideMediaPlayerInfoBar)
self.righttimer = False
self.rightKeyTimer = eTimer()
self.rightKeyTimer.callback.append(self.rightTimerFire)
self.lefttimer = False
self.leftKeyTimer = eTimer()
self.leftKeyTimer.callback.append(self.leftTimerFire)
self.hideMediaPlayerInfoBar = eTimer()
self.hideMediaPlayerInfoBar.callback.append(self.timerHideMediaPlayerInfoBar)
self.currList = "filelist"
self.isAudioCD = False
self.ext = None
self.AudioCD_albuminfo = {}
self.cdAudioTrackFiles = []
self.onShown.append(self.applySettings)
self.playlistIOInternal = PlaylistIOInternal()
list = self.playlistIOInternal.open(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
if list:
for x in list:
self.playlist.addFile(x.ref)
self.playlist.updateList()
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
iPlayableService.evUser+13: self["coverArt"].embeddedCoverArt
})
self.servicelist = None
self.pipZapAvailable = False
if InfoBar.instance is not None:
self.servicelist = InfoBar.instance.servicelist
if self.servicelist and hasattr(self.servicelist, 'dopipzap'):
self.pipZapAvailable = SystemInfo.get("NumVideoDecoders", 1) > 1
def __init__(self, session, dvd_device=None, dvd_filelist=[], args=None):
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.dvdScreen = None
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.evEnd: self.__serviceStopped,
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,
}, -2)
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["DVDPlayerColorActions"] = HelpableActionMap(
self, ["ColorActions"], {
"blue": (self.chapterZap, _("jump to chapter by number")),
}, -2)
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
if fileExists("/proc/stb/fb/dst_left"):
self.left = open("/proc/stb/fb/dst_left", "r").read()
self.width = open("/proc/stb/fb/dst_width", "r").read()
self.top = open("/proc/stb/fb/dst_top", "r").read()
self.height = open("/proc/stb/fb/dst_height", "r").read()
if self.left != "00000000" or self.top != "00000000" or self.width != "000002d0" or self.height != "0000000240":
open("/proc/stb/fb/dst_left", "w").write("00000000")
open("/proc/stb/fb/dst_width", "w").write("000002d0")
open("/proc/stb/fb/dst_top", "w").write("00000000")
open("/proc/stb/fb/dst_height", "w").write("0000000240")
self.onClose.append(self.__restoreOSDSize)
def callHelpAction(self, *args): HelpableScreen.callHelpAction(self, *args)
def __init__(self, session, webSender):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.webSender = webSender
from .SerienRecorder import serienRecDataBaseFilePath
from .SerienRecorderDatabase import SRDatabase
self.database = SRDatabase(serienRecDataBaseFilePath)
self["actions"] = HelpableActionMap(self, "SerienRecorderActions", {
"red": (self.cancel, "Änderungen verwerfen und zurück zur Sender-Ansicht"),
"green": (self.save, "Einstellungen speichern und zurück zur Sender-Ansicht"),
"cancel": (self.cancel, "Änderungen verwerfen und zurück zur Sender-Ansicht"),
"ok": (self.ok, "---"),
"up": (self.keyUp, "eine Zeile nach oben"),
"down": (self.keyDown, "eine Zeile nach unten"),
"startTeletext": (self.showAbout, "Über dieses Plugin"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(["SerienRecorderActions", ], {
"ok": self.ok,
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
self.setupSkin()
if config.plugins.serienRec.showAllButtons.value:
setMenuTexts(self)
(Vorlaufzeit, Nachlaufzeit, vps, autoAdjust) = self.database.getChannelsSettings(self.webSender)
if str(Vorlaufzeit).isdigit():
self.margin_before = ConfigInteger(Vorlaufzeit, (0, 99))
self.enable_margin_before = ConfigYesNo(default=True)
else:
self.margin_before = ConfigInteger(config.plugins.serienRec.margin_before.value, (0, 99))
self.enable_margin_before = ConfigYesNo(default=False)
if str(Nachlaufzeit).isdigit():
self.margin_after = ConfigInteger(Nachlaufzeit, (0, 99))
self.enable_margin_after = ConfigYesNo(default=True)
else:
self.margin_after = ConfigInteger(config.plugins.serienRec.margin_after.value, (0, 99))
self.enable_margin_after = ConfigYesNo(default=False)
if str(vps).isdigit():
self.enable_vps = ConfigYesNo(default=bool(vps & 0x1))
self.enable_vps_savemode = ConfigYesNo(default=bool(vps & 0x2))
else:
self.enable_vps = ConfigYesNo(default=False)
self.enable_vps_savemode = ConfigYesNo(default=False)
if str(autoAdjust).isdigit():
self.autoAdjust = ConfigYesNo(default=bool(autoAdjust))
self.enable_autoAdjust = ConfigYesNo(default=True)
else:
self.autoAdjust = ConfigYesNo(default=False)
self.enable_autoAdjust = ConfigYesNo(default=False)
self.changedEntry()
ConfigListScreen.__init__(self, self.list)
self.setInfoText()
self['config_information_text'].setText(self.HilfeTexte[self.enable_margin_before])
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self,
session,
text,
type=TYPE_YESNO,
timeout=0,
close_on_any_key=False,
default=True,
enable_input=True,
msgBoxID=None,
picon=True,
simple=False,
wizard=False,
list=None,
skin_name=None,
timeout_default=None,
title=None):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
if text:
self.text = _(text)
else:
self.text = text
if type in range(self.TYPE_MESSAGE + 1):
self.type = type
else:
self.type = self.TYPE_MESSAGE
self.timeout = int(timeout)
self.close_on_any_key = close_on_any_key
if enable_input:
self["actions"] = HelpableActionMap(
self,
["MsgBoxActions", "DirectionActions"],
{
"cancel": (self.cancel, _("Cancel the selection")),
"ok": (self.ok, _("Accept the current selection")),
"alwaysOK": (self.alwaysOK, _("Always select OK")),
"up": (self.up, _("Move up a line")),
"down": (self.down, _("Move down a line")),
"left": (self.left, _("Move up a page")),
"right": (self.right, _("Move down a page"))
# These actions are *ONLY* defined on OpenPLi!
# I don't believe thay add any functionality even for OpenPLi.
# "upRepeated": (self.up, _("Move up a line repeatedly")),
# "downRepeated": (self.down, _("Move down a line repeatedly")),
# "leftRepeated": (self.left, _("Move up a page repeatedly")),
# "rightRepeated": (self.right, _("Move down a page repeatedly"))
},
prio=-1,
description=_("MessageBox Functions"))
self.msgBoxID = msgBoxID
# These six lines can go with new skins that only use self["icon"]...
self["icon"] = MultiPixmap()
self["icon"].hide()
self.picon = picon
if picon:
# These five lines can go with new skins that only use self["icon"]...
if self.type == self.TYPE_YESNO:
self["icon"].show()
elif self.type == self.TYPE_INFO:
self["icon"].show()
elif self.type == self.TYPE_ERROR:
self["icon"].show()
self.skinName = ["MessageBox"]
if simple:
self.skinName = ["MessageBoxSimple"] + self.skinName
if wizard:
self["rc"] = MultiPixmap()
self["rc"].setPixmapNum(config.misc.rcused.value)
self.skinName = ["MessageBoxWizard"]
if isinstance(skin_name, str):
self.skinName = [skin_name] + self.skinName
if not list:
list = []
if type == self.TYPE_YESNO:
if list:
self.list = list
elif default:
self.list = [(_("Yes"), True), (_("No"), False)]
else:
self.list = [(_("No"), False), (_("Yes"), True)]
else:
self.list = []
self.timeout_default = timeout_default
self.baseTitle = title
self.activeTitle = None
self.timerRunning = False
if timeout > 0:
self.timerRunning = True
self["text"] = Label(self.text)
self["Text"] = StaticText(self.text) # What is self["Text"] for?
self["selectedChoice"] = StaticText()
self["list"] = MenuList(self.list)
if self.list:
self["selectedChoice"].setText(self.list[0][0])
else:
self["list"].hide()
self["key_help"] = StaticText(_("HELP"))
self.timer = eTimer()
self.timer.callback.append(self.processTimer)
if self.layoutFinished not in self.onLayoutFinish:
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self, session, currentValue=""):
self.skin = optionSelector.skin
self.session = session
self.currentOption = ""
self.currentValue = ""
currentValueSplit = currentValue.split("=")
self.currentOption = currentValueSplit[0]
if len(currentValueSplit) > 1:
self.currentValue = currentValueSplit[1]
print currentValueSplit
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["description"] = Label()
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"green": (self.saveOption, _("Return with saving")),
"red": (self.removeOption, _("Remove entry")),
}, -1)
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
"cancel": (self.closeScreen, _("Return without saving")),
}, -1)
# this list contains all options that required a value
self.needsValueList = [
"retrans", "wsize", "rsize", "x-systemd.idle-timeout", "retry",
"timeo", "x-systemd.device-timeout", "mode", "nfsvers", "vers"
]
# this list contains many but not all possible options
choices = [
"defaults", "atime", "noatime", "sync", "async", "user", "nouser",
"users", "auto", "dev", "exec", "suid", "rw", "ro", "relatime",
"nosuid", "nodev", "noexec", "udp", "tcp", "x-systemd.automount",
"retrans", "noauto", "wsize", "rsize", "x-systemd.idle-timeout",
"retry", "lock", "nolock", "timeo", "x-systemd.device-timeout",
"soft", "hard", "nofail", "mode", "nfsvers", "vers"
]
# this dictionary contains descriptions for options
self.descriptionDict = {
"async":
_("All I/O to the filesystem should be done asynchronously."),
"atime":
_("Do not use the noatime feature, so the inode access time is controlled by kernel defaults."
),
"noatime":
_("Do not update inode access times on this filesystem (e.g. for faster access on the news spool to speed up news servers). This works for all inode types (directories too), so it implies nodiratime."
),
"auto":
_("Can be mounted with the -a option."),
"noauto":
_("Can only be mounted explicitly (i.e., the -a option will not cause the filesystem to be mounted)."
),
"defaults":
_("Use the default options: rw, suid, dev, exec, auto, nouser, and async. Note that the real set of all default mount options depends on kernel and filesystem type."
),
"dev":
_("Interpret character or block special devices on the filesystem."
),
"nodev":
_("Do not interpret character or block special devices on the file system."
),
"diratime":
_("Update directory inode access times on this filesystem. This is the default. (This option is ignored when noatime is set.)"
),
"nodiratime":
_("Do not update directory inode access times on this filesystem. (This option is implied when noatime is set.)"
),
"dirsync":
_("All directory updates within the filesystem should be done synchronously. This affects the following system calls: creat, link, unlink, symlink, mkdir, rmdir, mknod and rename."
),
"exec":
_("Permit execution of binaries."),
"noexec":
_("Do not permit direct execution of any binaries on the mounted filesystem."
),
"group":
_("Allow an ordinary user to mount the filesystem if one of that user's groups matches the group of the device. This option implies the options nosuid and nodev (unless overridden by subsequent options, as in the option line group,dev,suid)."
),
"iversion":
_("Every time the inode is modified, the i_version field will be incremented."
),
"noiversion":
_("Do not increment the i_version inode field."),
"mand":
_("Allow mandatory locks on this filesystem."),
"nomand":
_("Do not allow mandatory locks on this filesystem."),
"nofail":
_("Do not report errors for this device if it does not exist."),
"relatime":
_("Update inode access times relative to modify or change time. Access time is only updated if the previous access time was earlier than the current modify or change time. (Similar to noatime, but it doesn't break mutt or other applications that need to know if a file has been read since the last time it was modified.)"
),
"norelatime":
_("Do not use the relatime feature."),
"strictatime":
_("Allows to explicitly request full atime updates. This makes it possible for the kernel to default to relatime or noatime but still allow userspace to override it."
),
"nostrictatime":
_("Use the kernel's default behavior for inode access time updates."
),
"lazytime":
_("Only update times (atime, mtime, ctime) on the in-memory version of the file inode."
),
"nolazytime":
_("Do not use the lazytime feature."),
"suid":
_("Allow set-user-ID or set-group-ID bits to take effect."),
"nosuid":
_("Do not allow set-user-ID or set-group-ID bits to take effect."),
"silent":
_("Turn on the silent flag."),
"loud":
_("Turn off the silent flag."),
"owner":
_("Allow an ordinary user to mount the filesystem if that user is the owner of the device. This option implies the options nosuid and nodev (unless overridden by subsequent options, as in the option line owner,dev,suid)."
),
"ro":
_("Mount the filesystem read-only."),
"rw":
_("Mount the filesystem read-write."),
"sync":
_("All I/O to the filesystem should be done synchronously. In the case of media with a limited number of write cycles (e.g. some flash drives), sync may cause life-cycle shortening."
),
"user":
_("Allow an ordinary user to mount the filesystem. The name of the mounting user is written to the mtab file (or to the private libmount file in /run/mount on systems without a regular mtab) so that this same user can unmount the filesystem again. This option implies the options noexec, nosuid, and nodev (unless overridden by subsequent options, as in the option line user,exec,dev,suid)."
),
"nouser":
_("Forbid an ordinary user to mount the filesystem. This is the default; it does not imply any other options."
),
"users":
_("Allow any user to mount and to unmount the filesystem, even when some other ordinary user mounted it. This option implies the options noexec, nosuid, and nodev (unless overridden by subsequent options, as in the option line users,exec,dev,suid)."
),
"mode":
_("Set the mode of all files to value & 0777 disregarding the original permissions. Add search permission to directories that have read permission. The value is given in octal."
),
"soft":
_("Determines the recovery behavior of the NFS client after an NFS request times out. If neither option is specified (or if the hard option is specified), NFS requests are retried indefinitely. If the soft option is specified, then the NFS client fails an NFS request after retrans retransmissions have been sent, causing the NFS client to return an error to the calling application."
),
"hard":
_("Determines the recovery behavior of the NFS client after an NFS request times out. If neither option is specified (or if the hard option is specified), NFS requests are retried indefinitely. If the soft option is specified, then the NFS client fails an NFS request after retrans retransmissions have been sent, causing the NFS client to return an error to the calling application."
),
"timeo":
_("The time in deciseconds (tenths of a second) the NFS client waits for a response before it retries an NFS request."
),
"retrans":
_("The number of times the NFS client retries a request before it attempts further recovery action. If the retrans option is not specified, the NFS client tries each request three times."
),
"rsize":
_("The maximum number of bytes in each network READ request that the NFS client can receive when reading data from a file on an NFS server. The actual data payload size of each NFS READ request is equal to or smaller than the rsize setting. The largest read payload supported by the Linux NFS client is 1,048,576 bytes (one megabyte)."
),
"wsize":
_("The maximum number of bytes per network WRITE request that the NFS client can send when writing data to a file on an NFS server. The actual data payload size of each NFS WRITE request is equal to or smaller than the wsize setting. The largest write payload supported by the Linux NFS client is 1,048,576 bytes (one megabyte)."
),
"retry":
_("The number of minutes that the mount(8) command retries an NFS mount operation in the foreground or background before giving up. If this option is not specified, the default value for foreground mounts is 2 minutes, and the default value for background mounts is 10000 minutes (80 minutes shy of one week). If a value of zero is specified, the mount(8) command exits immediately after the first failure."
),
"udp":
_("The udp option is an alternative to specifying proto=udp. It is included for compatibility with other operating systems."
),
"tcp":
_("The tcp option is an alternative to specifying proto=tcp. It is included for compatibility with other operating systems."
),
"nfsvers":
_("The NFS protocol version number used to contact the server's NFS service. If the server does not support the requested version, the mount request fails. If this option is not specified, the client negotiates a suitable version with the server, trying version 4 first, version 3 second, and version 2 last."
),
"vers":
_("This option is an alternative to the nfsvers option. It is included for compatibility with other operating systems."
),
"lock":
_("Selects whether to use the NLM sideband protocol to lock files on the server. If neither option is specified (or if lock is specified), NLM locking is used for this mount point. When using the nolock option, applications can lock files, but such locks provide exclusion only against other applications running on the same client. Remote applications are not affected by these locks."
),
"nolock":
_("Selects whether to use the NLM sideband protocol to lock files on the server. If neither option is specified (or if lock is specified), NLM locking is used for this mount point. When using the nolock option, applications can lock files, but such locks provide exclusion only against other applications running on the same client. Remote applications are not affected by these locks."
),
"x-systemd.automount":
_("An automount unit will be created for the file system."),
"x-systemd.idle-timeout":
_("Configures the idle timeout of the automount unit."),
"x-systemd.device-timeout":
_("Configure how long systemd should wait for a device to show up before giving up on an entry from /etc/fstab. Specify a time in seconds."
),
}
self.list = []
if self.currentOption != "":
self.options = NoSave(
ConfigSelection(choices, default=self.currentOption))
else:
self.options = NoSave(ConfigSelection(choices))
self.list.append(getConfigListEntry(_("option: "), self.options))
if self.currentValue != "":
self.optionValue = NoSave(ConfigText(default=self.currentValue))
self.list.append(getConfigListEntry(_("value: "),
self.optionValue))
ConfigListScreen.__init__(self, self.list)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.list = []
# Summary
self.setup_title = _("EPGRefresh Configuration")
self.onChangedEntry = []
self.session = session
# Although EPGRefresh keeps services in a Set we prefer a list
self.services = ([x for x in epgrefresh.services[0]],
[x for x in epgrefresh.services[1]])
ConfigListScreen.__init__(self,
self.list,
session=session,
on_change=self.changed)
self._getConfig()
self["config"].onSelectionChanged.append(self.updateHelp)
# Initialize Buttons
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
self["key_yellow"] = StaticText(_("Functions"))
self["key_blue"] = StaticText(_("Edit Services"))
self["help"] = StaticText()
# Define Actions
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"yellow": (self.showFunctionMenu, _("Show more Functions")),
"blue": (self.editServices, _("Edit Services")),
})
self["actions"] = HelpableActionMap(self, "ChannelSelectEPGActions", {
"showEPGList": (self.keyInfo, _("Show last EPGRefresh - Time")),
})
self["ChannelSelectBaseActions"] = HelpableActionMap(
self, "ChannelSelectBaseActions", {
"nextBouquet": (self.pageup, _("Move page up")),
"prevBouquet": (self.pagedown, _("Move page down")),
})
self["actionstmp"] = ActionMap(["HelpActions"], {
"displayHelp": self.showHelp,
})
self["SetupActions"] = HelpableActionMap(
self, "SetupActions", {
"cancel": (self.keyCancel, _("Close and forget changes")),
"save": (self.keySave, _("Close and save changes")),
})
# Trigger change
self.changed()
self.needsEnigmaRestart = False
self.ServicesChanged = False
self.onLayoutFinish.append(self.setCustomTitle)
self.onFirstExecBegin.append(self.firstExec)
self["config"].isChanged = self._ConfigisChanged
