def __init__(self, session):
desktop_size = getDesktop(0).size()
AntiLogoDisplay.skin = "<screen name=\"AntiLogoDisplay\" position=\"0,0\" size=\"%d,%d\" flags=\"wfNoBorder\" zPosition=\"-1\" backgroundColor=\"transparent\" />" %(desktop_size.width(), desktop_size.height())
Screen.__init__(self, session)
self.session = session
self.dlgs = [ ]
self.infobars = [ ]
self.__event_tracker = ServiceEventTracker(screen = self, eventmap =
{
iPlayableService.evStart: self.__evServiceStart,
iPlayableService.evEnd: self.__evServiceEnd
})
# this would be the current infobar singleton
# it would be None most likely on sessionstart
# but we should not depend on that.
self.infobarOpened(InfoBar.instance)
InfoBarBase.connectInfoBarOpened(self.infobarOpened)
InfoBarBase.connectInfoBarClosed(self.infobarClosed)
def __init__(self, session):
self.session = session
Screen.__init__(self, session)
#associate event tracker with class methods
self.et = ServiceEventTracker(screen=self,
eventmap={
iPlayableService.evUpdatedEventInfo:
self.UpdInfo,
iPlayableService.evUpdatedInfo:
self.UpdInfo
})
#read and apply settings stored in configuration file - enigma starts...
setConfiguredSettings()
#read current mode
if config.plugins.OSD3DSetup.mode.value:
self.CurrentMode = config.plugins.OSD3DSetup.mode.value
else:
self.CurrentMode = val_auto
self.Confirming = False
AutoToggle3D.Instance = self #set instance - only one should be running
def __init__(self, session):
self.session = session
Screen.__init__(self, session)
print "[AutomaticVolumeAdjustment] Starting AutomaticVolumeAdjustment..."
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
iPlayableService.evStart: self.__evStart,
iPlayableService.evEnd: self.__evEnd
})
self.newService = False # switching flag
self.pluginStarted = False # is plugin started?
self.lastAdjustedValue = 0 # remember delta from last automatic volume up/down
self.currentVolume = 0 # only set when AC3 or DTS is available
self.enabled = False # AutomaticVolumeAdjustment enabled in setup?
self.serviceList = {} # values from config
configVA = AutomaticVolumeAdjustmentConfig()
self.initializeConfigValues(configVA, False)
self.volctrl = eDVBVolumecontrol.getInstance()
def __init__(self, session):
self.session = session
Screen.__init__(self, session)
self.__event_tracker = ServiceEventTracker(screen = self, eventmap =
{
iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
iPlayableService.evStart: self.__evStart
})
self.newService = False
self.lastmode = getmode()
assert not AutoThreeD.instance, "only one AutoThreeD instance is allowed!"
AutoThreeD.instance = self # set instance
if eDBoxLCD.getInstance().detected(): # display found
from Components.config import NoSave
config.plugins.threed.disableDisplay = ConfigYesNo(default = False)
config.plugins.threed.disableDisplay.addNotifier(toggleDisplay, initial_call = False)
from Components.config import NoSave
config.plugins.threed.toggleState = NoSave(ConfigYesNo(default = True)) # True = display on, False = display off
config.misc.standbyCounter.addNotifier(standbyCounterChanged, initial_call = False)
def __init__(self, session):
Screen.__init__(self, session)
self.DBStatusTimer = eTimer()
self.DBStatusTimer.callback.append(self.updateStatus)
self.__event_tracker = ServiceEventTracker(screen = self, eventmap =
{
iPlayableService.evUpdatedInfo: self.restartTimer,
iPlayableService.evUpdatedEventInfo: self.restartTimer
})
self.recordtimer = session.nav.RecordTimer
self.NetworkConnectionAvailable = False
self.LastTimerlistUpdate = 0
self.timerlist = ""
self.pluginlist = ""
self.onShow.append(self.restartTimer)
def __init__(self, session):
self.session = session
self.sign = 0
self.updatetime = 10000
self.blink = False
self.blinkCounter = 5
self.channelnrdelay = 10000
self.begin = int(time())
self.endkeypress = True
eActionMap.getInstance().bindAction('', -0x7FFFFFFF, self.keyPressed)
self.zaPrik = eTimer()
self.zaPrik.timeout.get().append(self.vrime)
self.zaPrik.start(1000, 1)
self.onClose = []
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evUpdatedEventInfo: self.__eventInfoChanged
})
def __init__(self, session):
self.session = session
self.onClose = [ ] # hack
self.channelList = []
# self.srefList = []
self.channelData = []
self.procData = {}
self.parseChannelDB()
srefList = self.getSrefList()
self.channelData = self.makeChannelData(srefList)
self.parseNimConfiguration()
self.writeDataProc(self.channelData)
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
iPlayableService.evStart: self.serviceStarted,
})
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.showTv, _("Show the tv player...")),
"showSubtitle": (self.showSubtitle, _("Show the Subtitle...")),
},
prio=2)
self.allowPiP = True
self.allowPiPSwap = True
for x in HelpableScreen, \
InfoBarBase, InfoBarShowHide, \
InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, \
InfoBarInstantRecord, InfoBarAudioSelection, InfoBarRedButton, InfoBarUnhandledKey, \
InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, \
InfoBarTimeshift, InfoBarSeek, InfoBarSummarySupport, InfoBarTimeshiftState, \
InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, \
InfoBarPlugins, InfoBarServiceErrorPopupSupport:
x.__init__(self)
self.helpList.append(
(self["actions"], "InfobarActions", [("showMovies",
_("view recordings..."))]))
self.helpList.append(
(self["actions"], "InfobarActions", [("showRadio",
_("hear radio..."))]))
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
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
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.showTv, _("Show the tv player...")),
"showPluginBrowser": (self.showPluginBrowser, _("Show the plugins...")),
"openTimerList": (self.openTimerList, _("Open Timerlist...")),
}, prio=2)
self["key_red"] = Label()
self["key_yellow"] = Label()
self["key_blue"] = Label()
self["key_green"] = Label()
self.allowPiP = True
for x in HelpableScreen, \
InfoBarBase, InfoBarShowHide, \
InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, \
InfoBarInstantRecord, InfoBarAudioSelection, InfoBarRedButton, InfoBarTimerButton, InfoBarUnhandledKey, InfoBarVmodeButton,\
InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, InfoBarBuffer, \
InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, \
InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, InfoBarPowersaver, \
InfoBarPlugins, InfoBarServiceErrorPopupSupport, InfoBarHDMI:
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.onShow.append(self.doButtonsCheck)
def __init__(self, session, service, lastPosition=None, bugEOFworkaround=0):
Screen.__init__(self, session)
self.skinName = "MoviePlayer"
self.__event_tracker = ServiceEventTracker(screen = self, eventmap =
{
iPlayableService.evEOF: self.__evEOF,
iPlayableService.evSOF: self.__evEOF,
})
self["actions"] = HelpableActionMap(self, "MoviePlayerActions",
{
"leavePlayer": (self.leavePlayer, _("leave movie player...")),
"leavePlayerOnExit": (self.leavePlayer, _("leave movie player...")),
}, -5)
for x in HelpableScreen, InfoBarShowHide, InfoBarSeek, InfoBarAudioSelection, InfoBarSubtitleSupport, InfoBarNotifications:
x.__init__(self)
# InfoBarServiceNotifications
self.onClose.append(self.__onClose)
self.mainTimer = eTimer()
self.mainTimer_conn = eConnectCallback(self.mainTimer.timeout, self.timerCallBack)
self.mainTimer.start(1000)
self.bugEOFworkaround = bugEOFworkaround
self.session.nav.playService(service)
if lastPosition != None and (lastPosition / 90000) > 10:
self.position = 0
self.lastPosition = lastPosition
self.doSeekToLastPosition = True
else:
self.position = 0
self.lastPosition = 0
self.doSeekToLastPosition = False
self.waitForSeekToLastPosition = 0
self.stopTimeFix = 0
self.returning = False
self.aspectratiomode = "1"
self.isClosing = False
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.showTv, _("Show the tv player...")),
# [ IQON : Zoom In/Out Key define and HarddiskSetup key : by knuth
"ZoomInOut":(self.ZoomInOut, _("Zoom In/Out TV...")),
"ZoomOff":(self.ZoomOff, _("Zoom Off...")),
"HarddiskSetup": (self.HarddiskSetup, _("Select HDD")),
# IQON : by knuth ]
}, prio=2)
self.allowPiP = True
for x in HelpableScreen, \
InfoBarBase, InfoBarShowHide, \
InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, \
InfoBarInstantRecord, InfoBarAudioSelection, InfoBarRedButton, InfoBarTimerButton, InfoBarUnhandledKey, InfoBarVmodeButton,\
InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, \
InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, \
InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, InfoBarPowersaver, \
InfoBarPlugins, InfoBarServiceErrorPopupSupport, InfoBarHDMI:
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
# [ IQON : zoom variable define : by knuth
self.zoomrate=0
self.zoomin=1
# IQON : by knuth ]
assert InfoBar.instance is None, "class InfoBar is a singleton class and just one instance of this class is allowed!"
InfoBar.instance = self
def __init__(self, session):
Screen.__init__(self, session)
self["Dishpixmap"] = BlinkingPixmapConditional()
self["Dishpixmap"].onVisibilityChange.append(
self.DishpixmapVisibilityChanged)
self["turnTime"] = Label("")
self["posFrom"] = Label("")
self["posGoto"] = Label("")
self["From"] = Label(_("From :"))
self["Goto"] = Label(_("Goto :"))
self["Tuner"] = Label(_("Tuner :"))
self["tunerName"] = Label("")
self["turnSpeed"] = Label("")
self.updateRotorSatList()
self.rotorTimer = eTimer()
self.rotorTimer.callback.append(self.updateRotorMovingState)
self.turnTimer = eTimer()
self.turnTimer.callback.append(self.turnTimerLoop)
self.timeoutTimer = eTimer()
self.timeoutTimer.callback.append(self.testIsTuned)
self.showdish = config.usage.showdish.value
config.usage.showdish.addNotifier(self.configChanged)
self.configChanged(config.usage.showdish)
self.rotor_pos = self.cur_orbpos = config.misc.lastrotorposition.value
config.misc.lastrotorposition.addNotifier(self.rotorPositionChanged)
self.turn_time = self.total_time = self.pmt_timeout = self.close_timeout = None
self.cur_polar = 0
self.__state = self.STATE_HIDDEN
self.onShow.append(self.__onShow)
self.onHide.append(self.__onHide)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evTunedIn: self.__serviceTunedIn,
})
def __init__(self, session):
Screen.__init__(self, session)
if session == None:
self.firstrun = False
else:
self.firstrun = True
self.__event_tracker = ServiceEventTracker(screen=self, eventmap=
{
#iPlayableService.evStart: self.__evStart,
iPlayableService.evVideoSizeChanged: self.VideoChanged,
iPlayableService.evVideoProgressiveChanged: self.VideoChanged,
iPlayableService.evVideoFramerateChanged: self.VideoChanged,
iPlayableService.evBuffering: self.BufferInfo,
iPlayableService.evStopped: self.BufferInfoStop
})
self.delay = False
self.bufferfull = True
self.detecttimer = eTimer()
self.detecttimer.callback.append(self.VideoChangeDetect)
def __init__(self, session, stitle=None, currentservice=None, currentindex=None):
self.skin = persianplayingscrn.skin
self.skin_path = resolveFilename(SCOPE_PLUGINS, "Extensions/PurePrestige")
Screen.__init__(self, session)
self['titel'] = Label()
self['station'] = Label()
self['leagueNumberWidget'] = Label()
self.currentindex = currentindex
self['station'].setText(stitle)
self.CurrentService = currentservice
self.currentindex = currentindex
stationscount = config.plugins.Cradio.stations_count.value
self.stationscount = stationscount
self['leagueNumberWidget'].setText('%d/%d' % (self.currentindex, self.stationscount))
self.onClose.append(self.__onClose)
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={iPlayableService.evUpdatedInfo: self.__evUpdatedInfo})
self['actions'] = ActionMap(['PiPSetupActions', 'SetupActions'], {'down': self.previousLeague,
'up': self.nextLeague,
'cancel': self.close,
'size-': self.previousLeague,
'size+': self.nextLeague}, -2)
def __init__(self, session, service):
CutListSupport.__init__(self, service)
MoviePlayer.__init__(self, session, service)
PlayerBase.__init__(self, session)
self.skinName = ["MoviePlayerExtended", "MoviePlayer"]
if config.AdvancedMovieSelection.exitkey.value and config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(self, "WizardActions",
{
"back": (self.leavePlayer, _("Leave movie player"))
})
if config.AdvancedMovieSelection.exitkey.value and not config.AdvancedMovieSelection.exitprompt.value:
self["closeactions"] = HelpableActionMap(self, "WizardActions",
{
"back": (self.close, _("Leave movie player"))
})
if config.AdvancedMovieSelection.use_original_movieplayer_summary.value == True:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evUpdatedInfo: self.__updateInfo
})
self.firstime = True
self.onExecBegin.append(self.__onExecBegin)
def __init__(self, session):
self.list = []
self.getList()
self.session = session
self.timer = eTimer()
self.timer.timeout.get().append(self.timerEvent)
self.service = None
self.onClose = [ ]
self.__event_tracker = ServiceEventTracker(screen=self,eventmap=
{
iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
iPlayableService.evUpdatedEventInfo: self.__evUpdatedEventInfo,
iPlayableService.evVideoSizeChanged: self.__evVideoSizeChanged,
iPlayableService.evSeekableStatusChanged: self.__evSeekableStatusChanged,
iPlayableService.evStart: self.__evStart,
})
session.nav.record_event.append(self.gotRecordEvent)
self.mp3Available = False
self.dolbyAvailable = False
self.tr_servicename = ""
self.old_show = ""
def __init__(self, session):
Screen.__init__(self, session)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evEnd:
self.__serviceStopped,
iPlayableService.evUpdatedRadioText:
self.RadioTextChanged,
iPlayableService.evUpdatedRtpText:
self.RtpTextChanged,
iPlayableService.evUpdatedRassInteractivePicMask:
self.RassInteractivePicMaskChanged
})
self['RadioText'] = Label()
self['RtpText'] = Label()
self['RassLogo'] = Pixmap()
self.onLayoutFinish.append(self.hideWidgets)
self.rassInteractivePossible = False
self.onRassInteractivePossibilityChanged = []
self.onText = []
def __init__(self, session):
global port
Screen.__init__(self, session)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evVideoSizeChanged: self.__evVideoSizeChanged,
iPlayableService.evVideoProgressiveChanged:
self.__evVideoProgressiveChanged,
iPlayableService.evVideoFramerateChanged:
self.__evVideoFramerateChanged,
iPlayableService.evUpdatedInfo: self.__evUpdatedInfo,
iPlayableService.evStart: self.__evStart
})
self.timer = eTimer()
self.timer.callback.append(self.determineContent)
if config.av.videoport.value in config.av.videomode:
self.lastmode = config.av.videomode[
config.av.videoport.value].value
config.av.videoport.addNotifier(self.defaultModeChanged)
config.plugins.autoresolution.enable.addNotifier(self.enableChanged,
initial_call=False)
config.plugins.autoresolution.deinterlacer.addNotifier(
self.enableChanged, initial_call=False)
config.plugins.autoresolution.deinterlacer_progressive.addNotifier(
self.enableChanged, initial_call=False)
if default:
self.setMode(default[0], False)
self.after_switch_delay = False
self.newService = False
if "720p" in config.av.videorate:
config.av.videorate["720p"].addNotifier(
self.__videorate_720p_changed,
initial_call=False,
immediate_feedback=False)
if "1080i" in config.av.videorate:
config.av.videorate["1080i"].addNotifier(
self.__videorate_1080i_changed,
initial_call=False,
immediate_feedback=False)
def __init__(self, session):
#print "CuberevoVFD initializing"
#---- CIVER start ----#
global showmenuorpanel
showmenuorpanel = False
self.showtimer = eTimer()
#---- CIVER end ----#
self.session = session
self.service = None
self.onClose = []
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evSeekableStatusChanged:
self.__evSeekableStatusChanged,
iPlayableService.evStart: self.__evStart,
})
self.Console = Console()
self.tsEnabled = False
#---- CIVER start ----#
self.timer = eTimer()
self.timer.callback.append(self.handleTimer)
self.timer.start(1000, False)
#---- CIVER end ----#
self.fanEnabled = config.plugins.CuberevoVFD.setFan.getValue()
self.ledEnabled = config.plugins.CuberevoVFD.setLed.getValue()
self.clockEnabled = config.plugins.CuberevoVFD.showClock.getValue()
# self.daylightEnabled = config.plugins.CuberevoVFD.setDaylight.getValue()
if config.plugins.CuberevoVFD.timeMode.value == "24h":
self.timeModeEnabled = 1
else:
self.timeModeEnabled = 0
if self.fanEnabled == False:
self.disableFan()
else:
self.enableFan()
if self.ledEnabled == False:
self.disableLed()
else:
self.enableLed()
def __init__(self, session):
Screen.__init__(self, session)
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...")),
"toggleTvRadio": (self.toggleTvRadio, _("Toggle the tv and the radio player...")),
"ZoomInOut": (self.ZoomInOut, _("Zoom In/Out TV...")),
"ZoomOff": (self.ZoomOff, _("Zoom Off...")),
}, prio=2)
self.radioTV = 0
self.allowPiP = True
for x in HelpableScreen, \
InfoBarBase, InfoBarShowHide, \
InfoBarNumberZap, InfoBarChannelSelection, InfoBarMenu, InfoBarEPG, InfoBarRdsDecoder, InfoBarResolutionSelection, InfoBarAspectSelection, \
InfoBarInstantRecord, InfoBarAudioSelection, InfoBarRedButton, InfoBarTimerButton, InfoBarUnhandledKey, InfoBarVmodeButton,\
InfoBarAdditionalInfo, InfoBarNotifications, InfoBarDish, InfoBarSubserviceSelection, InfoBarBuffer, \
InfoBarTimeshift, InfoBarSeek, InfoBarCueSheetSupport, InfoBarSummarySupport, InfoBarTimeshiftState, \
InfoBarTeletextPlugin, InfoBarExtensions, InfoBarPiP, InfoBarSubtitleSupport, InfoBarJobman, InfoBarZoom, InfoBarPowersaver, \
InfoBarHdmi2, 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
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
self.zoomrate = 0
self.zoomin = 1
def __init__(self):
self["ShowHideActions"] = ActionMap(["InfobarShowHideActions"], {
"toggleShow": self.OkPressed,
"hide": self.hide,
}, 1)
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evStart: self.serviceStarted,
})
self.__state = self.STATE_SHOWN
self.__locked = 0
self.hideTimer = eTimer()
try:
self.hideTimer_conn = self.hideTimer.timeout.connect(self.doTimerHide)
except:
self.hideTimer.callback.append(self.doTimerHide)
self.hideTimer.start(5000, True)
self.onShow.append(self.__onShow)
self.onHide.append(self.__onHide)
def __init__(self,
session,
sref,
videoPlayerController,
playlist,
playlistName,
playlistCB,
playAndDownload=False,
subtitles=None):
CustomVideoPlayer.__init__(self, session, sref, videoPlayerController,
playlist, playlistName, playlistCB,
playAndDownload, subtitles)
self.gstreamerSetting = self.settings
self.useBufferControl = False
self.setBufferMode(int(self.gstreamerSetting.bufferMode.getValue()))
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evBuffering: self._evUpdatedBufferInfo,
})
self.playService()
def __init__(self, session, service, lastservice):
Screen.__init__(self, session)
self.skin_path = resolveFilename(SCOPE_PLUGINS,
"Extensions/DLNABrowser")
InfoBarNotifications.__init__(self)
self.session = session
self.service = service
self.lastservice = lastservice
self["actions"] = ActionMap(
[
"OkCancelActions", "InfobarSeekActions", "MediaPlayerActions",
"MovieSelectionActions"
], {
"ok": self.doInfoAction,
"cancel": self.doExit,
"stop": self.doExit,
"playpauseService": self.playpauseService,
}, -2)
self["sidebar"] = Label(_("/"))
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evSeekableStatusChanged:
self.__seekableStatusChanged,
iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evEOF: self.__evEOF,
})
self.hidetimer = eTimer()
self.hidetimer.timeout.get().append(self.doInfoAction)
self.state = self.PLAYER_PLAYING
self.lastseekstate = self.PLAYER_PLAYING
self.__seekableStatusChanged()
self.onClose.append(self.__onClose)
self.doPlay()
def __init__(self, session):
self.skin = """
<screen name="Screensaver" position="fill" flags="wfNoBorder">
<eLabel position="fill" backgroundColor="#54000000" zPosition="0"/>
<widget name="picture" pixmap="screensaverpicture.png" position="0,0" size="150,119" alphatest="blend" transparent="1" zPosition="1"/>
</screen>"""
Screen.__init__(self, session)
self.moveLogoTimer = eTimer()
self.moveLogoTimer.callback.append(self.doMovePicture)
self.onShow.append(self.__onShow)
self.onHide.append(self.__onHide)
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evStart: self.serviceStarted
})
self["picture"] = Pixmap()
self.onLayoutFinish.append(self.layoutFinished)
def __init__(self):
for x in InfoBarShowHide, InfoBarMenu, \
InfoBarBase, InfoBarSeek, InfoBarShowMovies, \
InfoBarAudioSelection, InfoBarSimpleEventView, \
InfoBarServiceNotifications, InfoBarPVRState, \
InfoBarSubtitleSupport, \
InfoBarTeletextPlugin, InfoBarServiceErrorPopupSupport, InfoBarExtensions, InfoBarNotifications, \
InfoBarPlugins, InfoBarNumberZap:
#InfoBarPiP
#InfoBarCueSheetSupport
#InfoBarMoviePlayerSummarySupport
x.__init__(self)
# Initialize InfoBarCueSheetSupport because we cannot override __serviceStarted
#def __init__(self, actionmap = "InfobarCueSheetActions"):
actionmap = "InfobarCueSheetActions"
self["CueSheetActions"] = HelpableActionMap(
self,
actionmap, {
"jumpPreviousMark":
(self.jumpPreviousMark, _("jump to previous marked position")),
"jumpNextMark":
(self.jumpNextMark, _("jump to next marked position")),
"toggleMark": (self.toggleMark,
_("toggle a cut mark at the current position"))
},
prio=1)
self.cut_list = []
self.is_closing = False
self.resume_point = 0
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.__serviceStarted,
})
def __init__(self, session):
self.skin = Dish.skin
Screen.__init__(self, session)
self["Dishpixmap"] = BlinkingPixmapConditional()
self["Dishpixmap"].onVisibilityChange.append(
self.DishpixmapVisibilityChanged)
self["turnTime"] = Label("")
self["posFrom"] = Label("")
self["posGoto"] = Label("")
self["From"] = Label(_("From :"))
self["Goto"] = Label(_("Goto :"))
self.rotorTimer = eTimer()
self.rotorTimer.callback.append(self.updateRotorMovingState)
self.turnTimer = eTimer()
self.turnTimer.callback.append(self.turnTimerLoop)
self.showTimer = eTimer()
self.showTimer.callback.append(self.hide)
config.usage.showdish.addNotifier(self.configChanged)
self.configChanged(config.usage.showdish)
self.rotor_pos = self.cur_orbpos = config.misc.lastrotorposition.getValue(
)
self.turn_time = self.total_time = None
self.cur_polar = 0
self.__state = self.STATE_HIDDEN
self.onShow.append(self.__onShow)
self.onHide.append(self.__onHide)
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.__serviceStarted,
iPlayableService.evTunedIn: self.__serviceTuneEnd,
iPlayableService.evTuneFailed: self.__serviceTuneEnd,
})
def __init__(self, session, infobar=None):
Screen.__init__(self, session)
self["actions"] = ActionMap(["SetupActions"], {
"ok": self.ok,
"cancel": self.cancel,
}, -2)
self.list = []
ConfigListScreen.__init__(self, self.list)
if self.session.infobar is None:
if InfoBar.instance:
self.infobar = InfoBar.instance
else:
self.infobar = self.session.infobar
self.fillList()
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={iPlayableService.evUpdatedInfo: self.__updatedInfo})
self.cached_subtitle_checked = False
self.__selected_subtitle = None
def __init__(self, session, track_autoselect_config):
assert TrackAutoselector.instance is None, "TrackAutoselector is a singleton class and may only be initialized once!"
TrackAutoselector.instance = self
self.session = session
self.track_autoselect_config = track_autoselect_config
self.onClose = []
self.__event_tracker = ServiceEventTracker(
screen=self,
eventmap={
iPlayableService.evStart: self.__initializeVars,
iPlayableService.evEnd: self.__serviceStopped,
iPlayableService.evUpdatedInfo: self.__updatedInfo,
iPlayableService.evUpdatedEventInfo: self.__updatedEventInfo,
iPlayableService.evAudioListChanged: self.__audioListChanged,
iPlayableService.evSubtitleListChanged:
self.__subtitleListChanged
})
self._nav = session.nav
self._waitForEventInfoTimer = eTimer()
self._waitForEventInfoTimer_conn = self._waitForEventInfoTimer.timeout.connect(
self.__updatedInfoTimeoutCB)
self.__initializeVars()
self.deferredSelectSubtitles = False
def __init__(self, session, handlePlayback=False):
global globalActionMap #fixme #hack
self.actionmap = globalActionMap
self.session = session
self._handlePlayback = handlePlayback
self.uri = None
self.metadata = {}
self.mimetype = None
self._state = UPnPMediaRenderer.STATE_IDLE
self.onStateChange = []
self.onClose = [] #hack
self.__poll_pos_timer = eTimer()
self.__poll_pos_timer_conn = self.__poll_pos_timer.timeout.connect(self.updatePosition)
self.volctrl = eDVBVolumecontrol.getInstance() # this is not nice
if self._handlePlayback:
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evEOF: self.__onEOF,
})
def __init__(self, session, updateIntervalInMs=500):
desktopWidth = getDesktop(0).size().width()
offset = 20
screenWidth = desktopWidth - (2 * offset)
widgetWidth = screenWidth / 3 - 5
self.skin = """
<screen position="%d,0" size="%d,60" zPosition="2" backgroundColor="transparent" flags="wfNoBorder">
<widget source="bufferSize" render="Label" position="0,0" size="%d,70" valign="center" halign="left" font="Regular;22" transparent="1" foregroundColor="#ffffff" shadowColor="#40101010" shadowOffset="2,2" />
<widget source="bufferLevel" render="Label" position="%d,0" size="%d,70" valign="center" halign="center" font="Regular;22" transparent="1" foregroundColor="#ffffff" shadowColor="#40101010" shadowOffset="2,2" />
<widget source="avgInRate" render="Label" position="%d,0" size="%d,70" valign="center" halign="right" font="Regular;22" transparent="1" foregroundColor="#ffffff" shadowColor="#40101010" shadowOffset="2,2" />
</screen>""" % (offset, screenWidth, widgetWidth, widgetWidth + 5, widgetWidth, 2 * widgetWidth + 10, widgetWidth)
Screen.__init__(self, session)
self["avgInRate"] = StaticText()
self["bufferSize"] = StaticText()
self["bufferLevel"] = StaticText()
self.updateIntervalInMs = updateIntervalInMs
self.updateTimer = eTimer()
self.updateTimer.callback.append(self.updateStatus)
self.__event_tracker = ServiceEventTracker(screen=self, eventmap={
iPlayableService.evBuffering: self.__evBuffering,
iPlayableService.evStart: self.__evStart,
iPlayableService.evStopped: self.__evStopped,
})
self.onClose.append(self.updateTimer.stop)
