def finishStillPicture(self):
if self.elementExists():
try:
if self.isLoop is False:
self.showiframe.finishStillPicture()
elif self.isLoop is True:
self.pollStop()
if self.session is not None and self.session.nav is not None:
self.session.nav.stopService()
ServiceEventTracker.popActiveInfoBar()
else:
printl("ARGGHHHH!!! self.session is not None and self.session.nav is None", self, "E")
except Exception, ex:
printl("Exception(" + str(type(ex)) + "): " + str(ex), self, "E")
def showStillPicture(self):
#print "showStillPicture", "-->"
if self.elementExists():
try:
if self.isLoop is False:
self.showiframe.showStillpicture(self.getStillpicture())
elif self.isLoop is True:
if self.session is not None and self.session.nav is not None:
printl("loop: " + str(self.getStillpicture()), self)
ServiceEventTracker.setActiveInfoBar(self, None, None)
self.session.nav.playService(eServiceReference(4097, 0, self.getStillpicture()))
self.pollStart()
else:
printl("ARGGHHHH!!! self.session is not None and self.session.nav is not None", self, "E")
except Exception, ex:
printl("Exception(" + str(type(ex)) + "): " + str(ex), self, "E")
def __init__(self, session, server):
Screen.__init__(self, session)
self.session = session
self.server = server
self.filelistlabel = "Filelist:" + self.server.getBasedir()
self.playlistlabel = "Playlist"
self.defaultFilter = "(?i)\.(avi|mpeg|mpg|divx|flac|ogg|xvid|mp3|mp4|mov|ts|vob|wmv|mkv|iso|bin|m3u|pls|dat|xspf)$"
#self.filelist = VlcFileList(server, self.defaultFilter)
self.filelist = VlcFileList(self.getFilesAndDirsCB, server.getBasedir(), self.defaultFilter)
self["filelist"] = self.filelist
self["playlist"] = VlcPlayList(self.getPlaylistEntriesCB)
self["listlabel"] = Label("")
self["key_red"] = Button("Favorites")
self["key_green"] = Button("Preview")
self["key_yellow"] = Button("Refresh")
self["key_blue"] = Button("Filter Off")
self["currentdir"] = Label("Folder:")
self["currentmedia"] = Label("")
self["currentserver"] = Label("Server:")
self["filterstatus"] = Label("Filter: On")
self.curfavfolder = -1
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
#iPlayableService.evStart: self.doEofInternal,
iPlayableService.evEnd: self.StopPlayback,
iPlayableService.evEOF: self.StopPlayback,
iPlayableService.evStopped: self.StopPlayback
})
self["actions"] = ActionMap(["WizardActions", "InfobarActions", "MovieSelectionActions", "MenuActions", "ShortcutActions", "MoviePlayerActions", "EPGSelectActions"],
{
"back": self.Exit,
"red": self.JumpToFavs,
"green": self.showPreview,
"yellow": self.update,
"blue": self.keyFilter,
"up": self.up,
"down": self.down,
"left": self.left,
"right": self.right,
"ok": self.ok,
"menu": self.KeyMenu,
"nextBouquet": self.NextFavFolder,
"prevBouquet": self.PrevFavFolder,
"showMovies": self.visibility,
"leavePlayer": self.StopPlayback
}, -1)
self.currentList = None
self.playlistIds = []
self.isVisible = True
self.switchToFileList()
self.onClose.append(self.__onClose)
self.onShown.append(self.__onShown)
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, \
InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, InfoBarSleepTimer, InfoBarOpenOnTopHelper, \
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,
enigma.iPlayableService.evUpdatedInfo: self.__infoChanged
})
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):
Screen.__init__(self, session)
if config.usage.show_infobar_lite.value and (config.skin.primary_skin.value.startswith('Darkness/')):
self.skinName = "InfoBarLite"
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.openSleepTimer, _("Show the Sleep Timer...")),
"openPowerTimerList": (self.openPowerTimerList, _("Show the Power 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...")),
"showInformation": (self.showInformation, _("Show Information...")),
"showFormat": (self.showFormat, _("Show Format Setup...")),
"showPluginBrowser": (self.showPluginBrowser, _("Show the plugins...")),
"showBoxPortal": (self.showBoxPortal, _("Show Box Portal...")),
"openSimpleUnmount": (self.openSimpleUnmount, _("Simple umounter mass storage device.")),
}, 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, InfoBarESIpanel, InfoBarResolutionSelection, InfoBarVmodeButton, \
InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, InfoBarAspectSelection, InfoBarBuffer, \
InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, \
InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, InfoBarZoom, InfoBarSleepTimer, InfoBarOpenOnTopHelper, InfoBarHandleBsod, \
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):
self.session = session
self.onClose = []
print('[hs9510VFD] Start')
self.tuned = False
self.play = False
self.record = False
self.timeshift = False
self.standby = False
self.usb = 0
self.dolbyAvailable = False
self.mp3Available = False
self.DTSAvailable = False
self.timer = eTimer()
self.timer.callback.append(self.timerEvent)
self.timer.start(60000, False) # start one minute timer
Console().ePopen("fp_control -i 29 0")
Console().ePopen("fp_control -l 0 0")
global DisplayType
print('[hs9510VFD] Hardware displaytype:', DisplayType)
print('[hs9510VFD] VFD displaytype :', DisplayTypevfd)
if DisplayType == 7:
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUpdatedInfo: self.UpdatedInfo,
iPlayableService.evUpdatedEventInfo:
self.__evUpdatedEventInfo,
iPlayableService.evVideoSizeChanged:
self.__evVideoSizeChanged,
iPlayableService.evSeekableStatusChanged:
self.__evSeekableStatusChanged,
iPlayableService.evTunedIn: self.__evTunedIn,
iPlayableService.evTuneFailed: self.__evTuneFailed,
iPlayableService.evStart: self.__evStart
})
config.misc.standbyCounter.addNotifier(self.onEnterStandby,
initial_call=False)
session.nav.record_event.append(self.gotRecordEvent)
try:
from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
hotplugNotifier.append(self.hotplugCB)
except:
pass
self.dir = None
self.mount = None
self.firstmount = -1
global hddUsed
hddUsed = -1
self.SetMount()
if self.mount:
self.firstmount = self.mount
if self.standby == False:
self.displayHddUsed()
else:
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.writeName,
})
print('[hs9510VFD] Set text scrolling option')
if config.plugins.vfdicon.textscroll.value is not None:
evfd.getInstance().vfd_set_SCROLL(
int(config.plugins.vfdicon.textscroll.value))
else:
evfd.getInstance().vfd_set_SCROLL(1)
print("[hs9510VFD] Set text centering option")
if config.plugins.vfdicon.textcenter.value == "1":
evfd.getInstance().vfd_set_CENTER(True)
else:
evfd.getInstance().vfd_set_CENTER(False)
print('[hs9510VFD] End initialisation')
def __init__(self, session):
Screen.__init__(self, session)
self.session = session
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evStart: self.__evStart
})
def __init__(self,
session,
service,
backend,
start=None,
lastservice=None):
self.backend = backend
self.startNewServiceOnPlay = False
self.start = start
self.service = service
self.session = session
self.useProxy = False
self.url = self.service.getPath()
self.proxyReady = False
self.proxyError = False
self['useProxy'] = Boolean(False)
self['premiumUser'] = Boolean(True)
self.azBoxLastService = None
self.proxyCaching = False
self.alreadyUsedTsServiceAsBackup = False
print '[AirPlayMoviePlayer] MoviePlayer play url: ', self.url
if self.url[:7] == 'http://' or self.url[:8] == 'https://':
print '[AirPlayMoviePlayer] found http(s) link'
if self.checkProxyUsable(
) and config.plugins.airplayer.useProxyIfPossible.value:
print '[AirPlayMoviePlayer] using proxy'
self.service = None
self.startNewServiceOnPlay = True
self.proxyCaching = True
self.useProxy = True
self['useProxy'] = Boolean(True)
if self.backend.ENIGMA_SERVICE_ID == self.backend.ENIGMA_SERVICEAZ_ID:
self.azBoxLastService = lastservice or self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
open('/proc/player', 'w').write('0')
open('/proc/player', 'w').write('2')
MoviePlayer.__init__(self, session, self.service)
if self.backend.ENIGMA_SERVICE_ID == self.backend.ENIGMA_SERVICEAZ_ID:
self.lastservice = self.azBoxLastService
backend.MovieWindow = self
self.skinName = 'AirPlayerMoviePlayer'
if lastservice is not None:
self.lastservice = lastservice
self.bufferslider = Slider(0, 100)
self.bufferslider.setValue(0)
self['bufferslider'] = self.bufferslider
self['bufferslider'].setValue(0)
self['label_speed'] = StaticText('DL-Speed: N/A')
self['label_cache'] = StaticText('Cache: N/A')
self.endReached = False
self.localCache = False
self.dlactive = False
self.localsize = 0
self.proxyProcess = None
self.liveStream = False
self.m3u8Stream = False
self['actions'] = ActionMap(
['InfobarInstantRecord', 'MoviePlayerActions'], {
'instantRecord': self.keyStartLocalCache,
'leavePlayer': self.leavePlayer
}, -2)
if config.plugins.airplayer.setSeekOnStart.value and self.start != None and self.start > 0.0:
start_new_thread(self.seekWatcher, (self, ))
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUser + 10: self.__evAudioDecodeError,
iPlayableService.evUser + 11: self.__evVideoDecodeError,
iPlayableService.evUser + 12: self.__evPluginError,
iPlayableService.evEOF: self.__evEOF
})
if self.useProxy:
start_new_thread(self.proxyWatcher, (self, ))
self.backend.updateEventInfo('loading')
self.onHide.append(self.lockInfoBar)
self.proxyCaching = True
self.checkProxyTimer = eTimer()
self.checkProxyTimer.timeout.get().append(self.checkProxyStatus)
self.checkProxyTimer.start(500, True)
return
def __init__(self, session):
Screen.__init__(self, session)
self["actions"] = NumberActionMap(
["NumberActions", "RassInteractiveActions"], {
"exit": self.close,
"0": lambda x: self.numPressed(0),
"1": lambda x: self.numPressed(1),
"2": lambda x: self.numPressed(2),
"3": lambda x: self.numPressed(3),
"4": lambda x: self.numPressed(4),
"5": lambda x: self.numPressed(5),
"6": lambda x: self.numPressed(6),
"7": lambda x: self.numPressed(7),
"8": lambda x: self.numPressed(8),
"9": lambda x: self.numPressed(9),
"nextPage": self.nextPage,
"prevPage": self.prevPage,
"nextSubPage": self.nextSubPage,
"prevSubPage": self.prevSubPage
})
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUpdatedRassInteractivePicMask:
self.recvRassInteractivePicMaskChanged
})
self["subpages_1"] = Pixmap()
self["subpages_2"] = Pixmap()
self["subpages_3"] = Pixmap()
self["subpages_4"] = Pixmap()
self["subpages_5"] = Pixmap()
self["subpages_6"] = Pixmap()
self["subpages_7"] = Pixmap()
self["subpages_8"] = Pixmap()
self["subpages_9"] = Pixmap()
self["Marker"] = Label(">")
self.subpage = {
1: self["subpages_1"],
2: self["subpages_2"],
3: self["subpages_3"],
4: self["subpages_4"],
5: self["subpages_5"],
6: self["subpages_6"],
7: self["subpages_7"],
8: self["subpages_8"],
9: self["subpages_9"]
}
self.subpage_png = {
1:
LoadPixmap(
resolveFilename(SCOPE_CURRENT_SKIN,
"skin_default/icons/rass_page1.png")),
2:
LoadPixmap(
resolveFilename(SCOPE_CURRENT_SKIN,
"skin_default/icons/rass_page2.png")),
3:
LoadPixmap(
resolveFilename(SCOPE_CURRENT_SKIN,
"skin_default/icons/rass_page3.png")),
4:
LoadPixmap(
resolveFilename(SCOPE_CURRENT_SKIN,
"skin_default/icons/rass_page4.png"))
}
self.current_page = 0
self.current_subpage = 0
self.showRassPage(0, 0)
self.onLayoutFinish.append(self.updateSubPagePixmaps)
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,
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, args = None):
Screen.__init__(self, session)
InfoBarAudioSelection.__init__(self)
InfoBarAspectSelection.__init__(self)
InfoBarCueSheetSupport.__init__(self, actionmap = "MediaPlayerCueSheetActions")
InfoBarNotifications.__init__(self)
InfoBarBase.__init__(self)
InfoBarScreenSaver.__init__(self)
InfoBarSubtitleSupport.__init__(self)
HelpableScreen.__init__(self)
self.summary = None
self.oldService = self.session.nav.getCurrentlyPlayingServiceOrGroup()
self.session.nav.stopService()
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 as ex:
print("[MediaPlayer] No hotplug support", ex)
class MoviePlayerActionMap(NumberActionMap):
def __init__(self, player, contexts = [ ], actions = { }, prio=0):
NumberActionMap.__init__(self, contexts, actions, prio)
self.player = player
def action(self, contexts, action):
self.player.show()
return NumberActionMap.action(self, contexts, action)
self["OkCancelActions"] = HelpableActionMap(self, ["OkCancelActions"],
{
"ok": (self.ok, _("Add file to playlist")),
"cancel": (self.exit, _("Exit mediaplayer")),
}, -2)
self["MediaPlayerActions"] = HelpableActionMap(self, ["MediaPlayerActions"],
{
"play": (self.xplayEntry, _("Play entry")),
"pause": (self.pauseEntry, _("Pause")),
"stop": (self.stopEntry, _("Stop entry")),
"previous": (self.previousMarkOrEntry, _("Play from previous mark or playlist entry")),
"next": (self.nextMarkOrEntry, _("Play from next mark or playlist entry")),
"menu": (self.showMenu, _("Menu")),
"skipListbegin": (self.skip_listbegin, _("Jump to beginning of list")),
"skipListend": (self.skip_listend, _("Jump to end of list")),
"prevBouquet": (self.prevBouquet, self.prevBouquetHelpText),
"nextBouquet": (self.nextBouquet, self.nextBouquetHelptext),
"delete": (self.deletePlaylistEntry, _("Delete playlist entry")),
"shift_stop": (self.clear_playlist, _("Clear playlist")),
"shift_record": (self.playlist.PlayListShuffle, _("Shuffle playlist")),
"subtitles": (self.subtitleSelection, _("Subtitle selection")),
}, -2)
self["InfobarEPGActions"] = HelpableActionMap(self, ["InfobarEPGActions"],
{
"showEventInfo": (self.showEventInformation, _("show event details")),
})
self["actions"] = MoviePlayerActionMap(self, ["DirectionActions"],
{
"right": self.rightDown,
"rightRepeated": self.doNothing,
"rightUp": self.rightUp,
"left": self.leftDown,
"leftRepeated": self.doNothing,
"leftUp": self.leftUp,
"up": self.up,
"upRepeated": self.up,
"upUp": self.doNothing,
"down": self.down,
"downRepeated": self.down,
"downUp": self.doNothing,
}, -2)
InfoBarSeek.__init__(self, actionmap = "MediaPlayerSeekActions")
self.mediaPlayerInfoBar = self.session.instantiateDialog(MediaPlayerInfoBar)
self.onClose.append(self.delMPTimer)
self.onClose.append(self.__onClose)
self.onShow.append(self.timerHideMediaPlayerInfoBar)
self.righttimer = False
self.rightKeyTimer = eTimer()
self.rightKeyTimer.callback.append(self.rightTimerFire)
self.lefttimer = False
self.leftKeyTimer = eTimer()
self.leftKeyTimer.callback.append(self.leftTimerFire)
self.hideMediaPlayerInfoBar = eTimer()
self.hideMediaPlayerInfoBar.callback.append(self.timerHideMediaPlayerInfoBar)
self.currList = "filelist"
self.isAudioCD = False
self.ext = None
self.AudioCD_albuminfo = {}
self.cdAudioTrackFiles = []
self.onShown.append(self.applySettings)
self.playlistIOInternal = PlaylistIOInternal()
list = self.playlistIOInternal.open(resolveFilename(SCOPE_CONFIG, "playlist.e2pls"))
if list:
for x in list:
self.playlist.addFile(x.ref)
self.playlist.updateList()
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
iPlayableService.evUser+10: self.__evAudioDecodeError,
iPlayableService.evUser+11: self.__evVideoDecodeError,
iPlayableService.evUser+12: self.__evPluginError,
iPlayableService.evUser+13: self["coverArt"].embeddedCoverArt
})
self.servicelist = None
self.pipZapAvailable = False
if InfoBar.instance is not None:
self.servicelist = InfoBar.instance.servicelist
if self.servicelist and hasattr(self.servicelist, 'dopipzap'):
self.pipZapAvailable = SystemInfo.get("NumVideoDecoders", 1) > 1
def __init__(self, session):
Screen.__init__(self, session)
self['actions'] = NumberActionMap(
['NumberActions', 'RassInteractiveActions'], {
'exit': self.close,
'0': lambda x: self.numPressed(0),
'1': lambda x: self.numPressed(1),
'2': lambda x: self.numPressed(2),
'3': lambda x: self.numPressed(3),
'4': lambda x: self.numPressed(4),
'5': lambda x: self.numPressed(5),
'6': lambda x: self.numPressed(6),
'7': lambda x: self.numPressed(7),
'8': lambda x: self.numPressed(8),
'9': lambda x: self.numPressed(9),
'nextPage': self.nextPage,
'prevPage': self.prevPage,
'nextSubPage': self.nextSubPage,
'prevSubPage': self.prevSubPage
})
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUpdatedRassInteractivePicMask:
self.recvRassInteractivePicMaskChanged
})
self['subpages_1'] = Pixmap()
self['subpages_2'] = Pixmap()
self['subpages_3'] = Pixmap()
self['subpages_4'] = Pixmap()
self['subpages_5'] = Pixmap()
self['subpages_6'] = Pixmap()
self['subpages_7'] = Pixmap()
self['subpages_8'] = Pixmap()
self['subpages_9'] = Pixmap()
self['Marker'] = Label('>')
self.subpage = {
1: self['subpages_1'],
2: self['subpages_2'],
3: self['subpages_3'],
4: self['subpages_4'],
5: self['subpages_5'],
6: self['subpages_6'],
7: self['subpages_7'],
8: self['subpages_8'],
9: self['subpages_9']
}
self.subpage_png = {
1:
LoadPixmap(
resolveFilename(SCOPE_ACTIVE_SKIN, 'icons/rass_page1.png')),
2:
LoadPixmap(
resolveFilename(SCOPE_ACTIVE_SKIN, 'icons/rass_page2.png')),
3:
LoadPixmap(
resolveFilename(SCOPE_ACTIVE_SKIN, 'icons/rass_page3.png')),
4:
LoadPixmap(
resolveFilename(SCOPE_ACTIVE_SKIN, 'icons/rass_page4.png'))
}
self.current_page = 0
self.current_subpage = 0
self.showRassPage(0, 0)
self.onLayoutFinish.append(self.updateSubPagePixmaps)
def __init__(self, session, mrl, title, currentList, contextMenuEntries,
infoCallback, name):
Screen.__init__(self, session)
InfoBarNotifications.__init__(self)
self.contextMenuEntries = contextMenuEntries
self.infoCallback = infoCallback
self.name = name
self.skinName = "MoviePlayer"
self.session = session
self.service = eServiceReference(4097, 0, mrl)
self.service.setName(title)
self.currentList = currentList
self.infoCallback = infoCallback
self.screen_timeout = 5000
class DirectYouTubePlayerActionMap(ActionMap):
def __init__(self, player, contexts=[], actions={}, prio=0):
ActionMap.__init__(self, contexts, actions, prio)
self.player = player
def action(self, contexts, action):
if action[:5] == "seek:":
time = int(action[5:])
self.player.seekRelative(time * 90000)
return 1
elif action[:8] == "seekdef:":
key = int(action[8:])
time = [
-config.seek.selfdefined_13.value, False,
config.seek.selfdefined_13.value,
-config.seek.selfdefined_46.value, False,
config.seek.selfdefined_46.value,
-config.seek.selfdefined_79.value, False,
config.seek.selfdefined_79.value
][key - 1]
self.player.seekRelative(time * 90000)
return 1
else:
return ActionMap.action(self, contexts, action)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evSeekableStatusChanged:
self.__seekableStatusChanged,
iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evEOF: self.__evEOF
})
self["actions"] = DirectYouTubePlayerActionMap(
self,
[
"OkCancelActions", "TvRadioActions", "InfobarSeekActions",
"MediaPlayerActions", "YouTubePlayerScreenActions"
],
{
"ok": self.ok,
"cancel": self.close,
"keyTV": self.close,
"pauseService": self.playpauseService,
"unPauseService": self.playpauseService,
"play": self.play,
# "seekFwd": self.seekFwd,
# "seekBack": self.seekBack,
# "seekFwdDown": self.seekFwd,
# "seekBackDown": self.seekBack,
# "seekFwdManual": self.seekManual,
# "seekBackManual": self.seekManual,
"next": self.playNextFile,
"previous": self.playPrevFile,
"menu": self.openContextMenu,
"info": self.showVideoInfo,
},
-2)
self.oldservice = self.session.screen["CurrentService"]
self.oldNavService = session.nav.getCurrentlyPlayingServiceReference()
self.hidetimer = eTimer()
self.hidetimer.timeout.get().append(self.ok)
self.returning = False
self.state = self.STATE_PLAYING
self.lastseekstate = self.STATE_PLAYING
self.onPlayStateChanged = []
self.__seekableStatusChanged()
self.onClose.append(self.__onClose)
self.play()
def __init__(self, session, server, currentList):
Screen.__init__(self, session)
InfoBarNotifications.__init__(self)
InfoBarAudioSelection.__init__(self)
InfoBarSubtitleSupport.__init__(self)
self.server = server
self.seek_time = 600
self.currentList = currentList
self.skinName = "MoviePlayer"
self.state = self.STATE_IDLE
self.oldservice = self.session.screen["CurrentService"]
self.oldNavService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
self.vlcservice = VlcService(self)
self.session.screen["CurrentService"] = self.vlcservice
self.hidetimer = eTimer()
self.hidetimer.timeout.get().append(self.ok)
self.onClose.append(self.__onClose)
class VlcPlayerActionMap(ActionMap):
def __init__(self, player, contexts=[], actions={}, prio=0):
ActionMap.__init__(self, contexts, actions, prio)
self.player = player
def action(self, contexts, action):
if action[:5] == "seek:":
time = int(action[5:])
self.player.seekRelative(time)
return 1
elif action[:8] == "seekdef:":
key = int(action[8:])
time = [
-config.seek.selfdefined_13.value, False,
config.seek.selfdefined_13.value,
-config.seek.selfdefined_46.value, False,
config.seek.selfdefined_46.value,
-config.seek.selfdefined_79.value, False,
config.seek.selfdefined_79.value
][key - 1]
self.player.seekRelative(time)
return 1
else:
return ActionMap.action(self, contexts, action)
self["actions"] = VlcPlayerActionMap(
self, [
"OkCancelActions", "TvRadioActions", "InfobarSeekActions",
"MediaPlayerActions", "ChannelSelectEPGActions"
], {
"ok": self.ok,
"cancel": self.stop,
"keyTV": self.stop,
"stop": self.stop,
"pauseService": self.pause,
"playpauseService": self.pause,
"unPauseService": self.play,
"play": self.play,
"seekFwd": self.seekFwd,
"seekBack": self.seekBack,
"seekFwdDown": self.seekFwd,
"seekBackDown": self.seekBack,
"seekFwdManual": self.seekManual,
"seekBackManual": self.seekManual,
"next": self.playNextFile,
"previous": self.playPrevFile,
"menu": self.openVCS,
"showEPGList": self.choiceJumping,
"subtitles": self.subtitleSelection
}, -2)
print("[VLC] evEOF=%d" % iPlayableService.evEOF)
self.__event_tracker = ServiceEventTracker(screen=self,
eventmap={
iPlayableService.evEOF:
self.__evEOF,
iPlayableService.evSOF:
self.__evSOF
})
def __init__(self, session):
Screen.__init__(self, session)
self.skinName = config.usage.show_infobar_lite.value
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, 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, 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
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, 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,
openmovie,
opensubtitle,
rootID,
LastPlayedService,
URLlinkName='',
movieTitle='',
LastPosition=0):
self.session = session
self.statusScreen = self.session.instantiateDialog(StatusScreen)
# #end subsupports stuff
self.conditionalNotVisible = []
self.URLlinkName = URLlinkName
self.frameon = 1 / 24
self.seeksubtitle = 0
self.resume_point = 0
self.nrsubtitle = 0
self.statesubtitle = self.HIDDENSUBTITLE
self.subtitles_enabled = False
self.selected_subtitle = False
self.stateplay = ''
self.stateinfo = self.VISIBLE
self.openmovie = openmovie
if movieTitle == '':
self.movieTitle = getNameWithoutExtension(
path.basename(self.openmovie))
#printDEBUG(self.movieTitle)
else:
self.movieTitle = movieTitle
self.opensubtitle = ''
self.rootID = int(rootID)
self.LastPlayedService = LastPlayedService
self.subtitle = []
self.fontpos = 540
self.fontsize = 60
self.aspectratiomode = '0'
self.SubtitleLineHeight = 66
self.osdPosX = 0
self.osdPosY = 0
self.fonttype_nr = 0
self.fontcolor_nr = 0
self.fontbackground_nr = 0
self.fontBackgroundState = 1
self.loadfont()
self.loadcolor()
self.loadBackgroundColor()
self.loadconfig()
if self.opensubtitle == '':
self.enablesubtitle = False
else:
self.enablesubtitle = True
isHD = False
isWideScreen = False
isDolby = False
self.skin = """
<screen name="AdvancedFreePlayer" position="0,0" size="1280,720" zPosition="-2" title="InfoBar" backgroundColor="transparent" flags="wfNoBorder">
<!-- SubTitles -->
<widget name="afpSubtitles" position="0,0" size="1,1" valign="center" halign="center" font="Regular;60" backgroundColor="#ff000000" transparent="0" />
</screen>"""
Screen.__init__(self, session)
self['afpSubtitles'] = Label()
self['actions'] = ActionMap(['AdvancedFreePlayer'], { # "ToggleSubtitles": self.ToggleSubtitles,
'ToggleInfobar': self.ToggleInfobar,
'HelpScreen': self.HelpScreen,
'SelectAspect': self.aspectChange,
'ExitPlayer': self.ExitPlayer,
'MoveSubsUp': self.MoveSubsUp,
'MoveSubsDown': self.MoveSubsDown,
'SetSmallerFont': self.SetSmallerFont,
'SetBiggerFont': self.SetBiggerFont,
'pause': self.pause,
'play': self.play,
'FastF30s': self.FastF30s,
'FastF120s': self.FastF120s,
'FastF300s': self.FastF300s,
'BackF30s': self.BackF30s,
'BackF120s': self.BackF120s,
'BackF300s': self.BackF300s,
'toggleFontBackground': self.toggleFontBackground,
'SeekUpSubtitles': self.subsDelayInc,
'SeekDownSubtitles': self.subsDelayDec,
'togglePause': self.togglePause,
'ToggleFont': self.ToggleFont,
'refreshSubs': self.refreshSubs,
'SelectAudio': self.SelectAudio,
'SelectSubtitles': self.SelectSubtitles,
}, -2)
self.onShown.append(self.__LayoutFinish)
InfoBarBase.__init__(self,
steal_current_service=True) # #subsupport....
if subs == True: # #susbsupport
initSubsSettings()
SubsSupport.__init__(self, embeddedSupport=True, searchSupport=True)
self.subs = subs
InfoBarSeek.__init__(
self, actionmap='AdvancedFreePlayerSeekActions') # #subsupport
self.onClose.append(self.__onClose)
if self.LastPlayedService is None:
self.LastPlayedService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.session.nav.stopService()
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evStart: self.resumeLastPlayback}
) # iPlayableService.evSeekableStatusChanged: self.__seekableStatusChanged,
def __init__(self, session, filelist, index, path, startslide):
self.textcolor = config.plugins.mc_pp.textcolor.value
self.bgcolor = config.plugins.mc_pp.bgcolor.value
space = config.plugins.mc_pp.framesize.value
size_w = getDesktop(0).size().width()
size_h = getDesktop(0).size().height()
self.skin = "<screen position=\"0,0\" size=\"" + str(
size_w
) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
<eLabel position=\"0,0\" zPosition=\"0\" size=\"" + str(size_w) + "," + str(
size_h
) + "\" backgroundColor=\"" + self.bgcolor + "\" /><widget name=\"pic\" position=\"" + str(
space) + "," + str(space) + "\" size=\"" + str(
size_w - (space * 2)) + "," + str(
size_h - (space * 2)
) + "\" zPosition=\"1\" alphatest=\"on\" /> \
<widget name=\"point\" position=\"" + str(space + 5) + "," + str(
space + 2
) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"skin_default/icons/record.png\" alphatest=\"on\" /> \
<widget name=\"play_icon\" position=\"" + str(space + 25) + "," + str(
space + 2
) + "\" size=\"20,20\" zPosition=\"2\" pixmap=\"skin_default/icons/ico_mp_play.png\" alphatest=\"on\" /> \
<widget name=\"file\" position=\"" + str(space + 45) + "," + str(
space
) + "\" size=\"" + str(
size_w - (space * 2) - 50
) + ",25\" font=\"Regular;20\" halign=\"left\" foregroundColor=\"" + self.textcolor + "\" zPosition=\"2\" noWrap=\"1\" transparent=\"1\" /></screen>"
Screen.__init__(self, session)
InfoBarBase.__init__(self)
InfoBarSeek.__init__(self, actionmap="MediaPlayerSeekActions")
self["actions"] = ActionMap(
[
"OkCancelActions", "ColorActions", "DirectionActions",
"MovieSelectionActions"
], {
"cancel": self.Exit,
"green": self.PlayPause,
"yellow": self.PlayPause,
"blue": self.nextPic,
"red": self.prevPic,
"left": self.prevPic,
"right": self.nextPic,
"showEventInfo": self.StartExif,
}, -1)
self["point"] = Pixmap()
self["pic"] = Pixmap()
self["play_icon"] = Pixmap()
self["file"] = Label(_("please wait, loading picture..."))
self.old_index = 0
self.filelist = []
self.lastindex = index
self.currPic = []
self.shownow = True
self.dirlistcount = 0
for x in filelist:
if len(filelist[0]) == 3: #orig. filelist
if x[0][1] == False:
self.filelist.append(path + x[0][0])
else:
self.dirlistcount += 1
else: # thumbnaillist
self.filelist.append(x[T_FULL])
self.maxentry = len(self.filelist) - 1
self.index = index - self.dirlistcount
if self.index < 0:
self.index = 0
self.picload = ePicLoad()
self.picload.PictureData.get().append(self.finish_decode)
self.slideTimer = eTimer()
self.slideTimer.callback.append(self.slidePic)
if self.maxentry >= 0:
self.onLayoutFinish.append(self.setPicloadConf)
self.__event_tracker = ServiceEventTracker(screen=self,
eventmap={
iPlayableService.evEOF:
self.doEOF,
})
if startslide == True:
self.PlayPause()
if config.plugins.mc_pp.musicenable.value == True and config.plugins.mc_pp.music.value != "none":
if pathExists(config.plugins.mc_pp.music.value):
self.session.nav.playService(
eServiceReference(4097, 0,
config.plugins.mc_pp.music.value))
def __init__(self, session, playlist):
PlaylistPlayer.__init__(self, session, "audio", MediaCore.TYPE_AUDIO)
InfoBarNotifications.__init__(self)
self._playlist = None
self._initPlaylist(
config.plugins.mediacenter.audio.last_playlist_id.value)
self.seekState = self.SEEK_STATE_IDLE
self._repeat = Playlist.REPEAT_NONE
self._browser = None
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["red"] = Label(_("Remove"))
self["green"] = Label(_("Add"))
self["yellow"] = Label(_("Shuffle - Off"))
self["blue"] = Label(_("Repeat - None"))
self._summary_list = StaticText("")
self["summary_list"] = self._summary_list
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUpdatedInfo: self._evUpdatedInfo,
iPlayableService.evEOF: self._evEOF,
iPlayableService.evUser + 10: self._evAudioDecodeError,
iPlayableService.evUser + 11: self._evVideoDecodeError,
iPlayableService.evUser + 12: self._evPluginError,
iPlayableService.evUser + 13: self["coverArt"].embeddedCoverArt
})
self["MediaCenterActions"] = HelpableActionMap(
self, "MediaCenterActions", {
"menu": (self._showMenu, _("Open Menu")),
"ok": (self.play, _("Play Selected Entry")),
"cancel": (self._close, _("Close MediaCenter Audioplayer")),
"red": (self._removeSelectedPlaylistEntry,
_("Remove Selected Entry From Playlist")),
"green": (self.editPlaylist, _("Add file(s) to Playlist")),
"yellow": (self._toggleShuffle, _("Toggle Shuffle")),
"blue": (self._toggleRepeat,
_("Toggle Repeat-Modes (None / All / Single)")),
"playpause": (self.playpause, _("Play/Pause")),
"stop": (self.stop, _("Stop Playback")),
"next": (self.playNext, _("Play Next Entry")),
"previous": (self.playPrev, _("Play Previous Entry")),
"moveUp":
self._moveUp,
"moveDown":
self._moveDown,
"pageUp":
self._pageUp,
"pageDown":
self._pageDown,
"channelUp":
(self._moveSelectedUp, _("Move selected item up")),
"channelDown":
(self._moveSelectedDown, _("Move selected item down")),
}, -2)
if playlist != None:
self.addAllToPlaylist(playlist)
def __init__(self, session, infobar=None, page=PAGE_AUDIO):
Screen.__init__(self, session)
self["streams"] = List([])
self["key_red"] = Boolean(False)
self["key_green"] = Boolean(False)
self["key_yellow"] = Boolean(True)
self["key_blue"] = Boolean(False)
self["key_menu"] = Boolean(False)
self["help_label"] = Label()
ConfigListScreen.__init__(self, [])
self.infobar = infobar or self.session.infobar
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evSubtitleListChanged:
self.__subtitleListChanged,
iPlayableService.evAudioListChanged: self.__audioListChanged,
iPlayableService.evUpdatedInfo: self.__audioListChanged,
iPlayableService.evUpdatedEventInfo: self.__audioListChanged
})
self.cached_subtitle_checked = False
self.plugincallerdict = {}
self["actions"] = NumberActionMap(
[
"ColorActions", "SetupActions", "DirectionActions",
"MenuActions", "InfobarAudioSelectionActions"
], {
"red": self.keyRed,
"green": self.keyGreen,
"yellow": self.keyYellow,
"blue": self.keyBlue,
"menu": self.keyMenu,
"ok": self.keyOk,
"cancel": self.cancel,
"audioSelection": self.cancel,
"up": self.keyUp,
"down": self.keyDown,
"previousSection": self.enablePrevious,
"nextSection": self.enableNext,
"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,
"upUp": self.doNothing,
"downUp": self.doNothing,
"leftUp": self.doNothing,
"rightUp": self.doNothing
}, -2)
self.settings = ConfigSubsection()
choicelist = [(PAGE_AUDIO, _("Subtitles")),
(PAGE_SUBTITLES, _("audio tracks"))]
self.settings.menupage = ConfigSelection(choices=choicelist,
default=page)
self.onLayoutFinish.append(self.__layoutFinished)
def __init__(self, session):
Screen.__init__(self, session)
self['cam_info'] = Label()
self['ecm_info'] = Label()
self['netcard_info'] = Label()
self['beta_no'] = Label()
self['beta_emm'] = Label()
self['beta_ecm'] = Label()
self['irdeto_no'] = Label()
self['irdeto_emm'] = Label()
self['irdeto_ecm'] = Label()
self['seca_no'] = Label()
self['seca_emm'] = Label()
self['seca_ecm'] = Label()
self['td_no'] = Label()
self['td_emm'] = Label()
self['td_ecm'] = Label()
self['via_no'] = Label()
self['via_emm'] = Label()
self['via_ecm'] = Label()
self['nagra_no'] = Label()
self['nagra_emm'] = Label()
self['nagra_ecm'] = Label()
self['cw_no'] = Label()
self['cw_emm'] = Label()
self['cw_ecm'] = Label()
self['nds_no'] = Label()
self['nds_emm'] = Label()
self['nds_ecm'] = Label()
self['conax_no'] = Label()
self['conax_emm'] = Label()
self['conax_ecm'] = Label()
self['biss_no'] = Label()
self['biss_emm'] = Label()
self['biss_ecm'] = Label()
self['bul_no'] = Label()
self['bul_emm'] = Label()
self['bul_ecm'] = Label()
self['dre_no'] = Label()
self['dre_emm'] = Label()
self['dre_ecm'] = Label()
self['pv_no'] = Label()
self['pv_emm'] = Label()
self['pv_ecm'] = Label()
self['button_fta'] = Label()
self['button_card'] = Label()
self['button_emu'] = Label()
self['button_cex'] = Label()
self['button_spider'] = Label()
self['nfreq_info'] = Label()
self['orbital_pos'] = Label()
self['Universe'] = Label()
self.my_timer = eTimer()
self.my_timer.timeout.get().append(self.__updateEmuInfo)
self.my_timer_active = 0
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.__start,
iPlayableService.evUpdatedInfo: self.__start
})
self.onShow.append(self.__start)
self.onHide.append(self.__onHide)
def __init__(self, session):
Screen.__init__(self, session)
self["actions"] = HelpableActionMap(
self,
"InfobarActions", {
"showMovies":
(self.showMovies, _("Watch recordings and media...")),
"showRadio": (self.showRadio, _("Listen to the radio...")),
"showTv": (self.TvRadioToggle, self._helpTvRadioToggle()),
"openTimerList": (self.openTimerList, _("Open timer list...")),
"openSleepTimer":
(self.openSleepTimer, _("Show/add power timers...")),
"showMediaPlayer":
(self.showMediaPlayer, _("Open the media player...")),
"showPluginBrowser":
(self.showPluginBrowser, _("Open the plugins screen...")),
"showSetup":
(self.showSetup, _("Open the settings screen...")),
"showInformation":
(self.showInformation,
_("Open the system information screen...")),
"showWWW": (self.showWWW, _("Open Web browser...")),
"showLanSetup": (self.showLanSetup, _("Show LAN Setup...")),
"showFormat":
(self.showFormat, _("Display the screen format...")),
},
prio=2,
description=_("Basic functions"))
self.radioTV = 0
self.allowPiP = True
for x in (
HelpableScreen,
InfoBarBase,
InfoBarShowHide,
InfoBarNumberZap,
InfoBarChannelSelection,
InfoBarMenu,
InfoBarEPG,
InfoBarRdsDecoder,
InfoBarInstantRecord,
InfoBarAudioSelection,
InfoBarRedButton,
InfoBarTimerButton,
InfoBarUnhandledKey,
InfoBarLongKeyDetection,
InfoBarAdditionalInfo,
InfoBarNotifications,
InfoBarDish,
InfoBarSubserviceSelection,
InfoBarBuffer,
InfoBarTimeshift,
InfoBarSeek,
InfoBarCueSheetSupport,
InfoBarSummarySupport,
InfoBarTimeshiftState,
InfoBarTeletextPlugin,
InfoBarExtensions,
InfoBarPiP,
InfoBarSubtitleSupport,
InfoBarJobman,
InfoBarZoom,
InfoBarHdmi,
InfoBarPlugins,
InfoBarServiceErrorPopupSupport,
InfoBarButtonSetup,
):
x.__init__(self)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
enigma.iPlayableService.evUpdatedEventInfo:
self.__eventInfoChanged,
enigma.iPlayableService.evStart: self.__eventServiceStart
})
self["serviceNumber"] = Label()
self["serviceName"] = Label()
self["serviceName1"] = Label()
self.current_begin_time = 0
if InfoBar.instance is not None:
raise AssertionError(
"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.onShown.append(self._onShown)
def __init__(self,
session,
sref,
playlist,
playlistName,
playlistCB,
subtitles=None,
autoPlay=True,
showProtocol=False,
onStartShow=False,
repeat=False):
BaseArchivCZSKScreen.__init__(self, session)
self.onPlayService = []
self.settings = config.plugins.archivCZSK.videoPlayer
self.sref = sref
# # set default/non-default skin according to SD/HD mode
if self.settings.useDefaultSkin.getValue():
self.skinName = "MoviePlayer"
else:
HD = getDesktop(0).size().width() == 1280
if HD:
self.skinName = "ArchivCZSKMoviePlayer"
else:
self.skinName = "MoviePlayer"
# # init custom infobar (added info about download speed, buffer level..)
ArchivCZSKMoviePlayerInfobar.__init__(self)
# # custom actions for MP
self["actions"] = HelpableActionMap(
self, "ArchivCZSKMoviePlayerActions", {
"leavePlayer": (self.leavePlayer, _("leave player?")),
"toggleShow": (self.toggleShow, _("show/hide infobar")),
"audioSelection":
(self.audioSelection, _("show audio selection menu")),
"refreshSubs":
(self.refreshSubs, _("refreshing subtitles position")),
"subsDelayInc":
(self.subsDelayInc, _("increasing subtitles delay")),
"subsDelayDec":
(self.subsDelayDec, _("decreasing subtitles delay"))
}, -3)
InfoBarBase.__init__(self, steal_current_service=True)
# init of all inherited screens
for x in HelpableScreen, InfoBarShowHide, \
InfoBarSeek, InfoBarAudioSelection, InfoBarNotifications, \
InfoBarServiceNotifications, HelpableScreen, InfoBarPVRState, \
InfoBarAspectChange, InfoBarServiceErrorPopupSupport:
x.__init__(self)
# init subtitles
initSubsSettings()
SubsSupport.__init__(
self,
subsPath=subtitles,
defaultPath=config.plugins.archivCZSK.subtitlesPath.getValue(),
forceDefaultPath=True,
searchSupport=True)
SubsSupportStatus.__init__(self)
# playlist support
InfoBarPlaylist.__init__(self,
playlist,
playlistCB,
playlistName,
autoPlay=autoPlay,
onStartShow=onStartShow,
repeat=repeat,
showProtocol=showProtocol)
# to get real start of service, and for queries for video length/position
self.video = Video(session)
# # bindend some video events to functions
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evUpdatedEventInfo: self.__evUpdatedEventInfo,
iPlayableService.evUser + 10: self.__evAudioDecodeError,
iPlayableService.evUser + 11: self.__evVideoDecodeError,
iPlayableService.evUser + 12: self.__evPluginError,
})
self.statusDialog = session.instantiateDialog(StatusScreen)
self.onClose.append(self.statusDialog.doClose)
self.isStream = self.sref.getPath().find('://') != -1
self.returning = False
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")),
},-1)
else:
self["actions"] = HelpableActionMap(self, "CoolPlayerActions2",
{
"leavePlayer": (self.leavePlayer, _("Stop playback")),
},-1)
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 playStream(self, servicetype, streamurl):
self["epg_description"].setText(
glob.currentepglist[glob.currentchannelistindex][4])
self["nowchannel"].setText(
glob.currentchannelist[glob.currentchannelistindex][0])
self["nowtitle"].setText(
glob.currentepglist[glob.currentchannelistindex][3])
self["nexttitle"].setText(
glob.currentepglist[glob.currentchannelistindex][6])
self["nowtime"].setText(
glob.currentepglist[glob.currentchannelistindex][2])
self["nexttime"].setText(
glob.currentepglist[glob.currentchannelistindex][5])
self["streamcat"].setText("Live")
self["streamtype"].setText(str(servicetype))
try:
self["extension"].setText(str(os.path.splitext(streamurl)[-1]))
except:
pass
start = ''
end = ''
percent = 0
if glob.currentepglist[glob.currentchannelistindex][2] != '':
start = glob.currentepglist[glob.currentchannelistindex][2]
if glob.currentepglist[glob.currentchannelistindex][5] != '':
end = glob.currentepglist[glob.currentchannelistindex][5]
if start != '' and end != '':
self["progress"].show()
start_time = datetime.strptime(start, "%H:%M")
end_time = datetime.strptime(end, "%H:%M")
if end_time < start_time:
end_time = datetime.strptime(end,
"%H:%M") + timedelta(hours=24)
total_time = end_time - start_time
duration = 0
if total_time.total_seconds() > 0:
duration = total_time.total_seconds() / 60
now = datetime.now().strftime("%H:%M")
current_time = datetime.strptime(now, "%H:%M")
elapsed = current_time - start_time
elapsedmins = 0
if elapsed.total_seconds() > 0:
elapsedmins = elapsed.total_seconds() / 60
if duration > 0:
percent = int(elapsedmins / duration * 100)
else:
percent = 100
if percent < 0:
percent = 0
if percent > 100:
percent = 100
self["progress"].setValue(percent)
else:
self["progress"].hide()
self.downloadPicon()
self.reference = eServiceReference(int(self.servicetype), 0,
self.streamurl)
self.reference.setName(
str(glob.currentepglist[glob.currentchannelistindex][3]))
self.session.nav.stopService()
self.session.nav.playService(self.reference)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.__evStart,
iPlayableService.evSeekableStatusChanged:
self.__evSeekableStatusChanged,
iPlayableService.evEOF: self.__evEOF,
})
class MediaPlayer(Screen, InfoBarBase, InfoBarSeek, InfoBarAudioSelection,
InfoBarCueSheetSupport, InfoBarNotifications,
InfoBarSubtitleSupport, HelpableScreen):
ALLOW_SUSPEND = True
ENABLE_RESUME_SUPPORT = True
def __init__(self, session, args=None):
Screen.__init__(self, session)
InfoBarAudioSelection.__init__(self)
InfoBarCueSheetSupport.__init__(self,
actionmap="MediaPlayerCueSheetActions")
InfoBarNotifications.__init__(self)
InfoBarBase.__init__(self)
InfoBarSubtitleSupport.__init__(self)
HelpableScreen.__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
defaultDir = config.mediaplayer.defaultDir.getValue()
self.filelist = FileList(
defaultDir,
matchingPattern=
"(?i)^.*\.(mp2|mp3|ogg|ts|mts|m2ts|wav|wave|m3u|pls|e2pls|mpg|vob|avi|divx|m4v|mkv|mp4|m4a|dat|flac|flv|mov|dts)",
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 listbegin")),
"skipListend": (self.skip_listend, _("jump to listend")),
"prevBouquet":
(self.switchToPlayList, _("switch to playlist")),
"nextBouquet":
(self.switchToFileList, _("switch to filelist")),
"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.onClose.append(self.delMPTimer)
self.onClose.append(self.__onClose)
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.currList = "filelist"
self.isAudioCD = False
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
})
def __init__(self, session, infobar=None, page=PAGE_AUDIO):
Screen.__init__(self, session)
self["streams"] = List([], enableWrapAround=True)
self["key_red"] = Boolean(False)
self["key_green"] = Boolean(False)
self["key_yellow"] = Boolean(True)
self["key_blue"] = Boolean(False)
self["key_left"] = Pixmap()
self["key_right"] = Pixmap()
self["switchdescription"] = Label(
_("Switch between Audio-, Subtitlepage"))
self["summary_description"] = StaticText("")
self.protectContextMenu = True
ConfigListScreen.__init__(self, [])
self.infobar = infobar or self.session.infobar
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evUpdatedInfo: self.__updatedInfo})
self.cached_subtitle_checked = False
self.__selected_subtitle = None
self["actions"] = NumberActionMap(
[
"ColorActions", "OkCancelActions", "DirectionActions",
"MenuActions", "InfobarAudioSelectionActions",
"InfobarSubtitleSelectionActions"
], {
"red": self.keyRed,
"green": self.keyGreen,
"yellow": self.keyYellow,
"subtitleSelection": self.keyAudioSubtitle,
"audioSelection": self.keyAudioSubtitle,
"blue": self.keyBlue,
"ok": self.keyOk,
"cancel": self.cancel,
"up": self.keyUp,
"down": self.keyDown,
"volumeUp": self.volumeUp,
"volumeDown": self.volumeDown,
"volumeMute": self.volumeMute,
"menu": self.openAutoLanguageSetup,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
}, -2)
self.settings = ConfigSubsection()
choicelist = [(PAGE_AUDIO, ""), (PAGE_SUBTITLES, "")]
self.settings.menupage = ConfigSelection(choices=choicelist,
default=page)
self.onLayoutFinish.append(self.__layoutFinished)
def __init__(self, session, providers, pcallback=None, noosd=False):
if (getDesktop(0).size().width() < 800):
skin = "%s/skins/downloader_sd.xml" % os.path.dirname(
sys.modules[__name__].__file__)
self.isHD = 0
else:
skin = "%s/skins/downloader_hd.xml" % os.path.dirname(
sys.modules[__name__].__file__)
self.isHD = 1
f = open(skin, "r")
self.skin = f.read()
f.close()
Screen.__init__(self, session)
self.session = session
self["background"] = Pixmap()
self["action"] = Label(_("Starting downloader"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress"].hide()
self["actions"] = NumberActionMap(["WizardActions", "InputActions"],
{"back": self.quit}, -1)
self.__event_tracker = ServiceEventTracker(
screen=self, eventmap={
iPlayableService.evTunedIn: self.tuned,
})
self.retValue = True
self.provider_index = 0
self.status = 0
self.open = False
self.saved = False
self.tune_enabled = False
self.oldService = self.session.nav.getCurrentlyPlayingServiceReference(
)
self.config = CrossEPG_Config()
self.config.load()
self.providers = providers
self.pcallback = pcallback
self.wrapper = CrossEPG_Wrapper()
self.wrapper.addCallback(self.wrapperCallback)
self.timeout = eTimer()
self.timeout.callback.append(self.quit)
self.hideprogress = eTimer()
self.hideprogress.callback.append(self["progress"].hide)
self.pcallbacktimer = eTimer()
self.pcallbacktimer.callback.append(self.doCallback)
self.wrappertimer = eTimer()
self.wrappertimer.callback.append(self.initWrapper)
if noosd:
self.wrappertimer.start(100, 1)
else:
self.onFirstExecBegin.append(self.firstExec)
def __init__(self, session, text):
self.showsource = CfgPlTr.showsource.getValue()
if self.showsource == "yes":
size = MySD.tMyes
else:
size = MySD.tMno
self.dict = {'size': size, 'plug_loc': plugin_location}
self.skin = applySkinVars(MySD.translatorMain_skin, self.dict)
self.session = session
Screen.__init__(self, session)
if self.showsource != "yes":
self.skinName = ["translatorMainSingle", "translatorMain"]
self.text = text
self.hideflag = True
self.refresh = False
self.max = 1
self.count = 0
self.list = []
self.eventName = ''
self['flag'] = Pixmap()
self['flag2'] = Pixmap()
self['timing'] = Label('')
self['text'] = ScrollLabel('')
self['text2'] = ScrollLabel('')
self['label'] = Label('= Hide')
self['label2'] = Label('= Clear cache')
# Add the helptext for the default destination now
lang = CfgPlTr.destination.getValue()
if lang not in self.helptext:
self.helptext[lang] = DO_translation(self.helptext['en'], 'en',
lang)
AMbindings = {
'ok': self.get_text,
'cancel': self.exit,
'down': self.down,
'up': self.up,
'yellow': self.clear_cache,
'red': self.getEPG,
'green': self.showHelp,
'blue': self.hideScreen,
'contextMenu': self.config,
'bluelong': self.showHelp,
'showEventInfo': self.showHelp
}
# We need to know whether we are playing a recording as, if so, we do
# NOT want to activate the service-changing keys, nor programme text
# changes.
# We also don't need to set-up a ServiceEventTracker for a recording, as
# the even can't occur.
# The playback state is also needed for getEPG(), so save it.
# Do NOT use:
# self.session.nav.getCurrentlyPlayingServiceOrGroup().isPlayback()
# as that isPlayback() is Vix-specific. So just replicate the code here.
#
self.inPlayBack = "0:0:0:0:0:0:0:0:0" in self.My_Sref(
).toCompareString()
# Add the channel name.
wintitle = 'EPG Translator'
try:
cur_serv = self.My_Sref().getServiceName()
wintitle += " - " + cur_serv
except:
pass
self.setTitle(wintitle)
if not self.inPlayBack: # We can add in service-change keys
AMbindings.update({
'right': self.rightDown,
'left': self.leftUp,
'nextBouquet': self.zapDown,
'prevBouquet': self.zapUp
})
# Also add the event tracker for changing service for not-in-Playback
# This means we can call getEPG() *after* the service changes, even
# if there may be a user prompt related to timeshift.
#
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evTunedIn: self.__serviceTuned})
self['actions'] = ActionMap([
'OkCancelActions', 'DirectionActions', 'ChannelSelectBaseActions',
'ColorActions', 'MovieSelectionActions', 'HelpActions'
], AMbindings, -1)
self.onLayoutFinish.append(self.onLayoutFinished)
self["key_red"] = StaticText(_("Refresh EPG"))
self["key_green"] = StaticText(_("Info"))
self["key_yellow"] = StaticText(_("Clear cache"))
self["key_blue"] = StaticText(_("Hide"))
self["key_menu"] = StaticText(_("MENU"))
self["key_ok"] = StaticText(_("Translate text"))
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, dvd_device=None, dvd_filelist=[], args=None):
Screen.__init__(self, session)
InfoBarBase.__init__(self)
InfoBarCueSheetSupport.__init__(self,
actionmap="MediaPlayerCueSheetActions")
InfoBarShowHide.__init__(self)
InfoBarAudioSelection.__init__(self)
InfoBarSubtitleSupport.__init__(self)
self.subtitle_window.real_hide = self.subtitle_window.hide
self.subtitle_window.hide = self.SubtitleWindowFakeHide
InfoBarExtensions.__init__(self)
InfoBarPlugins.__init__(self)
InfoBarNotifications.__init__(self)
HelpableScreen.__init__(self)
self.save_infobar_seek_config()
self.change_infobar_seek_config()
InfoBarSeek.__init__(self)
InfoBarPVRState.__init__(self)
self.dvdScreen = self.session.instantiateDialog(DVDOverlay)
self.oldService = self.session.nav.getCurrentlyPlayingServiceReference(
)
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_audioString = None
self.last_subtitleString = None
self.last_angleTuple = None
self.totalChapters = 0
self.currentChapter = 0
self.totalTitles = 0
self.currentTitle = 0
self._subs_enabled = False
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 + 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.__osdAngleInfoAvail,
iPlayableService.evUser + 7: self.__chapterUpdated,
iPlayableService.evUser + 8: self.__titleUpdated,
iPlayableService.evUser + 9: self.__menuOpened,
iPlayableService.evUser + 10: self.__menuClosed
})
self["DVDPlayerDirectionActions"] = ActionMap(
["DirectionActions"],
{
#MENU KEY DOWN ACTIONS
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
#MENU KEY REPEATED ACTIONS
"leftRepeated": self.doNothing,
"rightRepeated": self.doNothing,
"upRepeated": self.doNothing,
"downRepeated": self.doNothing,
#MENU KEY UP ACTIONS
"leftUp": self.doNothing,
"rightUp": self.doNothing,
"upUp": self.doNothing,
"downUp": self.doNothing,
})
self["OkCancelActions"] = ActionMap(["OkCancelActions"], {
"ok": self.keyOk,
"cancel": self.keyCancel,
})
self["DVDPlayerPlaybackActions"] = HelpableActionMap(
self,
"DVDPlayerActions",
{
#PLAYER ACTIONS
"dvdMenu": (self.enterDVDMenu, _("show DVD main menu")),
"toggleInfo":
(self.toggleInfo,
_("toggle time, chapter, audio, subtitle info")),
"nextChapter":
(self.nextChapter, _("forward to the next chapter")),
"prevChapter":
(self.prevChapter, _("rewind to the previous chapter")),
"nextTitle":
(self.nextTitle, _("jump forward to the next title")),
"prevTitle":
(self.prevTitle, _("jump back to the previous title")),
"tv": (self.askLeavePlayer,
_("exit DVD player or return to file browser")),
"dvdAudioMenu":
(self.enterDVDAudioMenu, _("(show optional DVD audio menu)")),
"AudioSelection":
(self.enterAudioSelection, _("Select audio track")),
"nextAudioTrack":
(self.nextAudioTrack, _("switch to the next audio track")),
"nextSubtitleTrack":
(self.nextSubtitleTrack,
_("switch to the next subtitle language")),
"nextAngle": (self.nextAngle, _("switch to the next angle")),
"seekBeginning":
self.seekBeginning,
},
-2)
self["NumberActions"] = NumberActionMap(
["NumberActions"], {
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal,
})
self.onClose.append(self.__onClose)
from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
hotplugNotifier.append(self.hotplugCB)
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
