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, 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):
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, 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 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)
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, 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, 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, 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, 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=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"
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, *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, 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, 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 __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):
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, 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.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):
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):
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):
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, 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, 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):
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, 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)
# 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):
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)
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, timer):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.timer = timer
self.entryDate = None
self.entryService = None
self["HelpWindow"] = Pixmap()
self["HelpWindow"].hide()
self["VKeyIcon"] = Boolean(False)
self["description"] = Label("")
self["key_red"] = Label(_("Cancel"))
self["key_green"] = Label(_("OK"))
self["key_yellow"] = Label()
self["key_blue"] = Label()
self.createConfig()
self["actions"] = HelpableNumberActionMap(
self, ["SetupActions", "GlobalActions", "PiPSetupActions"], {
"ok": (self.keySelect, _("Save the timer and exit")),
"save": (self.keyGo, "Save the timer and exit"),
"cancel":
(self.keyCancel, "Cancel creation of the timer and exit"),
"volumeUp": (self.incrementStart, _("Increment start time")),
"volumeDown": (self.decrementStart, _("Decrement start time")),
"size+": (self.incrementEnd, _("Increment end time")),
"size-": (self.decrementEnd, _("Decrement end time"))
}, -2)
self.list = []
ConfigListScreen.__init__(self, self.list, session=session)
self.setTitle(_("PowerManager entry"))
self.createSetup("config")
if self.selectionChanged not in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.selectionChanged)
self.selectionChanged()
def __init__(self, session, title, list): #@ReservedAssignment
Screen.__init__(self, session)
ConfigListScreen.__init__(self, [], session)
HelpableScreen.__init__(self)
self.skinName = "SelectSortFunctions"
self.setTitle(title)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Close"))
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"cancel": (self.cancel, _("Cancel")),
})
self["ColorActions"] = HelpableActionMap(self, "ColorActions",
{
"red": (self.cancel, _("Cancel")),
"green": (self.accept, _("Save/Close")),
})
l = []
for x in list:
l.append(getConfigListEntry(x[0], ConfigYesNo(x[1])))
self["config"].setList(l)
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, 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)
Screen.setTitle(self, _('Please select medium'))
#edit lululla
# self['key_red'] = StaticText(_('Cancel'))
# self['key_green'] = StaticText()
# self['message'] = StaticText(message)
self['key_green'] = Label(_(''))
self['key_red'] = Label(_('Cancel'))
self['message'] = Label(_(''))
self['message'].setText(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, 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]
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:
print("[Setup] %s image '%s'." %
("Default" if setupImage is defaultSetupImage else "Setup",
setupImage))
setupImage = resolveFilename(SCOPE_GUISKIN, setupImage)
self.setupImage = LoadPixmap(setupImage)
if self.setupImage:
self["setupimage"] = Pixmap()
else:
print("[Setup] Error: Unable to load image '%s'!" % setupImage)
else:
self.setupImage = None
self["config"].onSelectionChanged.append(self.selectionChanged)
self.onLayoutFinish.append(self.layoutFinished)
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):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["key_red"] = Button(_("Favorites"))
self["key_yellow"] = Button("")
self["key_blue"] = Button(_("Settings"))
self["currentfolder"] = Label("")
self["currentfavname"] = Label("")
self.showiframe = Showiframe()
self.mvion = False
self.curfavfolder = -1
os.system("touch /tmp/bmcmovie")
self["actions"] = HelpableActionMap(self, "MC_VideoPlayerActions",
{
"ok": (self.KeyOk, "Play selected file"),
"cancel": (self.Exit, "Exit Video Player"),
"left": (self.leftUp, "List Top"),
"right": (self.rightDown, "List Bottom"),
"up": (self.up, "List up"),
"down": (self.down, "List down"),
"menu": (self.KeyMenu, "File / Folder Options"),
"info": (self.showFileInfo, "Show File Info"),
"nextBouquet": (self.NextFavFolder, "Next Favorite Folder"),
"prevBouquet": (self.PrevFavFolder, "Previous Favorite Folder"),
# "red": (self.FavoriteFolders, "Favorite Folders"),
"blue": (self.KeySettings, "Settings"),
}, -2)
currDir = config.plugins.mc_vp.lastDir.value
if not pathExists(currDir):
currDir = "/"
self["currentfolder"].setText(str(currDir))
sort = config.plugins.mc_vp_sortmode.enabled.value
self.filelist = []
self["filelist"] = []
inhibitDirs = ["/bin", "/boot", "/dev", "/dev.static", "/etc", "/lib" , "/proc", "/ram", "/root" , "/sbin", "/sys", "/tmp", "/usr", "/var"]
self.filelist = FileList(currDir, useServiceRef = True, showDirectories = True, showFiles = True, matchingPattern = "(?i)^.*\.(ts|vob|mpg|mpeg|avi|mkv|dat|iso|img|mp4|wmv|flv|divx|mov|ogm|m2ts)", additionalExtensions = None, sort = sort)
self["filelist"] = self.filelist
self["filelist"].show()
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, 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, 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, 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):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["key_green"] = Button("Slide Show")
self["key_yellow"] = Button("Thumb View")
self["currentfolder"] = Label("")
self["currentfavname"] = Label("")
self["actions"] = HelpableActionMap(self, "MC_PictureViewerActions",
{
"ok": (self.KeyOk, "Show Picture"),
"cancel": (self.Exit, "Exit Picture Viewer"),
"left": (self.leftUp, "List Top"),
"right": (self.rightDown, "List Bottom"),
"up": (self.up, "List up"),
"down": (self.down, "List down"),
"info": (self.StartExif, "Show File Info"),
"green": (self.startslideshow, "Start Slideshow"),
"yellow": (self.StartThumb, "Thumb View"),
"blue": (self.Settings, "Settings"),
}, -2)
self.aspect = getAspect()
currDir = config.plugins.mc_pp.lastDir.value
if not pathExists(currDir):
currDir = "/"
self["currentfolder"].setText(str(currDir))
self.filelist = []
self["filelist"] = []
inhibitDirs = ["/bin", "/boot", "/dev", "/dev.static", "/etc", "/lib" , "/proc", "/ram", "/root" , "/sbin", "/sys", "/tmp", "/usr", "/var"]
self.filelist = FileList(currDir, showDirectories = True, showFiles = True, showMountpoints = True, isTop = False, matchingPattern = "(?i)^.*\.(jpeg|jpg|jpe|png|bmp)", inhibitDirs = inhibitDirs)
self["filelist"] = self.filelist
self["filelist"].show()
self["thumbnail"] = Pixmap()
self.ThumbTimer = eTimer()
self.ThumbTimer.callback.append(self.showThumb)
self.ThumbTimer.start(500, True)
self.picload = ePicLoad()
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)
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, 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)
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):
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):
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):
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 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):
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 __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,
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, 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, 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 __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, 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)
