def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.picload = ePicLoad()
self.picloader = None
self.ErrorMsg = "unbekannt"
self.skin = None
self.chooseMenuList = None
self.chooseMenuList_popup = None
self.popup_list = []
self.piconLoader = PiconLoader()
self.database = None
self.singleTimer_conn = None
self.displayTimer_conn = None
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"ok":
(self.keyOK, "Marker für die ausgewählte Serie hinzufügen"),
"cancel": (self.keyCancel, "SerienRecorder beenden"),
"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.keyRed, "Anzeige-Modus auswählen"),
"green": (self.keyGreen, "Ansicht Sender-Zuordnung öffnen"),
"yellow": (self.keyYellow, "Ansicht Serien-Marker öffnen"),
"blue": (self.keyBlue, "Ansicht Timer-Liste öffnen"),
"info": (self.keyCheck, "Suchlauf für Timer starten"),
"menu":
(self.recSetup, "Menü für globale Einstellungen öffnen"),
"nextBouquet":
(self.nextPage, "Serienplaner des nächsten Tages laden"),
"prevBouquet":
(self.backPage, "Serienplaner des vorherigen Tages laden"),
"startTeletext":
(self.wunschliste,
"Informationen zur ausgewählten Serie auf Wunschliste anzeigen"
),
"0":
(self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"1": (self.searchSeries, "Serie manuell suchen"),
"2": (self.changeTVDBID, "TVDB-ID ändern"),
"3": (self.showProposalDB,
"Liste der Serien/Staffel-Starts anzeigen"),
"4": (self.serieInfo,
"Informationen zur ausgewählten Serie anzeigen"),
"5": (self.imapTest, "IMAP Test"),
"6":
(self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7": (self.showWishlist,
"Merkzettel (vorgemerkte Folgen) anzeigen"),
"8": (self.reloadSerienplaner, "Serienplaner neu laden"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap([
"SerienRecorderActions",
], {
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
}, 0)
SerienRecorder.ReadConfigFile()
if not os.path.exists(config.plugins.serienRec.piconPath.value):
config.plugins.serienRec.showPicons.value = False
self.setupSkin()
if config.plugins.serienRec.updateInterval.value == 24:
config.plugins.serienRec.timeUpdate.value = True
elif config.plugins.serienRec.updateInterval.value == 0:
config.plugins.serienRec.timeUpdate.value = False
else:
config.plugins.serienRec.timeUpdate.value = False
global showMainScreen
if config.plugins.serienRec.firstscreen.value == "0":
showMainScreen = True
else:
showMainScreen = False
self.pRegional = 0
self.pPaytv = 1
self.pPrime = 1
self.page = 0
self.modus = "list"
self.loading = True
self.daylist = [[]]
self.displayTimer = None
self.displayMode = 1
self.serviceRefs = None
self.onLayoutFinish.append(self.setSkinProperties)
self.onClose.append(self.__onClose)
self.onFirstExecBegin.append(self.showSplashScreen)
self.onFirstExecBegin.append(self.checkForUpdate)
if config.plugins.serienRec.showStartupInfoText.value:
if fileExists("%sStartupInfoText" %
SerienRecorder.serienRecMainPath):
self.onFirstExecBegin.append(self.showInfoText)
else:
self.onFirstExecBegin.append(self.startScreen)
else:
self.onFirstExecBegin.append(self.startScreen)
def __init__(self,
session,
service,
slist=None,
lastservice=None,
infobar=None):
Screen.__init__(self, session)
self.pts_pvrStateDialog = ""
self["key_yellow"] = Label()
self["key_blue"] = Label()
self["key_green"] = Label()
self["eventname"] = Label()
self["state"] = Label()
self["speed"] = Label()
self["statusicon"] = MultiPixmap()
self["actions"] = HelpableActionMap(
self, "MoviePlayerActions", {
"InfoButtonPressed": (self.openEventView, _("open Info...")),
"EPGButtonPressed": (self.showDefaultEPG, _("open EPG...")),
"leavePlayer": (self.leavePlayer, _("leave movie player...")),
"leavePlayerOnExit":
(self.leavePlayerOnExit, _("leave movie player...")),
"channelUp":
(self.channelUp, _("when PiPzap enabled zap channel up...")),
"channelDown": (self.channelDown,
_("when PiPzap enabled zap channel down...")),
})
self["DirectionActions"] = HelpableActionMap(self,
"DirectionActions", {
"left": self.left,
"right": self.right
},
prio=-2)
self.allowPiP = True
for x in InfoBarAspectSelection, HelpableScreen, InfoBarShowHide, InfoBarLongKeyDetection, InfoBarMenu, InfoBarEPG, \
InfoBarBase, InfoBarSeek, InfoBarShowMovies, InfoBarInstantRecord, \
InfoBarAudioSelection, InfoBarResolutionSelection, InfoBarNotifications, InfoBarSimpleEventView, \
InfoBarServiceNotifications, InfoBarPVRState, InfoBarCueSheetSupport, \
InfoBarMoviePlayerSummarySupport, InfoBarSubtitleSupport, \
InfoBarTeletextPlugin, InfoBarServiceErrorPopupSupport, InfoBarExtensions, \
InfoBarPlugins, InfoBarPiP, InfoBarZoom, InfoBarButtonSetup:
x.__init__(self)
self.onChangedEntry = []
self.servicelist = slist
self.infobar = infobar
self.lastservice = lastservice or session.nav.getCurrentlyPlayingServiceOrGroup(
)
session.nav.playService(service)
self.cur_service = service
self.returning = False
self.onClose.append(self.__onClose)
self.onShow.append(self.doButtonsCheck)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={enigma.iPlayableService.evStart: self.__evStart})
assert MoviePlayer.instance is None, "class InfoBar is a singleton class and just one instance of this class is allowed!"
MoviePlayer.instance = self
# is needed for every first call of MoviePlayer
self.__evStart()
def __init__(self, session):
Screen.__init__(self, session)
SelectionEventInfo.__init__(self)
CoolWide = getDesktop(0).size().width()
skinpath = str(resolveFilename)
self.skinName = "MovieSelectionSP"
if CoolWide == 720:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/Suomipoeka/CoolSkin/MovieSelectionSP_720.xml"
elif CoolWide == 1024:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/Suomipoeka/CoolSkin/MovieSelectionSP_1024.xml"
else:
skin = "/usr/lib/enigma2/python/Plugins/Extensions/Suomipoeka/CoolSkin/MovieSelectionSP_1280.xml"
Cool = open(skin)
self.skin = Cool.read()
Cool.close()
self.wasClosed = True
self.playerInstance = None
self.selectIdx = -1
self.cursorDir = 0
self.currentGrnText = _("Alpha sort")
self["wait"] = Label(_("Reading directory..."))
self["list"] = MovieList()
self["key_red"] = Button()
self["key_green"] = Button()
self["key_yellow"] = Button()
self["key_blue"] = Button()
global gMS
gMS = self
self["actions"] = HelpableActionMap(
self, "PluginMovieSelectionActions", {
"bOK": (self.movieSelected, _("Play selected movie(s)")),
"bOKL": (self.unUsed, "-"),
"bEXIT": (self.abort, _("Close movie list")),
"bMENU": (self.openMenu, _("Open menu")),
"bINFO": (self.showEventInformation, _("Show event info")),
"bINFOL": (self.unUsed, "-"),
"bRed": (self.deleteFile, _("Delete file or empty dir")),
"bGreen": (self.toggleSort, _("Toggle sort mode")),
"bYellow": (self.moveMovie, _("Move selected movie(s)")),
"bBlue":
(self.blueFunc, _("Movie home / Play last (configurable)")),
"bRedL": (self.unUsed, "-"),
"bGreenL": (self.unUsed, "-"),
"bYellowL": (self.openScriptMenu, _("Open shell script menu")),
"bBlueL": (self.openBookmarks, _("Open bookmarks")),
"bLeftUp": (self.keyPress, _("Move cursor page up")),
"bRightUp": (self.keyPress, _("Move cursor page down")),
"bUpUp": (self.keyPressU, _("Move cursor up")),
"bDownUp": (self.keyPressD, _("Move cursor down")),
"bBqtPlus": (self.bouquetPlus, _("Move cursor 1/2 page up")),
"bBqtMnus":
(self.bouquetMinus, _("Move cursor 1/2 page down")),
"bArrowR": (self.unUsed, "-"),
"bArrowRL": (self.unUsed, "-"),
"bArrowL": (self.unUsed, "-"),
"bArrowLL": (self.unUsed, "-"),
"bVIDEO":
(self.selectionToggle, _("Toggle service selection")),
"bAUDIO": (self.openMenuPlugins, _("Available plugins menu")),
"bAUDIOL": (self.unUsed, "-"),
"bMENUL": (self.openMenuPlugins, _("Available plugins menu")),
"bTV": (self.reloadList, _("Reload movie file list")),
"bTVL": (self.unUsed, "-"),
"bRADIO": (self.viewedToggle, _("Toggle viewed / not viewed")),
"bRADIOL": (self.unUsed, "-"),
"bTEXT": (self.multiSelect, _("Start / end multiselection")),
"bTEXTL": (self.unUsed, "-")
})
self["actions"].csel = self
HelpableScreen.__init__(self)
self.currentPathSel = config.suomipoeka.movie_homepath.value
self.parentStack = []
self.onExecBegin.append(self.onDialogShow)
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.skinName = ["ConfigScreen", "ConfigListScreen"]
from plugin import NAME, VERSION, gPushService
self.setup_title = NAME + " " + _("Configuration") + " " + VERSION
PushServiceBase.__init__(self)
if gPushService:
gPushService.stop()
# Load local moduls to work on
self.load()
# Buttons
self["key_red"] = StaticText("")
self["key_green"] = StaticText("")
self["key_blue"] = StaticText("")
self["key_yellow"] = StaticText("")
self.help_window = None
# Define Actions
#E2 Bug self["custom_actions"] = HelpableActionMap(self, ["SetupActions", "ColorActions", "PushServiceConfigActions"],
self["custom_actions"] = HelpableActionMap(
self, "PushServiceConfigActions", {
"pageUp": (self.pageUp, _("Page up")),
"pageDown": (self.pageDown, _("Page down")),
}, -2) # higher priority
self["main_actions"] = HelpableActionMap(
self, "PushServiceConfigActions", {
"red": (self.keyCancel, _("Exit without saving")),
"green": (self.keySave, _("Save and exit")),
}, -2) # higher priority
self["main_actions"].setEnabled(False)
self["main_actions_enabled"] = HelpableActionMap(
self, "PushServiceConfigActions", {
"yellow": (self.showServices, _("Show Services")),
"blue": (self.showControllers, _("Show Controllers")),
}, -2) # higher priority
self["main_actions_enabled"].setEnabled(False)
self["service_actions"] = HelpableActionMap(
self, "PushServiceConfigActions", {
"red": (self.showMain, _("Back to main screen")),
"green": (self.testService, _("Test selected Service")),
"yellow": (self.addServices, _("Add Service")),
"blue": (self.removeServices, _("Remove Service")),
}, -2) # higher priority
self["service_actions"].setEnabled(False)
self["controller_actions"] = HelpableActionMap(
self, "PushServiceConfigActions", {
"red": (self.showMain, _("Back to main screen")),
"green": (self.testController, _("Test selected Controller")),
"yellow": (self.addControllers, _("Add Controller")),
"blue": (self.removeControllers, _("Remove Controller")),
}, -2) # higher priority
self["controller_actions"].setEnabled(False)
# Initialize Configuration part
self.list = []
self.state = MAIN
self.build()
ConfigListScreen.__init__(self,
self.list,
session=session,
on_change=self.change)
# Override selectionChanged because our config tuples are bigger
self.onChangedEntry = []
def selectionChanged():
current = self["config"].getCurrent()
if self["config"].current != current:
if self["config"].current:
self["config"].current[1].onDeselect(self.session)
if current:
current[1].onSelect(self.session)
self["config"].current = current
for x in self["config"].onSelectionChanged:
x()
self["config"].selectionChanged = selectionChanged
self.setTitle(self.setup_title)
def __init__(self, session, skip=True):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.session = session
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self.chooseMenuList_popup = MenuList(
[], enableWrapAround=True, content=eListboxPythonMultiContent)
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"ok": (self.keyOK,
"für die ausgewählte Serien neue Einträge hinzufügen"),
"cancel":
(self.keyCancel,
"alle Änderungen verwerfen und 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.keyRed, "ausgewählten Eintrag löschen"),
"green":
(self.keyGreen,
"alle Änderungen speichern und zurück zur vorherigen Ansicht"
),
"yellow": (self.keyYellow, "umschalten Sortierung ein/aus"),
"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"),
"4": (self.serieInfo,
"Informationen zur ausgewählten Serie 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.delAdded = False
self.addedlist = []
self.addedlist_tmp = []
self.dbData = []
self.modus = "menu_list"
self.aSerie = ""
self.aStaffel = "0"
self.aFromEpisode = 0
self.aToEpisode = 0
self.onLayoutFinish.append(self.readAdded)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self, session, entry=None):
self.session = session
Screen.__init__(self, session)
if entry == None:
self.setTitle(_("Add birthday"))
config.plugins.birthdayreminder.name = NoSave(
ConfigText(default="", fixed_size=False, visible_width=40))
config.plugins.birthdayreminder.day = NoSave(
ConfigInteger(default=1, limits=(1, 31)))
config.plugins.birthdayreminder.month = NoSave(
ConfigInteger(default=1, limits=(1, 12)))
config.plugins.birthdayreminder.year = NoSave(
ConfigInteger(default=1900, limits=(1900, 2050)))
else:
self.setTitle(_("Edit birthday"))
(name, birthday) = entry
config.plugins.birthdayreminder.name = NoSave(
ConfigText(default=name, fixed_size=False, visible_width=40))
config.plugins.birthdayreminder.day = NoSave(
ConfigInteger(default=birthday.day, limits=(1, 31)))
config.plugins.birthdayreminder.month = NoSave(
ConfigInteger(default=birthday.month, limits=(1, 12)))
config.plugins.birthdayreminder.year = NoSave(
ConfigInteger(default=birthday.year, limits=(1900, 2050)))
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
self["error"] = Label(_("Invalid date!"))
self["error"].hide()
list = []
list.append(
getConfigListEntry(_("Name:"),
config.plugins.birthdayreminder.name))
if config.plugins.birthdayreminder.dateFormat.value == "mmddyyyy":
list.append(
getConfigListEntry(_("Month:"),
config.plugins.birthdayreminder.month))
list.append(
getConfigListEntry(_("Day:"),
config.plugins.birthdayreminder.day))
else:
list.append(
getConfigListEntry(_("Day:"),
config.plugins.birthdayreminder.day))
list.append(
getConfigListEntry(_("Month:"),
config.plugins.birthdayreminder.month))
list.append(
getConfigListEntry(_("Year:"),
config.plugins.birthdayreminder.year))
ConfigListScreen.__init__(self, list)
HelpableScreen.__init__(self)
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions", {
"cancel": (self.cancel, _("Cancel")),
}, -1)
self["ColorActions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.cancel, _("Cancel")),
"green": (self.accept, _("Accept changes")),
}, -1)
def __init__(self, session):
Screen.__init__(self, session)
self["actions"] = HelpableActionMap(
self,
"InfobarActions", {
"showMovies": (self.showMovies, _("Play recorded movies...")),
"showRadio": (self.showRadio, _("Show the radio player...")),
"showTv": (self.TvRadioToggle, _("Show the tv player...")),
"showMediaPlayer":
(self.showMediaPlayer, _("Show the media player...")),
"openBouquetList":
(self.openBouquetList, _("open bouquetlist")),
"openSleepTimer":
(self.openPowerTimerList, _("Show the Sleep Timer...")),
"showEMC": (self.showEMC, _("Show the media center...")),
"showETPORTAL": (self.showETPORTAL, _("Open EtPortal...")),
"showMEDIAPORTAL":
(self.showMEDIAPORTAL, _("Open MediaPortal...")),
"showWWW": (self.showWWW, _("Open WWW Plugin...")),
"showPluginBrowser":
(self.showPluginBrowser, _("Show the plugins...")),
"showBoxPortal": (self.showBoxPortal, _("Show Box Portal...")),
},
prio=2)
self["key_red"] = Label()
self["key_yellow"] = Label()
self["key_blue"] = Label()
self["key_green"] = Label()
self.allowPiP = True
self.radioTV = 0
for x in HelpableScreen, \
InfoBarBase, InfoBarShowHide, \
InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, \
InfoBarInstantRecord, InfoBarAudioSelection, InfoBarRedButton, InfoBarTimerButton, InfoBarUnhandledKey, InfoBarLongKeyDetection, InfoBarResolutionSelection, InfoBarVmodeButton, \
InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, InfoBarAspectSelection, InfoBarBuffer, \
InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, InfoBarSleepTimer, \
InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, InfoBarQuickMenu, InfoBarZoom, InfoBarHdmi, \
InfoBarPlugins, InfoBarServiceErrorPopupSupport, InfoBarHotkey:
x.__init__(self)
self.helpList.append(
(self["actions"], "InfobarActions", [("showMovies",
_("Watch recordings..."))]))
self.helpList.append((self["actions"], "InfobarActions",
[("showRadio", _("Listen to the radio..."))]))
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
enigma.iPlayableService.evUpdatedEventInfo:
self.__eventInfoChanged
})
self.current_begin_time = 0
assert InfoBar.instance is None, "class InfoBar is a singleton class and just one instance of this class is allowed!"
InfoBar.instance = self
self.zoomrate = 0
self.zoomin = 1
if config.misc.initialchannelselection.value:
self.onShown.append(self.showMenu)
self.onShow.append(self.doButtonsCheck)
def __init__(self, session, moviename, spath=None):
Screen.__init__(self, session)
#self.session = session
self.moviename = getMovieNameWithoutExt(moviename)
moviename = getMovieNameWithoutPhrases(self.moviename)
self.movielist = None
self.spath = spath
self["previewcover"] = Pixmap()
self.picload = ePicLoad()
try:
self.picload_conn = self.picload.PictureData.connect(self.showPreviewCoverCB)
except:
self.picload.PictureData.get().append(self.showPreviewCoverCB)
self.previewTimer = eTimer()
try:
self.previewTimer_conn = self.previewTimer.timeout.connect(self.showPreviewCover)
except:
self.previewTimer.callback.append(self.showPreviewCover)
self.selectionTimer = eTimer()
try:
self.selectionTimer_conn = self.selectionTimer.timeout.connect(self.updateSelection)
except:
self.selectionTimer.callback.append(self.updateSelection)
self["previewlist"] = MenuList([])
self.page = 0
self.id = None
self.cat = None
self["contenttxt"] = ScrollLabel()
self["runtime"] = Label("")
self["runtimetxt"] = Label("")
self["genre"] = Label("")
self["genretxt"] = Label("")
self["country"] = Label("")
self["countrytxt"] = Label("")
self["release"] = Label("")
self["releasetxt"] = Label("")
self["rating"] = Label("")
self["ratingtxt"] = Label("")
self["stars"] = ProgressBar()
self["starsbg"] = Pixmap()
self["stars"].hide()
self["starsbg"].hide()
self["setup"] = Label(_("Setup"))
self["key_menu"] = Pixmap()
self["save"] = Label(_("Save"))
self["key_green"] = Pixmap()
self.ratingstars = -1
self.movielist = getMovieList(moviename)
if self.movielist is not None:
self["previewlist"] = MenuList(self.movielist[0])
if self.movielist[1] > 1:
self.page = 1
self["movie_name"] = Label(_("Search results for:") + " " + moviename)
else:
self.page = 0
sel = self["previewlist"].l.getCurrentSelection()
if sel is not None:
preview = getMovieInfo(sel[1], sel[2])
if preview is not None:
self.id = sel[1]
self.cat = sel[2]
self["previewlist"].hide()
self["movie_name"] = Label(_("Movie Information Preview for:") + " " + moviename)
else:
self["movie_name"] = Label(_("Search results for:") + " " + moviename)
self["contenttxt"].setText(_("Nothing was found !"))
self.file_format = "(\.ts|\.avi|\.mkv|\.divx|\.f4v|\.flv|\.img|\.iso|\.m2ts|\.m4v|\.mov|\.mp4|\.mpeg|\.mpg|\.mts|\.vob|\.asf|\.wmv|.\stream|.\webm)"
# for file-operations
self.txtsaved = False
self.jpgsaved = False
self.mpath = None
self.onLayoutFinish.append(self.layoutFinished)
self["actions"] = HelpableActionMap(self, "EMCMovieInfo",
{
"EMCEXIT": self.exit,
"EMCUp": self.pageUp,
"EMCDown": self.pageDown,
"EMCOK": self.ok,
"EMCGreen": self.save,
"EMCMenu": self.setup,
#"EMCINFO": self.info,
#"EMCRed": self.red,
}, -1)
self["previewlist"].onSelectionChanged.append(self.selectionChanged)
def __init__(self, list, session=None, on_change=None, fullUI=False):
self.entryChanged = on_change if on_change is not None else lambda: None
if fullUI:
if "key_red" not in self:
self["key_red"] = StaticText(_("Cancel"))
if "key_green" not in self:
self["key_green"] = StaticText(_("Save"))
self["fullUIActions"] = HelpableActionMap(
self, ["ConfigListActions"], {
"cancel": (self.keyCancel,
_("Cancel any changed settings and exit")),
"close":
(self.closeRecursive,
_("Cancel any changed settings and exit all menus")),
"save":
(self.keySave, _("Save all changed settings and exit"))
},
prio=1,
description=_("Common Setup Actions"))
if "key_menu" not in self:
self["key_menu"] = StaticText(_("MENU"))
if "HelpWindow" not in self:
self["HelpWindow"] = Pixmap()
self["HelpWindow"].hide()
if "VKeyIcon" not in self:
self["VKeyIcon"] = Boolean(False)
self["configActions"] = HelpableActionMap(
self, ["ConfigListActions"], {
"select":
(self.keySelect,
_("Select, toggle, process or edit the current entry"))
},
prio=1,
description=_("Common Setup Actions"))
self["navigationActions"] = HelpableActionMap(
self, ["NavigationActions"], {
"top": (self.keyTop, _("Move to first line / screen")),
"pageUp": (self.keyPageUp, _("Move up a screen")),
"up": (self.keyUp, _("Move up a line")),
"first":
(self.keyFirst,
_("Jump to first item in list or the start of text")),
"left":
(self.keyLeft,
_("Select the previous item in list or move cursor left")),
"right":
(self.keyRight,
_("Select the next item in list or move cursor right")),
"last": (self.keyLast,
_("Jump to last item in list or the end of text")),
"down": (self.keyDown, _("Move down a line")),
"pageDown": (self.keyPageDown, _("Move down a screen")),
"bottom": (self.keyBottom, _("Move to last line / screen"))
},
prio=1,
description=_("Common Setup Actions"))
self["menuConfigActions"] = HelpableActionMap(
self,
"ConfigListActions", {
"menu": (self.keyMenu,
_("Display selection list as a selection menu")),
},
prio=1,
description=_("Common Setup Actions"))
self["menuConfigActions"].setEnabled(False)
self["editConfigActions"] = HelpableNumberActionMap(
self, ["NumberActions", "TextEditActions"], {
"backspace":
(self.keyBackspace,
_("Delete character to left of cursor or select AM times")),
"delete":
(self.keyDelete,
_("Delete character under cursor or select PM times")),
"erase": (self.keyErase, _("Delete all the text")),
"toggleOverwrite":
(self.keyToggle,
_("Toggle new text inserts before or overwrites existing text"
)),
"1":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"2":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"3":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"4":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"5":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"6":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"7":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"8":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"9":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"0":
(self.keyNumberGlobal, _("Number or SMS style data entry")),
"gotAsciiCode": (self.keyGotAscii, _("Keyboard data entry"))
},
prio=1,
description=_("Common Setup Actions"))
self["editConfigActions"].setEnabled(False)
self["VirtualKB"] = HelpableActionMap(
self,
"VirtualKeyboardActions", {
"showVirtualKeyboard":
(self.keyText,
_("Display the virtual keyboard for data entry"))
},
prio=1,
description=_("Common Setup Actions"))
self["VirtualKB"].setEnabled(False)
self["config"] = ConfigList(list, session=session)
self.setCancelMessage(None)
self.setRestartMessage(None)
self.onChangedEntry = []
if self.noNativeKeys not in self.onLayoutFinish:
self.onLayoutFinish.append(self.noNativeKeys)
if self.handleInputHelpers not in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.handleInputHelpers)
if self.showHelpWindow not in self.onExecBegin:
self.onExecBegin.append(self.showHelpWindow)
if self.hideHelpWindow not in self.onExecEnd:
self.onExecEnd.append(self.hideHelpWindow)
def __init__(self, session, playlist, playall=None, lastservice=None):
# The CutList must be initialized very first
CutList.__init__(self)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
InfoBarTimeshift.__init__(self)
InfoBarSupport.__init__(self)
# Skin
if config.EMC.use_orig_skin.value:
self.skinName = "EMCMediaCenterOwn"
else:
self.skinName = "EMCMediaCenter"
skin = getSkin()
if skin:
Cool = open(skin)
self.skin = Cool.read()
Cool.close()
self.serviceHandler = ServiceCenter.getInstance()
# EMC Source
self["Service"] = EMCCurrentService(session.nav, self)
# Events
if isDreamOS:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evEnd: self.__serviceStopped,
iPlayableService.evStopped: self.__serviceStopped,
iPlayableService.evAudioListChanged: self.__osdAudioInfoAvail,
iPlayableService.evSubtitleListChanged: self.__osdSubtitleInfoAvail,
iPlayableService.evUser+3: self.__osdFFwdInfoAvail,
iPlayableService.evUser+4: self.__osdFBwdInfoAvail,
iPlayableService.evUser+6: self.__osdAngleInfoAvail,
iPlayableService.evUser+7: self.__chapterUpdated,
iPlayableService.evUser+8: self.__titleUpdated,
iPlayableService.evUser+9: self.__menuOpened,
iPlayableService.evUser+10: self.__menuClosed
})
else:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
# Disabled for tests
# If we enable them, the sound will be delayed for about 2 seconds ?
iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evStopped: self.__serviceStopped,
#iPlayableService.evEnd: self.__evEnd,
#iPlayableService.evEOF: self.__evEOF,
#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
})
# Keymap
# self["SeekActions"] = HelpableActionMap(self, "InfobarSeekActions", -1 higher priority
# self["MovieListActions"] = HelpableActionMap(self, "InfobarMovieListActions", 0
# self["ShowHideActions"] = ActionMap( ["InfobarShowHideActions"] , 0
# self["EPGActions"] = HelpableActionMap(self, "InfobarEPGActions", 0
# self["CueSheetActions"] = HelpableActionMap(self, actionmap, 1 lower priority
# self["InstantExtensionsActions"] = HelpableActionMap(self, "InfobarExtensions", 1 lower priority
# self["NumberActions"] = NumberActionMap( [ "NumberActions"], 0 Set by EMC to 2 very lower priority
# self["TeletextActions"] = HelpableActionMap(self, "InfobarTeletextActions", 0 Set by EMC to 2 very lower priority
# self["MenuActions"] = HelpableActionMap(self, "InfobarMenuActions", 0 Set by EMC to 2 very lower priority
if config.EMC.movie_exit.value:
self["actions"] = HelpableActionMap(self, "CoolPlayerActions",
{
"leavePlayer": (self.leavePlayer, _("Stop playback")),
}) # default priority
else:
self["actions"] = HelpableActionMap(self, "CoolPlayerActions2",
{
"leavePlayer": (self.leavePlayer, _("Stop playback")),
}) # default priority
self["DVDPlayerPlaybackActions"] = HelpableActionMap(self, "EMCDVDPlayerActions",
{
"dvdMenu": (self.enterDVDMenu, _("show DVD main menu")),
#"showInfo": (self.showInfo, _("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")),
"dvdAudioMenu": (self.enterDVDAudioMenu, _("(show optional DVD audio menu)")),
"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")),
}, 1) # lower priority
# Only enabled if playing a dvd
self["DVDPlayerPlaybackActions"].setEnabled(False)
self["DVDMenuActions"] = ActionMap(["WizardActions"],
{
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
"ok": self.keyOk,
"back": self.keyBack,
}, 2) # lower priority
# Only enabled during DVD Menu
self["DVDMenuActions"].setEnabled(False)
self["GeneralPlayerPlaybackActions"] = HelpableActionMap(self, "EMCGeneralPlayerActions",
{
"showExtensions": (self.openExtensions, _("view extensions...")),
"EMCGreen": (self.CoolAVSwitch, _("Format AVSwitch")),
"seekFwd": (self.seekFwd, _("Seek forward")),
"seekBack": (self.seekBack, _("Seek backward")),
"nextTitle": (self.nextTitle, _("jump forward to the next title")),
"prevTitle": (self.prevTitle, _("jump back to the previous title")),
"movieInfo": (self.infoMovie, _("Movie information")),
}) # default priority
self["MenuActions"].prio = 2
if "TeletextActions" in self:
self["TeletextActions"].prio = 2
self["NumberActions"].prio = 2
# Cover Anzeige
self["Cover"] = Pixmap()
# DVD Player
self["audioLabel"] = Label("")
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.in_menu = None
self.dvdScreen = None
# Further initialization
self.firstStart = True
self.stopped = False
self.closedByDelete = False
self.closeAll = False
self.lastservice = lastservice or self.session.nav.getCurrentlyPlayingServiceReference()
if not self.lastservice:
self.lastservice = InfoBar.instance.servicelist.servicelist.getCurrent()
self.playlist = playlist
self.playall = playall
self.playcount = -1
self.service = None
self.allowPiP = True
self.allowPiPSwap = False # this is needed for vti-image
self.realSeekLength = None
self.servicelist = InfoBar.instance.servicelist
self.picload = ePicLoad()
try:
self.picload_conn = self.picload.PictureData.connect(self.showCoverCallback)
except:
self.picload.PictureData.get().append(self.showCoverCallback)
# Record events
try:
NavigationInstance.instance.RecordTimer.on_state_change.append(self.recEvent)
except Exception, e:
emcDebugOut("[EMCMediaCenter] Record observer add exception:\n" + str(e))
def __init__(self, session, *args, **kwargs):
Screen.__init__(self, session)
self.skinName = [self.skinName, "EPGSelection"]
if isinstance(self, HelpableScreen):
HelpableScreen.__init__(self)
self.searchargs = args
self.currSearch = ""
self.longbuttonpressed = False
# XXX: we lose sort begin/end here
self["key_yellow"] = Button(_("New Search"))
self["key_blue"] = Button(_("Add AutoTimer"))
# begin stripped copy of EPGSelection.__init__
self.ChoiceBoxDialog = None
self.bouquetChangeCB = None
self.serviceChangeCB = None
self.ask_time = -1 # now
self.closeRecursive = False
self.saved_title = None
self.lastAsk = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self["number"] = Label()
self["number"].hide()
self.type = EPG_TYPE_SINGLE
self.currentService = None
self.zapFunc = None
self.currch = None
self.sort_type = 0
self.eventviewDialog = None
self["key_red"] = Button(_("IMDb Search"))
self["key_green"] = Button(_("Add Timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGSearchList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self["dialogactions"] = HelpableActionMap(self, "WizardActions", {
"back": (self.closeChoiceBoxDialog, _("Close dialog")),
}, -1)
self["dialogactions"].csel = self
self["dialogactions"].setEnabled(False)
self["okactions"] = HelpableActionMap(
self, "OkCancelActions", {
"cancel": (self.closeScreen, _("Exit EPG Search")),
"OK": (self.epgsearchOK, _("Zap to channel")),
"OKLong":
(self.epgsearchOKLong, _("Show detailed event information"))
}, -1)
self["okactions"].csel = self
self["colouractions"] = HelpableActionMap(
self, "ColorActions", {
"red": (self.redButtonPressed,
_("IMDB search for highlighted event")),
"green": (self.timerAdd,
_("Add/remove/edit timer for highlighted event")),
"yellow": (self.yellowButtonPressed, _("Enter new search")),
"yellowlong": (self.showHistory, _("Show search history")),
"blue": (self.exportAutoTimer,
_("Add an AutoTimer for highlighted event")),
"bluelong":
(self.blueButtonPressedLong, _("Show AutoTimer list"))
}, -1)
self["colouractions"].csel = self
self["recordingactions"] = HelpableActionMap(
self, "InfobarInstantRecord", {
"ShortRecord": (self.doRecordTimer,
_("Add a record timer for highlighted event")),
"LongRecord":
(self.doZapTimer, _("Add a zap timer for highlighted event"))
}, -1)
self["recordingactions"].csel = self
self["epgactions"] = HelpableActionMap(
self, "EPGSelectActions", {
"nextBouquet": (self.nextPage, _("Move down a page")),
"prevBouquet": (self.prevPage, _("Move up a page")),
"nextService": (self.prevPage, _("Move up a page")),
"prevService": (self.nextPage, _("Move down a page")),
"epg": (self.Info, _("Show detailed event information")),
"info": (self.Info, _("Show detailed event information")),
"infolong":
(self.infoKeyPressed, _("Show detailed event information")),
"menu": (self.menu, _("Setup menu"))
}, -1)
self["epgactions"].csel = self
self["epgcursoractions"] = HelpableActionMap(
self, "DirectionActions", {
"left": (self.prevPage, _("Move up a page")),
"right": (self.nextPage, _("Move down a page")),
"up": (self.moveUp, _("Move up")),
"down": (self.moveDown, _("Move down"))
}, -1)
self["epgcursoractions"].csel = self
self.openHistory = kwargs.get("openHistory", False)
self.onLayoutFinish.append(self.onCreate)
# end stripped copy of EPGSelection.__init__
# Partnerbox
if PartnerBoxIconsEnabled:
EPGSelection.PartnerboxInit(self, False)
self.refreshTimer = eTimer()
self.refreshTimer.callback.append(self.refreshlist)
self.startTimer = eTimer()
self.startTimer.callback.append(self.startUp)
self.startTimer.start(10, 1)
self.searchStartTimer = eTimer()
# Hook up actions for yttrailer if installed
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
except ImportError as ie:
pass
else:
if baseEPGSelection__init__ is not None:
self["trailerActions"] = ActionMap(
["InfobarActions", "InfobarTeletextActions"], {
"showTv": self.showTrailer,
"showRadio": self.showTrailerList,
"startTeletext": self.showConfig
})
def __init__(self,
session,
service,
zapFunc=None,
eventid=None,
bouquetChangeCB=None,
serviceChangeCB=None,
parent=None):
Screen.__init__(self, session)
self.bouquetChangeCB = bouquetChangeCB
self.serviceChangeCB = serviceChangeCB
self.ask_time = -1 #now
self["key_red"] = StaticText("")
self.closeRecursive = False
self.saved_title = None
self["Service"] = ServiceEvent()
self["Event"] = Event()
self.session = session
self.Console = Console()
if isinstance(service, str) and eventid is not None:
self.type = EPG_TYPE_SIMILAR
self.setTitle(_("Similar EPG"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["key_red"] = StaticText()
self.currentService = service
self.eventid = eventid
self.zapFunc = None
elif isinstance(service, eServiceReference) or isinstance(
service, str):
self.setTitle(_("Single EPG"))
self.type = EPG_TYPE_SINGLE
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText(_("Select Channel"))
self.currentService = ServiceReference(service)
self.zapFunc = zapFunc
self.sort_type = 0
self.setSortDescription()
else:
self.setTitle(_("Multi EPG"))
self.skinName = "EPGSelectionMulti"
self.type = EPG_TYPE_MULTI
if self.bouquetChangeCB == StaticText:
self["key_yellow"] = StaticText(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = StaticText(
pgettext("button label, 'next screen'", "Next"))
else:
self["key_yellow"] = Button(
pgettext("button label, 'previous screen'", "Prev"))
self["key_blue"] = Button(
pgettext("button label, 'next screen'", "Next"))
self["now_button"] = Pixmap()
self["next_button"] = Pixmap()
self["more_button"] = Pixmap()
self["now_button_sel"] = Pixmap()
self["next_button_sel"] = Pixmap()
self["more_button_sel"] = Pixmap()
self["now_text"] = Label()
self["next_text"] = Label()
self["more_text"] = Label()
self["date"] = Label()
self.services = service
self.zapFunc = zapFunc
self.parent = parent
if self.bouquetChangeCB == StaticText:
self["key_green"] = StaticText(_("Add timer"))
else:
self["key_green"] = Button(_("Add timer"))
self.key_green_choice = self.ADD_TIMER
self.key_red_choice = self.EMPTY
self["list"] = EPGList(type=self.type,
selChangedCB=self.onSelectionChanged,
timer=session.nav.RecordTimer)
self["actions"] = ActionMap(
["EPGSelectActions", "OkCancelActions"],
{
"cancel": self.closeScreen,
"ok": self.eventSelected,
"timerAdd": self.timerAdd,
"yellow": self.yellowButtonPressed,
"blue": self.blueButtonPressed,
"info": self.infoKeyPressed,
"menu": self.furtherOptions,
"nextBouquet": self.nextBouquet, # just used in multi epg yet
"prevBouquet": self.prevBouquet, # just used in multi epg yet
"nextService": self.nextService, # just used in single epg yet
"prevService": self.prevService, # just used in single epg yet
"preview": self.eventPreview,
})
self['colouractions'] = HelpableActionMap(
self, 'ColorActions',
{"red": (self.GoToTmbd, _("Search event in TMBD"))})
self.isTMBD = fileExists(
resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo"))
if self.isTMBD:
self["key_red"] = Button(_("Search TMBD"))
self.select = True
if not self.isTMBD:
self["key_red"] = Button(_("TMBD Not Installed"))
self.select = False
try:
from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__
description = _("Search yt-trailer for event")
except ImportError as ie:
pass
else:
if baseEPGSelection__init__ is not None:
self["trailerActions"] = ActionMap(
["InfobarActions", "InfobarTeletextActions"], {
"showTv": self.showTrailer,
"showRadio": self.showTrailerList,
"startTeletext": self.showConfig
})
self["actions"].csel = self
if parent and hasattr(parent, "fallbackTimer"):
self.fallbackTimer = parent.fallbackTimer
self.onLayoutFinish.append(self.onCreate)
else:
self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def __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 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,
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,
zapFunc,
startBouquet,
startRef,
bouquets,
timeFocus=None,
isInfobar=False):
self.epgConfig = config.epgselection.infobar if isInfobar else config.epgselection.grid
UserDefinedButtons.__init__(self, self.epgConfig, epgActions,
okActions, infoActions)
EPGSelectionBase.__init__(self, session, self.epgConfig, startBouquet,
startRef, bouquets)
EPGServiceNumberSelection.__init__(self)
EPGServiceZap.__init__(self, zapFunc)
graphic = self.epgConfig.type_mode.value == "graphics"
if not config.epgselection.grid.pig.value:
self.skinName = ["GridEPG", "GraphicalEPG"]
else:
self.skinName = ["GridEPGPIG", "GraphicalEPGPIG"]
self.closeRecursive = False
EPGBouquetSelection.__init__(self, graphic)
self["timeline_text"] = TimelineText(self.epgConfig, graphic)
self["Event"] = Event()
self["primetime"] = Label(_("PRIMETIME"))
self["change_bouquet"] = Label(_("CHANGE BOUQUET"))
self["jump"] = Label(_("JUMP 24 HOURS"))
self["page"] = Label(_("PAGE UP/DOWN"))
self["key_text"] = StaticText(_("TEXT"))
self.timeLines = []
for x in range(0, MAX_TIMELINES):
pm = Pixmap()
self.timeLines.append(pm)
self["timeline%d" % x] = pm
self["timeline_now"] = Pixmap()
self.updateTimelineTimer = eTimer()
self.updateTimelineTimer.callback.append(self.moveTimeLines)
self.updateTimelineTimer.start(60000)
helpDescription = _("EPG Commands")
self["epgcursoractions"] = HelpableActionMap(
self,
"DirectionActions", {
"left": (self.leftPressed, _("Go to previous event")),
"right": (self.rightPressed, _("Go to next event")),
"up": (self.moveUp, _("Go to previous channel")),
"down": (self.moveDown, _("Go to next channel"))
},
prio=-1,
description=helpDescription)
self["epgactions"] = HelpableActionMap(
self,
"EPGSelectActions", {
"nextService":
self.helpKeyAction("channelup"),
"prevService":
self.helpKeyAction("channeldown"),
"nextBouquet": (self.nextBouquet, _("Go to next bouquet")),
"prevBouquet": (self.prevBouquet, _("Go to previous bouquet")),
"input_date_time":
(self.enterDateTime, _("Go to specific date/time")),
"epg":
self.helpKeyAction("epg"),
"epglong":
self.helpKeyAction("epglong"),
"info":
self.helpKeyAction("info"),
"infolong":
self.helpKeyAction("infolong"),
"tv": (self.toggleBouquetList,
_("Toggle between bouquet/epg lists")),
"tvlong": (self.togglePIG, _("Toggle picture In graphics")),
"timer": (self.openTimerList, _("Show timer list")),
"timerlong":
(self.openAutoTimerList, _("Show autotimer list")),
"back":
(self.goToCurrentTimeOrServiceOrTop,
_("Go to current time, then the start service, then home of list"
)),
"menu": (self.createSetup, _("Setup menu"))
},
prio=-1,
description=helpDescription)
if config.epgselection.grid.number_buttons_mode.value == "paging":
self["numberactions"] = HelpableActionMap(
self,
"NumberActions", {
"1": (self.reduceTimeScale, _("Reduce time scale")),
"2": (self.prevPage, _("Page up")),
"3": (self.increaseTimeScale, _("Increase time scale")),
"4": (self.pageLeft, _("page left")),
"5": (self.goToCurrentTime, _("Jump to current time")),
"6": (self.pageRight, _("Page right")),
"7": (self.toggleNumberOfRows,
_("No of items switch (increase or reduced)")),
"8": (self.nextPage, _("Page down")),
"9": (self.goToPrimeTime, _("Jump to prime time")),
"0":
(self.goToCurrentTimeAndTop, _("Move to home of list"))
},
prio=-1,
description=helpDescription)
self["list"] = EPGListGrid(session,
isInfobar=isInfobar,
selChangedCB=self.onSelectionChanged)
self["list"].setTimeFocus(timeFocus or time())
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self["key_menu"] = StaticText(_("MENU"))
self["key_info"] = StaticText(_("INFO"))
self["key_red"] = StaticText()
self["key_green"] = StaticText()
self["key_yellow"] = StaticText()
self["icons"] = MultiPixmap()
self["icons"].hide()
self["locales"] = List(None, enableWrapAround=True)
self["locales"].onSelectionChanged.append(self.selectionChanged)
self["description"] = StaticText()
self["selectionActions"] = HelpableActionMap(
self,
"LocaleSelectionActions", {
"menu": (self.keySettings,
_("Manage Locale/Language Selection settings")),
"current": (self.keyCurrent,
_("Jump to the currently active locale/language")),
"select":
(self.keySelect,
_("Select the currently highlighted locale/language for the user interface"
)),
"close":
(self.closeRecursive,
_("Cancel any changes the active locale/language and exit all menus"
)),
"cancel":
(self.keyCancel,
_("Cancel any changes to the active locale/language and exit")
),
"save":
(self.keySave,
_("Apply any changes to the active locale/language and exit"))
},
prio=0,
description=_("Locale/Language Selection Actions"))
self["manageActions"] = HelpableActionMap(
self,
"LocaleSelectionActions", {
"manage":
(self.keyManage,
(_("Purge all but / Add / Delete the currently highlighted locale/language"
),
_("Purge all but the current and permanent locales/languages. Add the current locale/language if it is not installed. Delete the current locale/language if it is installed."
)))
},
prio=0,
description=_("Locale/Language Selection Actions"))
topItem = _("Move up to first line")
topDesc = _("Move up to the first line in the list.")
pageUpItem = _("Move up one screen")
pageUpDesc = _(
"Move up one screen. Move to the first line of the screen if this is the first screen."
)
upItem = _("Move up one line")
upDesc = _(
"Move up one line. Move to the bottom of the previous screen if this is the first line of the screen. Move to the last of the entry / list if this is the first line of the list."
)
downItem = _("Move down one line")
downDesc = _(
"Move down one line. Move to the top of the next screen if this is the last line of the screen. Move to the first line of the list if this is the last line on the list."
)
pageDownItem = _("Move down one screen")
pageDownDesc = _(
"Move down one screen. Move to the last line of the screen if this is the last screen."
)
bottomItem = _("Move down to last line")
bottomDesc = _("Move down to the last line in the list.")
self["navigationActions"] = HelpableActionMap(
self,
"NavigationActions", {
"top": (self.keyTop, (topItem, topDesc)),
"pageUp": (self.keyPageUp, (pageUpItem, pageUpDesc)),
"up": (self.keyUp, (upItem, upDesc)),
"first": (self.keyTop, (topItem, topDesc)),
"left": (self.keyPageUp, (pageUpItem, pageUpDesc)),
"right": (self.keyPageDown, (pageDownItem, pageDownDesc)),
"last": (self.keyBottom, (bottomItem, bottomDesc)),
"down": (self.keyDown, (downItem, downDesc)),
"pageDown": (self.keyPageDown, (pageDownItem, pageDownDesc)),
"bottom": (self.keyBottom, (bottomItem, bottomDesc))
},
prio=0,
description=_("List Navigation Actions"))
self.initialLocale = international.getLocale()
self.currentLocale = self.initialLocale
self.packageTimer = eTimer()
self.packageTimer.callback.append(self.processPackage)
self.packageDoneTimer = eTimer()
self.packageDoneTimer.callback.append(self.processPackageDone)
self.onLayoutFinish.append(self.layoutFinished)
class MediaPlayer(Screen, InfoBarBase, InfoBarScreenSaver, InfoBarSeek, InfoBarAudioSelection, InfoBarCueSheetSupport, InfoBarNotifications, InfoBarSubtitleSupport, HelpableScreen):
ALLOW_SUSPEND = True
ENABLE_RESUME_SUPPORT = True
FLAG_CENTER_DVB_SUBS = 2048
media_instance = None
def __init__(self, session, args = None):
Screen.__init__(self, session)
InfoBarAudioSelection.__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()
MediaPlayer.media_instance = self
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, 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):
self.session = session
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.setTitle(_("Quad PiP Channel Selection"))
dw = self.session.desktop.size().width()
dh = self.session.desktop.size().height()
pw, ph = {1080:("center", "center"), 720:("center", "center"), 576:("center", "20%")}.get(dh, ("center", "center"))
(sw, sh) = {1080:(dw/3, dh/2), 720:(int(dw/2), int(dh/1.5)), 576:(int(dw/1.3), int(dh/1.5))}.get(dh, (28, 24))
button_margin = 5
button_h = 40
list_y = 40+button_margin*3
self.fontSize = {1080:(28, 24), 720:(24,20), 576:(20,18)}.get(dh, (28, 24))
self.skin = QuadPiPChannelSelection.skin % (pw, ph, \
sw, sh+list_y, \
sw/8-70, button_margin, \
sw/8-70+sw/4, button_margin, \
sw/8-70+sw/4*2, button_margin, \
sw/8-70+sw/4*3, button_margin, \
sw/8-70, button_margin, \
sw/8-70+sw/4, button_margin, \
sw/8-70+sw/4*2, button_margin, \
sw/8-70+sw/4*3, button_margin, \
0, list_y, sw, sh, \
sw/16, 1, sw-sw/16*2, sh/13, \
sw/11, 1+sh/13, sw-sw/16*2-sw/8, sh/18, \
sw/11, 1+sh/13+sh/18, sw-sw/16*2-sw/8, sh/18, \
sw/11, 1+sh/13+sh/18*2, sw-sw/16*2-sw/8, sh/18, \
sw/11, 1+sh/13+sh/18*3, sw-sw/16*2-sw/8, sh/18, \
self.fontSize[0], self.fontSize[1], \
sh/3)
self["key_red"] = Label(_("Select"))
self["key_green"] = Label(_("Add"))
self["key_yellow"] = Label(_("Remove"))
self["key_blue"] = Label(_("Edit"))
self.PipChannelListApply = []
self["ChannelList"] = List(self.PipChannelListApply)
self["qpipActions"] = HelpableActionMap(self, "QuadPipSetupActions",
{
"red": (self.keyRed, _("Select Quad Channels")),
"green": (self.keyGreen, _("Add New Quad Channel Entry")),
"yellow": (self.keyYellow, _("Remove Quad Channel Entry")),
"blue": (self.keyBlue, _("Edit Quad Channel Entry")),
}, -2)
self["OkCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{
"ok": (self.keyOk, _("Select Quad Channels")),
"cancel": (self.keyCancel, _("Exit Quad Channel Selection")),
}, -2)
self.oldPosition = None
global quad_pip_channel_list_instance
self.qpipChannelList = quad_pip_channel_list_instance
self.oldPosition = self.qpipChannelList.getIdx()-1
self.onLayoutFinish.append(self.layoutFinishedCB)
def __init__(self, session, libraryName, loadLibrary, playEntry, viewName, select=None, sort=None, filter=None):
print "viewName", viewName
self.skinName = viewName[2]
Screen.__init__(self, session)
NumericalTextInput.__init__(self)
self.skinName = viewName[2]
self.select = select
self.onFirstExecSort = sort
self.onFirstExecFilter = filter
self.libraryName = libraryName
self.loadLibrary = loadLibrary
self.viewName = viewName
self._playEntry = playEntry
self.oldService = self.session.nav.getCurrentlyPlayingServiceReference()
self.session.nav.stopService()
# Initialise API Level for this screen
self.APILevel = 99
printl("APILevel=" + str(self.APILevel))
# Initialise library list
list = []
if self.APILevel == 1:
self["listview"] = MenuList(list)
elif self.APILevel >= 2:
self["listview"] = List(list, True)
if self.APILevel >= 6:
self["number_key_popup"] = Label("")
self["number_key_popup"].hide()
self.seenPng = None
self.unseenPng = None
self["actions"] = HelpableActionMap(self, "DP_ListMain",
{
"ok": (self.onKeyOk, ""),
"cancel": (self.onKeyCancel, ""),
"left": (self.onKeyLeft, ""),
"right": (self.onKeyRight, ""),
"left_quick": (self.onKeyLeftQuick, ""),
"right_quick": (self.onKeyRightQuick, ""),
"up": (self.onKeyUp, ""),
"down": (self.onKeyDown, ""),
"up_quick": (self.onKeyUpQuick, ""),
"down_quick": (self.onKeyDownQuick, ""),
"info": (self.onKeyInfo, ""),
"menu": (self.onKeyMenu, ""),
"red": (self.onKeyRed, ""),
"green": (self.onKeyGreen, ""),
"yellow": (self.onKeyYellow, ""),
"blue": (self.onKeyBlue, ""),
"red_long": (self.onKeyRedLong, ""),
"green_long": (self.onKeyGreenLong, ""),
"yellow_long": (self.onKeyYellowLong, ""),
"blue_long": (self.onKeyBlueLong, ""),
"1": (self.onKey1, ""),
"2": (self.onKey2, ""),
"3": (self.onKey3, ""),
"4": (self.onKey4, ""),
"5": (self.onKey5, ""),
"6": (self.onKey6, ""),
"7": (self.onKey7, ""),
"8": (self.onKey8, ""),
"9": (self.onKey9, ""),
"0": (self.onKey0, ""),
}, -2)
# For number key input
self.setUseableChars(u' 1234567890abcdefghijklmnopqrstuvwxyz')
self.onLayoutFinish.append(self.setCustomTitle)
self.onFirstExecBegin.append(self.onFirstExec)
def __init__(self, session):
self.modulation = config.plugins.SDGRadio.modulation
self.frequency = eval("config.plugins.SDGRadio.frequency_%s" % self.modulation.value)
self.playbackFrequency = None # currently playing frequency
self.playbackPreset = None # currently playing preset
self.presets = [] # preset list for current modulation
self.log = [] # log messages
self.programs = [] # DAB program list
self.console = None
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.setTitle(_("Software defined radio"))
self.skin = SKIN
self.skin_path = resolveFilename(SCOPE_PLUGINS, "Extensions/SDGRadio")
for i in range(0, 10):
self["mem_%d" % i] = MultiPixmap()
self["modulation"] = Label()
self["freq"] = Label()
self["freq_off"] = Label()
self["freq_units"] = Label()
self["dab_channel"] = Label()
self["radiotext"] = Label()
self["prog_type"] = Label()
self["pi"] = Label()
self["traffic"] = Label()
self["af"] = Label()
self["ct"] = Label()
self["eon"] = Label()
self["rt+"] = Label()
self["pic"] = Pixmap()
self["rds_icon"] = Pixmap()
self["rt_icon"] = Pixmap()
self["ps_icon"] = Pixmap()
self["key_red"] = StaticText()
self["key_green"] = StaticText(_("Play"))
self["key_yellow"] = StaticText()
self["key_blue"] = StaticText()
self["actions"] = HelpableActionMap(self, "SDGRadioActions",
{
"cancel": (self.cancel, _("Close plugin")),
"ok": (self.selectFreq, _("Play current frequency")),
"info": (self.showPrograms, _("Show DAB program list")),
"menu": (self.showMenu, _("Open advanced options menu")),
"red": (self.toggleModulation, _("Change modulation")),
"green": (self.togglePlayback, _("Start/stop playback")),
"yellow": (self.yellow, _("Switch RDS on/off")),
"blue": (self.showInput, _("Open frequency input screen")),
"blue_long": (self.showLog, _("Cmd execution log")),
"0": (boundFunction(self.selectPreset, 0), _("Play memory preset %d") % 0),
"1": (boundFunction(self.selectPreset, 1), _("Play memory preset %d") % 1),
"2": (boundFunction(self.selectPreset, 2), _("Play memory preset %d") % 2),
"3": (boundFunction(self.selectPreset, 3), _("Play memory preset %d") % 3),
"4": (boundFunction(self.selectPreset, 4), _("Play memory preset %d") % 4),
"5": (boundFunction(self.selectPreset, 5), _("Play memory preset %d") % 5),
"6": (boundFunction(self.selectPreset, 6), _("Play memory preset %d") % 6),
"7": (boundFunction(self.selectPreset, 7), _("Play memory preset %d") % 7),
"8": (boundFunction(self.selectPreset, 8), _("Play memory preset %d") % 8),
"9": (boundFunction(self.selectPreset, 9), _("Play memory preset %d") % 9),
"long0": (boundFunction(self.storePreset, 0), _("Store frequency to memory preset %d") % 0),
"long1": (boundFunction(self.storePreset, 1), _("Store frequency to memory preset %d") % 1),
"long2": (boundFunction(self.storePreset, 2), _("Store frequency to memory preset %d") % 2),
"long3": (boundFunction(self.storePreset, 3), _("Store frequency to memory preset %d") % 3),
"long4": (boundFunction(self.storePreset, 4), _("Store frequency to memory preset %d") % 4),
"long5": (boundFunction(self.storePreset, 5), _("Store frequency to memory preset %d") % 5),
"long6": (boundFunction(self.storePreset, 6), _("Store frequency to memory preset %d") % 6),
"long7": (boundFunction(self.storePreset, 7), _("Store frequency to memory preset %d") % 7),
"long8": (boundFunction(self.storePreset, 8), _("Store frequency to memory preset %d") % 8),
"long9": (boundFunction(self.storePreset, 9), _("Store frequency to memory preset %d") % 9),
"up": (boundFunction(self.freqUp, "1"), _("Increase frequency by 1 MHz / KHz")),
"down": (boundFunction(self.freqDown, "1"), _("Decrease frequency by 1 MHz / KHz")),
"upRepeated": (boundFunction(self.freqUp, "10"), _("Increase frequency by 10 MHz / KHz (long press)")),
"downRepeated": (boundFunction(self.freqDown, "10"), _("Decrease frequency by 10 MHz / KHz (long press)")),
"right": (boundFunction(self.freqUp, "0.05"), _("Increase frequency by 0.05 MHz")),
"left": (boundFunction(self.freqDown, "0.05"), _("Decrease frequency by 0.05 MHz")),
"rightRepeated": (boundFunction(self.freqUp, "0.1"), _("Increase frequency by 0.1 MHz (long press)")),
"leftRepeated": (boundFunction(self.freqDown, "0.1"), _("Decrease frequency by 0.1 MHz (long press)")),
"nextBouquet": (boundFunction(self.freqUp, "0.0001"), _("Increase frequency by 0.0001 MHz")),
"prevBouquet": (boundFunction(self.freqDown, "0.0001"), _("Decrease frequency by 0.0001 MHz")),
}, -2)
self.onLayoutFinish.extend([self.getConfigOptions, self.getPresets, self.updateFreqWidget,
self.updateExtraWidgets, self.redText, self.yellowText, self.blueText])
self.oldService = self.session.nav.getCurrentlyPlayingServiceReference() # get currently playing service
self.session.nav.stopService() # stop currently playing service
eConsoleAppContainer().execute("showiframe /usr/share/enigma2/radio.mvi") # display radio mvi
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
InfoBarNotifications.__init__(self)
self.ftpclient = None
self.queueManagerInstance = None
self.file = None
self.queue = None
self.currlist = "local"
# # NOTE: having self.checkNotifications in onExecBegin might make our gui
# disappear, so let's move it to onShow
self.onExecBegin.remove(self.checkNotifications)
self.onShow.append(self.checkNotifications)
# Init what we need for dl progress
self.currentLength = 0
self.lastLength = 0
self.lastTime = 0
self.lastApprox = 0
self.fileSize = 0
self["localText"] = StaticText(_("Local"))
self["local"] = FileList("/media/hdd/", showMountpoints=False)
self["remoteText"] = StaticText(_("Remote (not connected)"))
self["remote"] = FTPFileList()
self["eta"] = StaticText("")
self["speed"] = StaticText("")
self["progress"] = VariableProgressSource()
self["key_red"] = StaticText(_("Exit"))
self["key_green"] = StaticText(_("Rename"))
self["key_yellow"] = StaticText(_("Delete"))
self["key_blue"] = StaticText(_("Upload"))
self.server = None
self["ftpbrowserBaseActions"] = HelpableActionMap(
self, "ftpbrowserBaseActions", {
"ok": (self.ok, _("enter directory/get file/put file")),
"cancel": (self.cancel, _("close")),
"menu": (self.menu, _("open menu")),
}, -2)
self["ftpbrowserListActions"] = HelpableActionMap(
self, "ftpbrowserListActions", {
"channelUp": (self.setLocal, _("Select local file list")),
"channelDown": (self.setRemote, _("Select remote file list")),
})
self["actions"] = ActionMap(
["ftpbrowserDirectionActions", "ColorActions"], {
"up": self.up,
"down": self.down,
"left": self.left,
"right": self.right,
"green": self.rename,
"yellow": self.delete,
"blue": self.transfer,
}, -2)
self.onExecBegin.append(self.reinitialize)
def __init__(self, session):
serienRecBaseScreen.__init__(self, session)
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.skin = None
self.session = session
self.picload = ePicLoad()
self.piconLoader = PiconLoader()
self.WochenTag = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
self.database = SRDatabase(SerienRecorder.serienRecDataBaseFilePath)
self.channelList = STBHelpers.buildSTBChannelList()
self["actions"] = HelpableActionMap(
self, "SerienRecorderActions", {
"ok": (self.keyOK, "Liste der erstellten Timer bearbeiten"),
"cancel": (self.keyCancel, "zurück zur Serienplaner-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.keyRed, "ausgewählten Timer löschen"),
"green": (self.viewChange, "Sortierung ändern"),
"yellow":
(self.keyYellow, "umschalten alle/nur aktive Timer anzeigen"),
"blue": (self.keyBlue, "alle noch ausstehenden Timer löschen"),
"menu":
(self.recSetup, "Menü für globale Einstellungen öffnen"),
"startTeletext":
(self.wunschliste,
"Informationen zur ausgewählten Serie auf Wunschliste anzeigen"
),
"0":
(self.readLogFile, "Log-File des letzten Suchlaufs anzeigen"),
"3": (self.showProposalDB,
"Liste der Serien/Staffel-Starts anzeigen"),
"4": (self.serieInfo,
"Informationen zur ausgewählten Serie anzeigen"),
"6":
(self.showConflicts, "Liste der Timer-Konflikte anzeigen"),
"7": (self.showWishlist,
"Merkzettel (vorgemerkte Folgen) anzeigen"),
"8": (self.cleanUp, "Timerliste bereinigen"),
"9":
(self.dropAllTimer, "Alle Timer aus der Datenbank löschen"),
}, -1)
self.helpList[0][2].sort()
self["helpActions"] = ActionMap(
[
"SerienRecorderActions",
],
{
# "ok" : self.keyOK,
"displayHelp": self.showHelp,
"displayHelp_long": self.showManual,
},
0)
self.setupSkin()
self.changesMade = False
self.filter = True
self.onLayoutFinish.append(self.readTimer)
self.onClose.append(self.__onClose)
self.onLayoutFinish.append(self.setSkinProperties)
def __init__(self, session):
Screen.__init__(self, session)
if config.usage.show_infobar_lite.value and (
config.skin.primary_skin.value == "DMConcinnity-HD/skin.xml"
or config.skin.primary_skin.value.startswith('MetrixHD/')):
self.skinName = "InfoBarLite"
self["Universe"] = Label(self.whereIAm())
self["actions"] = HelpableActionMap(
self,
"InfobarActions", {
"showMovies": (self.showMovies, _("Play recorded movies...")),
"showRadio":
(self.showRadioButton, _("Show the radio player...")),
"showTv": (self.showTvButton, _("Show the tv player...")),
"toogleTvRadio":
(self.toogleTvRadio, _("Toggels between tv and radio...")),
"openBouquetList":
(self.openBouquetList, _("Open bouquetlist...")),
"showMediaPlayer":
(self.showMediaPlayer, _("Show the media player...")),
"openTimerList": (self.openTimerList, _("Open Timerlist...")),
"openAutoTimerList":
(self.openAutoTimerList, _("Open AutoTimerlist...")),
"openEPGSearch": (self.openEPGSearch, _("Open EPGSearch...")),
"openIMDB": (self.openIMDB, _("Open IMDB...")),
"showMC":
(self.showMediaCenter, _("Show the media center...")),
"openSleepTimer":
(self.openPowerTimerList, _("Show the Sleep Timer...")),
'ZoomInOut': (self.ZoomInOut, _('Zoom In/Out TV...')),
'ZoomOff': (self.ZoomOff, _('Zoom Off...')),
'HarddiskSetup': (self.HarddiskSetup, _('Select HDD')),
"showWWW": (self.showPORTAL, _("Open MediaPortal...")),
"showSetup": (self.showSetup, _("Show setup...")),
"showFormat": (self.showFormat, _("Show Format Setup...")),
"showPluginBrowser":
(self.showPluginBrowser, _("Show the plugins...")),
"showBoxPortal": (self.showBoxPortal, _("Show Box Portal...")),
},
prio=2)
self["key_red"] = Label()
self["key_yellow"] = Label()
self["key_blue"] = Label()
self["key_green"] = Label()
self.allowPiP = True
self.radioTV = 0
for x in HelpableScreen, \
InfoBarBase, InfoBarShowHide, \
InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, DeliteBp, DeliteGp, BhRedp, \
InfoBarInstantRecord, InfoBarAudioSelection, InfoBarRedButton, InfoBarTimerButton, InfoBarUnhandledKey, InfoBarLongKeyDetection, InfoBarINFOpanel, InfoBarResolutionSelection, InfoBarVmodeButton, \
InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, InfoBarAspectSelection, InfoBarBuffer, \
InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, \
InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, InfoBarZoom, InfoBarSleepTimer, InfoBarOpenOnTopHelper, \
InfoBarHdmi, InfoBarPlugins, InfoBarServiceErrorPopupSupport, InfoBarButtonSetup:
x.__init__(self)
self.helpList.append(
(self["actions"], "InfobarActions", [("showMovies",
_("Watch recordings..."))]))
self.helpList.append((self["actions"], "InfobarActions",
[("showRadio", _("Listen to the radio..."))]))
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
enigma.iPlayableService.evUpdatedEventInfo:
self.__eventInfoChanged
})
self.current_begin_time = 0
assert InfoBar.instance is None, "class InfoBar is a singleton class and just one instance of this class is allowed!"
InfoBar.instance = self
if config.misc.initialchannelselection.value:
self.onShown.append(self.showMenu)
self.zoomrate = 0
self.zoomin = 1
self.onShow.append(self.doButtonsCheck)
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"] = self["description"] = 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
def __init__(self, session, playlistCallback, nextItemCallback,
prevItemCallback, infoCallback, menuCallback):
Screen.__init__(self, session)
self.skinName = ['KodiVideoPlayer']
statusScreen = self.session.instantiateDialog(StatusScreen)
InfoBarBase.__init__(self, steal_current_service=True)
SubsSupport.__init__(self, searchSupport=True, embeddedSupport=True)
SubsSupportStatus.__init__(self)
InfoBarSeek.__init__(self)
InfoBarShowHide.__init__(self)
InfoBarSubservicesSupport.__init__(self)
InfoBarAspectChange.__init__(self)
InfoBarAudioSelection.__init__(self)
InfoBarNotifications.__init__(self)
HelpableScreen.__init__(self)
self.playlistCallback = playlistCallback
self.nextItemCallback = nextItemCallback
self.prevItemCallback = prevItemCallback
self.infoCallback = infoCallback
self.menuCallback = menuCallback
self.statusScreen = statusScreen
self.defaultImage = None
self.postAspectChange.append(self.showAspectChanged)
self.__timer = eTimer()
self.__timer.callback.append(self.__seekToPosition)
self.__image = None
self.__position = None
self.__firstStart = True
self["genre"] = Label()
# load meta info from json file provided by Kodi Enigma2Player
try:
meta = json.load(open(KODIEXTIN, "r"))
except Exception as e:
self.logger.error("failed to load meta from %s: %s", KODIEXTIN,
str(e))
meta = {}
self.__image = Meta(meta).getImage()
self["image"] = WebPixmap(self.__image, caching=True)
self.genre = str(", ".join(Meta(meta).getGenre()))
self.plot = Meta(meta).getPlot()
self["genre"].setText(self.genre)
# set title, image if provided
self.title_ref = Meta(meta).getTitle()
# set start position if provided
self.setStartPosition(Meta(meta).getStartTime())
self["directionActions"] = HelpableActionMap(
self, "DirectionActions", {
"downUp": (playlistCallback, _("Show playlist")),
"upUp": (playlistCallback, _("Show playlist"))
})
self["okCancelActions"] = HelpableActionMap(self, "OkCancelActions",
{"cancel": self.close})
self["actions"] = HelpableActionMap(
self, "KodiPlayerActions", {
"menuPressed": (menuCallback, _("Show playback menu")),
"infoPressed": (infoCallback, _("Show playback info")),
"nextPressed":
(nextItemCallback, _("Skip to next item in playlist")),
"prevPressed":
(prevItemCallback, _("Skip to previous item in playlist")),
"seekFwdManual":
self.keyr,
"seekBackManual":
self.keyl
})
self.eventTracker = ServiceEventTracker(
self, {
iPlayableService.evStart: self.__evStart,
})
assert KodiVideoPlayer.instance is None, "class KodiVideoPlayer is a singleton class and just one instance of this class is allowed!"
KodiVideoPlayer.instance = self
self.onClose.append(
boundFunction(self.session.deleteDialog, self.statusScreen))
self.onClose.append(
boundFunction(Notifications.RemovePopup, self.RESUME_POPUP_ID))
self.onClose.append(self.__timer.stop)
def __init__(self, session, piclist, lastindex, path):
self["key_red"] = Button("")
self["key_green"] = Button("Slide Show")
self["key_yellow"] = Button("File View")
self["key_blue"] = Button(_("Settings"))
self.textcolor = config.plugins.mc_pp.textcolor.value
self.color = config.plugins.mc_pp.bgcolor.value
textsize = 20
self.spaceX = 20
self.spaceY = 28
self.picX = config.plugins.mc_pp.ThumbWidth.value
self.picY = config.plugins.mc_pp.ThumbHeight.value
size_w = getDesktop(0).size().width()
size_h = getDesktop(0).size().height()
if size_w == 1280:
self.spaceTop = 130
self.spaceLeft = 50
self.ButtonPosY = 95
else:
self.spaceTop = 120
self.spaceLeft = 25
self.ButtonPosY = 72
self.thumbsX = size_w / (self.spaceX + self.picX) # thumbnails in X
self.thumbsY = size_h / (self.spaceY + self.picY) # thumbnails in Y
self.thumbsC = self.thumbsX * self.thumbsY # all thumbnails
self.positionlist = []
skincontent = ""
posX = -1
for x in range(self.thumbsC):
posY = x / self.thumbsX
posX += 1
if posX >= self.thumbsX:
posX = 0
absX = self.spaceLeft + self.spaceX + (posX *
(self.spaceX + self.picX))
absY = self.spaceTop + self.spaceY + (posY *
(self.spaceY + self.picY))
self.positionlist.append((absX, absY))
skincontent += "<widget name=\"label" + str(
x
) + "\" position=\"" + str(absX + 5) + "," + str(
absY + self.picY - textsize
) + "\" size=\"" + str(self.picX - 10) + "," + str(
textsize
) + "\" font=\"Regular;14\" zPosition=\"2\" transparent=\"1\" noWrap=\"1\" foregroundColor=\"" + self.textcolor + "\" />"
skincontent += "<widget name=\"thumb" + str(
x) + "\" position=\"" + str(absX + 5) + "," + str(
absY + 5
) + "\" size=\"" + str(self.picX - 10) + "," + str(
self.picY - (textsize * 2)
) + "\" zPosition=\"2\" transparent=\"1\" alphatest=\"on\" />"
# Screen, buttons, backgroundlabel and MovingPixmap
self.skin = "<screen position=\"0,0\" size=\"" + str(
size_w
) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
<ePixmap name=\"mb_bg\" position=\"0,0\" zPosition=\"1\" size=\"" + str(
size_w
) + "," + str(
size_h
) + "\" pixmap=\"" + mcpath + "skins/defaultHD/images/background.png\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-red.png\" position=\"60," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-green.png\" position=\"210," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-yellow.png\" position=\"360," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<ePixmap pixmap=\"" + mcpath + "icons/key-blue.png\" position=\"510," + str(
self.ButtonPosY
) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
<widget name=\"key_red\" position=\"60," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#9f1313\" transparent=\"1\" /> \
<widget name=\"key_green\" position=\"210," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#1f771f\" transparent=\"1\" /> \
<widget name=\"key_yellow\" position=\"360," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#a08500\" transparent=\"1\" /> \
<widget name=\"key_blue\" position=\"510," + str(
self.ButtonPosY
) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#18188b\" transparent=\"1\" /> \
<eLabel position=\"0,0\" zPosition=\"0\" size=\"" + str(size_w) + "," + str(
size_h
) + "\" backgroundColor=\"" + self.color + "\" /> \
<widget name=\"frame\" position=\"35,30\" size=\"" + str(
self.picX + 1
) + "," + str(
self.picY +
10
) + "\" pixmap=\"pic_frame.png\" zPosition=\"3\" alphatest=\"on\" />" + skincontent + "</screen>"
Screen.__init__(self, session)
self["actions"] = HelpableActionMap(
self, "MC_PictureViewerActions", {
"ok": (self.KeyOk, "Show Picture"),
"cancel": (self.Exit, "Exit Picture Viewer"),
"left": (self.key_left, "List Top"),
"right": (self.key_right, "List Bottom"),
"up": (self.key_up, "List up"),
"down": (self.key_down, "List down"),
"info": (self.StartExif, "Show File Info"),
"green": (self.startslideshow, "Start Slideshow"),
"yellow": (self.close, "File View"),
"blue": (self.Settings, "Settings"),
}, -2)
self["frame"] = MovingPixmap()
for x in range(self.thumbsC):
self["label" + str(x)] = Label()
self["thumb" + str(x)] = Pixmap()
self.Thumbnaillist = []
self.filelist = []
self.currPage = -1
self.dirlistcount = 0
self.path = path
index = 0
framePos = 0
Page = 0
for x in piclist:
if x[0][1] == False:
self.filelist.append(
(index, framePos, Page, x[0][0], path + x[0][0]))
index += 1
framePos += 1
if framePos > (self.thumbsC - 1):
framePos = 0
Page += 1
else:
self.dirlistcount += 1
self.maxentry = len(self.filelist) - 1
self.index = lastindex - self.dirlistcount
if self.index < 0:
self.index = 0
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.showPic)
self.onLayoutFinish.append(self.setPicloadConf)
self.ThumbTimer = eTimer()
self.ThumbTimer.callback.append(self.showPic)
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)
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 as ex:
print("[MediaPlayer] No hotplug support", ex)
class MoviePlayerActionMap(NumberActionMap):
def __init__(self, player, contexts=None, actions=None, prio=0):
if not contexts: contexts = []
if not actions: actions = {}
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.switchLists, _("Switch between filelist/playlist")),
"nextBouquet": (self.switchLists, _("Switch between filelist/playlist")),
"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.evStart: self.__evStart,
iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
# we dont need that anymore, but keep it for the next two weeks
# let us see, if user reports any problems
iPlayableService.evUser+13: self["coverArt"].embeddedCoverArt,
iPlayableService.evUser+13: self.__embeddedCoverArt
})
def __init__(self, session):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
ChannelsBase.__init__(self)
WebChannels.__init__(self)
self.session = session
self.skinName = ["SeriesPluginChannelEditor"]
log.debug("ChannelEditor")
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)
