Exemplo n.º 1
0
	def __init__(self):
		assert not HdmiCec.instance, "only one HdmiCec instance is allowed!"
		HdmiCec.instance = self

		self.wait = eTimer()
		self.wait.timeout.get().append(self.sendCmd)
		self.waitKeyEvent = eTimer()
		self.waitKeyEvent.timeout.get().append(self.sendKeyEvent)
		self.queueKeyEvent = []
		self.repeat = eTimer()
		self.repeat.timeout.get().append(self.wakeupMessages)
		self.queue = []

		self.delay = eTimer()
		self.delay.timeout.get().append(self.sendStandbyMessages)
		self.useStandby = True

		eHdmiCEC.getInstance().messageReceived.get().append(self.messageReceived)
		config.misc.standbyCounter.addNotifier(self.onEnterStandby, initial_call = False)
		config.misc.DeepStandby.addNotifier(self.onEnterDeepStandby, initial_call = False)
		self.setFixedPhysicalAddress(config.hdmicec.fixed_physical_address.value)

		self.volumeForwardingEnabled = False
		self.volumeForwardingDestination = 0
		self.wakeup_from_tv = False
		eActionMap.getInstance().bindAction('', -maxint - 1, self.keyEvent)
		config.hdmicec.volume_forwarding.addNotifier(self.configVolumeForwarding)
		config.hdmicec.enabled.addNotifier(self.configVolumeForwarding)
		if config.hdmicec.enabled.value:
			if config.hdmicec.report_active_menu.value:
				if config.hdmicec.report_active_source.value and NavigationInstance.instance and not NavigationInstance.instance.isRestartUI():
					self.sendMessage(0, "sourceinactive")
				self.sendMessage(0, "menuactive")
			if config.hdmicec.handle_deepstandby_events.value and (not getFPWasTimerWakeup() or (config.usage.startup_to_standby.value == "no" and config.misc.prev_wakeup_time_type.value == 3)):
				self.onLeaveStandby()
Exemplo n.º 2
0
	def __init__(self, session, url, folder, filename):
		screen = """
		  <screen  flags="wfNoBorder" position="0,0" size="1280,720" backgroundColor="transparent">
		  <widget source="fname" render="Label" position="610,147" size="580,75" font="Regular;18" halign="center" valign="center"  transparent="1" />
		  <widget source="progressbar" render="Progress" pixmap="icons/bar_downloader.png" position="610,233" size="580,12" zPosition="2" transparent="1" />
		  <widget source="status" render="Label" position="610,258" zPosition="3" size="580,71" font="Regular;22" halign="center" transparent="1" />
		</screen>"""
		Screen.__init__(self, session)
		self.url = url
		self.filename = filename
		self.dstfilename = folder + filename
		self["oktext"] = Label(_("OK"))
		self["canceltext"] = Label(_("Cancel"))
		self["fname"] = StaticText('')
		self["status"] = StaticText('')
		self["progressbar"] = Progress()
		self["progressbar"].range = 1000
		self["progressbar"].value = 0
		self["actions"] = ActionMap(["WizardActions", "DirectionActions",'ColorActions'], 
		{
			"ok": self.cancel,
			"back": self.cancel,
			"red": self.stop,
			"green": self.cancel
		}, -1)
		self.autoCloseTimer = eTimer()
		self.autoCloseTimer.timeout.get().append(self.cancel)
		self.startDownloadTimer = eTimer()
		self.startDownloadTimer.timeout.get().append(self.fileDownload)
		self.download = None
		self.downloading(False)
		self.onShown.append(self.setWindowTitle)
		self.onLayoutFinish.append(self.startDownload)
Exemplo n.º 3
0
	def __init__(self, session, servicelist, cleanupfnc = None):
		Screen.__init__(self, session)
		
		# Save Session&Servicelist
		self.session = session
		self.servicelist = servicelist
		
		# Create zap timer
		self.zap_time = None
		self.zap_timer = eTimer()
		self.zap_timer_conn = self.zap_timer.timeout.connect(self.zap)

		# Create event monitoring timer
		self.monitor_timer = eTimer()
		self.monitor_timer_conn = self.monitor_timer.timeout.connect(self.stopMonitoring)

		# Create delay timer
		self.delay_timer = eTimer()
		self.delay_timer_conn = self.delay_timer.timeout.connect(self.zappedAway)

		# Initialize services
		self.zap_service = None
		self.move_service = None
		self.root = None
		
		#	Initialize monitoring
		self.monitored_service = None
		self.monitored_event = None
		self.__event_tracker = None
		
		# Keep Cleanup
		self.cleanupfnc = cleanupfnc
Exemplo n.º 4
0
	def __init__(self, session):
		self["actions"] = ActionMap(["DirectionActions","OkCancelActions"],
		{
			"ok": self.keyOk,
			"up": self.up,
			"down":self.down,
			"cancel": self.keyCancel,
		}, -2)

		Screen.__init__(self, session)
		tlist = []
		tlist.append(("Smartcard 1 Test",0))
		tlist.append(("Smartcard 2 Test",1))
		tlist.append(("CI 1 Test",2))
		tlist.append(("CI 2 Test",3))
		self["testlist"] = MenuList(tlist)
		self.rlist = []
		for x in range(4):
			self.rlist.append((".."))
		self["resultlist"] = TestResultList(self.rlist)
		self.result = 0
		self.removecard = eTimer()
		self.removecard.callback.append(self.remove_card)
		self["text"]=Label(("Press OK Key"))
		self.camstate= eTimer()
		self.camstate.callback.append(self.cam_state)
		self.camtry = 5
		self.camstep = 0
Exemplo n.º 5
0
	def __init__(self, session, StandbyCounterIncrease=True):
		Screen.__init__(self, session)
		self.avswitch = AVSwitch()

		print "enter standby"

		self["actions"] = ActionMap( [ "StandbyActions" ],
		{
			"power": self.Power,
			"discrete_on": self.Power
		}, -1)

		globalActionMap.setEnabled(False)

		from Screens.InfoBar import InfoBar
		self.infoBarInstance = InfoBar.instance
		self.StandbyCounterIncrease = StandbyCounterIncrease
		self.standbyTimeoutTimer = eTimer()
		self.standbyTimeoutTimer.callback.append(self.standbyTimeout)
		self.standbyStopServiceTimer = eTimer()
		self.standbyStopServiceTimer.callback.append(self.stopService)
		self.timeHandler = None

		#mute adc
		self.setMute()

		self.paused_service = None

		self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup()
		service = self.prev_running_service and self.prev_running_service.toString()
		if service:
			if service.rsplit(":", 1)[1].startswith("/"):
				self.paused_service = True
				self.infoBarInstance.pauseService()
		if not self.paused_service:
			self.timeHandler =  eDVBLocalTimeHandler.getInstance()
			if self.timeHandler.ready():
				if self.session.nav.getCurrentlyPlayingServiceOrGroup():
					self.stopService()
				else:
					self.standbyStopServiceTimer.startLongTimer(5)
				self.timeHandler = None
			else:
				self.timeHandler.m_timeUpdated.get().append(self.stopService)

		if self.session.pipshown:
			self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP()

		#set input to vcr scart
		if SystemInfo["ScartSwitch"]:
			self.avswitch.setInput("SCART")
		else:
			self.avswitch.setInput("AUX")

		gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value)
		if gotoShutdownTime:
			self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime)

		self.onFirstExecBegin.append(self.__onFirstExecBegin)
		self.onClose.append(self.__onClose)
Exemplo n.º 6
0
	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.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,
			})
Exemplo n.º 7
0
	def __init__(self, session):
		Screen.__init__(self, session)
		self["actions"]  = ActionMap(["OkCancelActions", "ShortcutActions", "WizardActions", "ColorActions", "SetupActions", "NumberActions", "MenuActions"], {
			"ok"    : self.keyOK,
			"cancel": self.keyCancel,
			"red"   : self.keyCancel,
			"green" : self.keyGreen,
			"yellow": self.keyYellow,
			"blue"  : self.keyBlue,
		}, -1)

		global DLNA_CONFIG_CLIENT_CONFNAME
		self.configFileName = DLNA_CONFIG_CLIENT_CONFNAME
		self["key_red"]    = StaticText(_("Exit"))
		self["key_green"]  = StaticText(_("Start"))
		self["key_yellow"] = StaticText(_("Setting"))
		self["key_blue"]   = StaticText(_("Reload Device"))

		#self["devicelist"] = MenuList(self.setListOnView())
		self["devicelist"] = MenuList([])
		self.onLayoutFinish.append(self.layoutFinished)

		self.initConfig()
		self.taskManager = TaskManager()

		self.toggleGreenButtonTimer = eTimer()
		self.toggleGreenButtonTimer.timeout.get().append(self.cbToggleGreenButton)

		self.deviceListRefreshTimer = eTimer()
		self.deviceListRefreshTimer.timeout.get().append(self.cbDeviceListRefresh)
		global DLNA_CONFIG_DEVICE_REFRESH
		self.deviceListRefreshTimer.start(DLNA_CONFIG_DEVICE_REFRESH)
Exemplo n.º 8
0
	def __init__(self, session):
		global globalActionMap
		globalActionMap.actions["volumeUp"]=self.volUp
		globalActionMap.actions["volumeDown"]=self.volDown
		globalActionMap.actions["volumeMute"]=self.volMute

		assert not VolumeControl.instance, "only one VolumeControl instance is allowed!"
		VolumeControl.instance = self

		config.audio = ConfigSubsection()
		config.audio.volume = ConfigInteger(default = 50, limits = (0, 100))

		self.volumeDialog = session.instantiateDialog(Volume)
		self.volumeDialog.setAnimationMode(0)
		self.muteDialog = session.instantiateDialog(Mute)
		self.muteDialog.setAnimationMode(0)

		self.hideVolTimer = eTimer()
		self.hideVolTimer.callback.append(self.volHide)

		self.stepVolTimer = eTimer()
		self.repeat = 500
		self.delay = 3000

		vol = config.audio.volume.value
		self.volumeDialog.setValue(vol)
		self.volctrl = eDVBVolumecontrol.getInstance()
		self.volctrl.setVolume(vol, vol)
Exemplo n.º 9
0
	def __init__(self, session):
		Screen.__init__(self, session)
		self.setTitle(_("SoftCam manager"))
		self.Console = Console()
		self["key_red"] = StaticText(_("Stop"))
		self["key_green"] = StaticText(_("Start"))
		self["key_yellow"] = StaticText(_("Restart"))
		self["key_blue"] = StaticText(_("Setup"))
		self["actions"] = ActionMap(["OkCancelActions", "ColorActions"],
			{
				"cancel": self.cancel,
				"ok": self.ok,
				"green": self.start,
				"red": self.stop,
				"yellow": self.restart,
				"blue": self.setup
			})
		self["status"] = Label()
		self["list"] = List([])
		checkconfigdir()
		self.actcam = config.plugins.AltSoftcam.actcam.value
		self.camstartcmd = ""
		self.actcampng = LoadPixmap(resolveFilename(SCOPE_PLUGINS,
			"Extensions/AlternativeSoftCamManager/images/actcam.png"))
		self.defcampng = LoadPixmap(resolveFilename(SCOPE_PLUGINS,
			"Extensions/AlternativeSoftCamManager/images/defcam.png"))
		self.stoppingTimer = eTimer()
		self.stoppingTimer.timeout.get().append(self.stopping)
		self.closestopTimer = eTimer()
		self.closestopTimer.timeout.get().append(self.closestop)
		self.createinfo()
		self.Timer = eTimer()
		self.Timer.callback.append(self.listecminfo)
		self.Timer.start(2000, False)
Exemplo n.º 10
0
 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})
     return
Exemplo n.º 11
0
 def __init__(self, session):
     Screen.__init__(self, session)
     self['Dishpixmap'] = Boolean(fixed=True, poll=1500)
     self['turnTime'] = Label('')
     self['posFrom'] = Label('')
     self['posGoto'] = Label('')
     self['From'] = Label(_('From :'))
     self['Goto'] = Label(_('Goto :'))
     self['tunerName'] = Label('')
     self['turnSpeed'] = Label('')
     self.updateRotorSatList()
     self.frontend = None
     self['Frontend'] = FrontendStatus(service_source=lambda : self.frontend, update_interval=1000)
     self.rotorTimer = eTimer()
     self.rotorTimer.timeout.get().append(self.updateRotorMovingState)
     self.turnTimer = eTimer()
     self.turnTimer.callback.append(self.turnTimerLoop)
     self.timeoutTimer = eTimer()
     self.timeoutTimer.callback.append(self.__toHide)
     self.rotor_pos = self.cur_orbpos = config.misc.lastrotorposition.value
     config.misc.lastrotorposition.addNotifier(self.RotorpositionChange)
     self.turn_time = self.total_time = None
     self.close_timeout = self.moving_timeout = self.cur_polar = 0
     self.__state = self.STATE_HIDDEN
     self.onShow.append(self.__onShow)
     self.onHide.append(self.__onHide)
     return
Exemplo n.º 12
0
    def __init__(self, session):
        self.session = session
        self.autobouquetsmakertimer = eTimer()
        self.autobouquetsmakertimer.callback.append(self.AutoBouquetsMakeronTimer)
        self.autobouquetsmakeractivityTimer = eTimer()
        self.autobouquetsmakeractivityTimer.timeout.get().append(self.autobouquetsmakerdatedelay)
        now = int(time())
        global AutoBouquetsMakerTime
        if config.autobouquetsmaker.schedule.value:
            print >> log, "[AutoBouquetsMaker] AutoBouquetsMaker Schedule Enabled at ", strftime("%c", localtime(now))
            if now > 1262304000:
                self.autobouquetsmakerdate()
            else:
                print >> log, "[AutoBouquetsMaker] AutoBouquetsMaker Time not yet set."
                AutoBouquetsMakerTime = 0
                self.autobouquetsmakeractivityTimer.start(36000)
        else:
            AutoBouquetsMakerTime = 0
            print >> log, "[AutoBouquetsMaker] AutoBouquetsMaker Schedule Disabled at", strftime("%c", localtime(now))
            self.autobouquetsmakeractivityTimer.stop()

        assert (
            AutoAutoBouquetsMakerTimer.instance is None
        ), "class AutoAutoBouquetsMakerTimer is a singleton class and just one instance of this class is allowed!"
        AutoAutoBouquetsMakerTimer.instance = self
Exemplo n.º 13
0
    def __init__(self, session, parent):
        size_w = getDesktop(0).size().width()
        size_h = getDesktop(0).size().height()
        self.skin = """<screen position="0,0" size="%i,%i" flags="wfNoBorder" title="LastFMSaveScreen" >
                <widget name="cover" position="50,50" size="%i,%i" />
              </screen>""" % (size_w, size_h, self.coverartsize[0], self.coverartsize[1])

        Screen.__init__(self, session)
        HelpableScreen.__init__(self)
        self.imageconverter = ImageConverter(self.coverartsize[0], self.coverartsize[1], self.setCoverArt)
        self.session = session
        self.streamplayer = parent.streamplayer
        self.parent = parent
        self["cover"] = MovingPixmap()

        self["actions"] = HelpableActionMap(self, ["WizardActions", "ShortcutActions"], {
            "ok": (self.action_exit, _("Exit screensaver")),
            "back": (self.action_exit, _("Exit screensaver")),
            "red": (self.parent.action_startstop, _("Start/stop streaming")),
            "green": (self.parent.skipTrack, _("Skip current track")),
            "yellow": (self.parent.love, _("Mark track as loved")),
            "blue": (self.parent.banTrack, _("Ban track, never play"))
        }, prio=-1, description=config.plugins.LastFM.name.value + " " + _("Screensaver"))

        self.onLayoutFinish.append(self.update)
        self.updatetimer = eTimer()
        self.updatetimer.timeout.get().append(self.update)
        self.updatetimer.start(1000)

        if config.plugins.LastFM.sreensaver.coverartanimation.value:
            self.startmovingtimer = eTimer()
            self.startmovingtimer.timeout.get().append(self.movePixmap)
            self.startmovingtimer.start(config.plugins.LastFM.sreensaver.coverartinterval.value * 1000)
Exemplo n.º 14
0
	def __init__(self, nextRecordTimerAfterEventActionAuto=False):
		if NavigationInstance.instance is not None:
			raise NavigationInstance.instance

		NavigationInstance.instance = self
		self.ServiceHandler = eServiceCenter.getInstance()

		import Navigation as Nav
		Nav.navcore = self

		self.pnav = pNavigation()
		self.pnav.m_event.get().append(self.dispatchEvent)
		self.pnav.m_record_event.get().append(self.dispatchRecordEvent)
		self.event = [ ]
		self.record_event = [ ]
		self.currentlyPlayingServiceReference = None
		self.currentlyPlayingService = None
		self.RecordTimer = RecordTimer.RecordTimer()
		if getFPWasTimerWakeup():
			if nextRecordTimerAfterEventActionAuto:
				# We need to give the system the chance to fully startup,
				# before we initiate the standby command.
				self.standbytimer = eTimer()
				self.standbytimer.callback.append(self.gotostandby)
				self.standbytimer.start(15000, True)
				# We need to give the systemclock the chance to sync with the transponder time,
				# before we will make the decision about whether or not we need to shutdown
				# after the upcoming recording has completed
				self.recordshutdowntimer = eTimer()
				self.recordshutdowntimer.callback.append(self.checkShutdownAfterRecording)
				self.recordshutdowntimer.start(30000, True)
		self.SleepTimer = SleepTimer.SleepTimer()
Exemplo n.º 15
0
    def doActions(self):
        from Screens.Standby import inStandby

        if len(self.actionsList) == 0:
            self.progresscurrent += 1
            if not inStandby:
                self["progress"].setValue(self.progresscurrent)
                self["action"].setText(_("Bouquets generation..."))
                self["status"].setText(
                    _("Services: %d video - %d radio")
                    % (self.manager.getServiceVideoRead(), self.manager.getServiceAudioRead())
                )
            self.timer = eTimer()
            self.timer.callback.append(self.doBuildIndex)
            self.timer.start(100, 1)
            return

        self.currentAction = self.actionsList[0]
        del (self.actionsList[0])

        self.progresscurrent += 1
        if not inStandby:
            self["progress"].setValue(self.progresscurrent)
            self["action"].setText(_("Tuning %s...") % str(self.providers[self.currentAction]["name"]))
            self["status"].setText(
                _("Services: %d video - %d radio")
                % (self.manager.getServiceVideoRead(), self.manager.getServiceAudioRead())
            )
        self.timer = eTimer()
        self.timer.callback.append(self.doTune)
        self.timer.start(100, 1)
Exemplo n.º 16
0
    def __init__(self,session,parent):
        size_w = getDesktop(0).size().width()    
        size_h = getDesktop(0).size().height()
        self.skin = """<screen position="0,0" size="%i,%i" flags="wfNoBorder" title="LastFMSaveScreen" >
                <widget name="cover" position="50,50" size="%i,%i" />          
              </screen>"""%(size_w,size_h,self.coverartsize[0],self.coverartsize[1])
    
        Screen.__init__(self,session)
        self.imageconverter = ImageConverter(self.coverartsize[0],self.coverartsize[1],self.setCoverArt)
        self.session = session
        self.streamplayer = parent.streamplayer
        self.parent = parent
        self["cover"] = MovingPixmap()
                        
        self["actions"] = ActionMap(["InfobarChannelSelection","WizardActions", "DirectionActions","MenuActions","ShortcutActions","GlobalActions","HelpActions"], 
            {
             "ok": self.action_exit,
             "back": self.action_exit,
			 "red": self.parent.action_startstop,
             "green": self.parent.skipTrack,
             "yellow": self.parent.love,
             "blue": self.parent.banTrack ,
             }, -1)
        
        self.onLayoutFinish.append(self.update)
        self.updatetimer = eTimer()
        self.updatetimer.timeout.get().append(self.update)
        self.updatetimer.start(1000)
            
        if config.plugins.LastFM.sreensaver.coverartanimation.value:
            self.startmovingtimer = eTimer()
            self.startmovingtimer.timeout.get().append(self.movePixmap)
            self.startmovingtimer.start(config.plugins.LastFM.sreensaver.coverartinterval.value*1000)
Exemplo n.º 17
0
	def __init__(self, session):
		self.skin = DishPiP.skin
		Screen.__init__(self, session)
		self["Dishpixmap"] = Boolean(fixed=True, poll=1500)
		self["turnTime"] = Label("")
		self["posFrom"] = Label("")
		self["posGoto"] = Label("")
		self["From"] = Label(_("From :"))
		self["Goto"] = Label(_("Goto :"))
		self["tunerName"] = Label("")
		self["turnSpeed"] = Label("")
		self.frontend = None
		self["Frontend"] = FrontendStatus(service_source = lambda: self.frontend, update_interval = 1000)
		self.rotorTimer = eTimer()
		self.rotorTimer.timeout.get().append(self.updateRotorMovingState)
		self.turnTimer = eTimer()
		self.turnTimer.callback.append(self.turnTimerLoop)
		self.timeoutTimer = eTimer()
		self.timeoutTimer.callback.append(self.__toHide)
		self.rotor_pos = self.cur_orbpos = configDishpip.value
		self.turn_time = self.total_time = self.close_timeout = None
		self.moving_timeout = self.cur_polar = 0
		self.__state = self.STATE_HIDDEN
		configDishpip.addNotifier(self.lastrotorPiPpositionChange)
		self.onShow.append(self.__onShow)
		self.onHide.append(self.__onHide)
Exemplo n.º 18
0
	def __init__(self):
		# support only tm models
		self.devices = { "tm2toe":1, "tmnano2t":1, "tmtwinoe":2, "tmsingle":4, "tmnanooe":4}
		self.models = { 1:"TM-2T-OE/TM-NANO-2T", 2:"TM-TWIN-OE", 4:"TM-SINGLE/TM-NANO-OE" }
		self.rcu = self.devices.get(HardwareInfo().get_device_name())
		self.rcuSaveFile = "/etc/.rcu"
		if os.path.exists(self.rcuSaveFile):
			fd = open(self.rcuSaveFile, "r")
			try:
				if int(fd.readline().strip()) in self.devices.values():
					self.rcu = int(fd.readline().strip()) 
			except:
				pass

		self.menuKeyCount = 0
		self.ChannelMinusKeyCount = 0
		self.volctrl = eDVBVolumecontrol.getInstance() #IQON

		model = HardwareInfo().get_device_name()

		# tmnano2t has not menu key.
		if model in ("tmnano2t"):
			self.resetChannelMinusKeyCountTimer = eTimer()
			self.resetChannelMinusKeyCountTimer.callback.append(self.resetChannelMinusKeyCount)
		else:
			self.resetMenuKeyCountTimer = eTimer()
			self.resetMenuKeyCountTimer.callback.append(self.resetMenuKeyCount)
Exemplo n.º 19
0
	def __init__(self, session):
		Screen.__init__(self, session)
		self.list = []
		self['config'] = ConfigList(self.list)
		self["title"] = Label(_("DB Panel"))
		self["ecmtext"] = ScrollLabel("")
		self["key_blue"] = Label(_("Addons Manager"))
		self["key_yellow"] = Label(_("System Settings"))
		self["key_green"] = Label(_("System Information"))
		self["key_red"] = Label(_("System Utility"))
		self["key_1"] = Label(_("DB News"))
		self["key_2"] = Label(_("Parental Control Setup"))
		self["key_3"] = Label(_("About DB"))
		self["info_use"] = Label(_("Use arrows < > to select"))
		self["actions"] = NumberActionMap(["ColorActions", "CiSelectionActions","WizardActions","SetupActions"],
			{
				"left": self.keyLeft,
				"right": self.keyRight,
				"blue": self.naddons,
				"green": self.ninfo,
				"yellow": self.nsetting,
				"red": self.nutility,
				"ok": self.ok_pressed,
				"back": self.close,
				"1": self.keyNumberGlobal,
				"2": self.keyNumberGlobal,
				"3": self.keyNumberGlobal
			},-1)
		self.activityTimer = eTimer()
		self.ecmTimer = eTimer()
		self.ecmTimer.timeout.get().append(self.readEcmInfo)
		self.ecmTimer.start(10000, True)
		self.readEcmInfo()
		self.onLayoutFinish.append(self.loadEmuList)
		self.onShown.append(self.setWindowTitle)
Exemplo n.º 20
0
	def __init__(self, session, alt_bouquet_count):
		self.reclist = {}
		self.session = session
		self.anchor = config.plugins.RecInfobar.anchor.value
		self.acount = alt_bouquet_count

		Screen.__init__(self, session)
		self.skinName = ["RecInfoBar_" + self.__class__.__name__, "RecInfoBar"]
		self.labels = ["chNum","chName","timelen","chProv","chBouq","recName","chTuner", "remaining", "chSnr"]
		for x in self.labels:
			self[x] = Label("")
		self.RecIndicator = None
		self.updateTimer = eTimer()
		self.updateTimer.callback.append(self.updateInfo)
		self.onClose.append(self.__onClose)
		self.onShow.append(self.__onShow)
		config.plugins.RecInfobar.x.addNotifier(self.__changePosition, False)
		config.plugins.RecInfobar.y.addNotifier(self.__changePosition, False)
		config.plugins.RecInfobar.rec_indicator.addNotifier(self.stateRecIndicator)
		self.onLayoutFinish.append(self.__onLayoutFinished)
		self.rec_ref = None
		self.zap_ref = None 
		self.no_decode = False
		self.SetPosition = False
		config.misc.rectimerstate.value = False
		config.misc.rectimerstate.save()
		NavigationInstance.instance.RecordTimer.on_state_change.append(self.timerEntryOnStateChange)
		config.recording.asktozap.addNotifier(self.asktozapChanged)
		if config.plugins.RecInfobar.check_wakeup.value and getFPWasTimerWakeup():
			self.checkTimer = eTimer()
			self.checkTimer.callback.append(self.checkWakeup)
			self.checkTimer.start(20000, True)
Exemplo n.º 21
0
def isDMMImage():
    try:
        from enigma import eTimer
        eTimer().timeout.connect
    except Exception as e:
        return False
    return True
Exemplo n.º 22
0
 def __init__(self, session, url, folder, filename):
     Screen.__init__(self, session)
     self.url = url
     self.filename = filename
     self.dstfilename = folder + filename
     self['oktext'] = Label(_('OK'))
     self['canceltext'] = Label(_('Cancel'))
     self['fname'] = StaticText('')
     self['status'] = StaticText('')
     self['progressbar'] = Progress()
     self['progressbar'].range = 1000
     self['progressbar'].value = 0
     self['actions'] = ActionMap(['WizardActions', 'DirectionActions', 'ColorActions'], {'ok': self.cancel,
      'back': self.cancel,
      'red': self.stop,
      'green': self.cancel}, -1)
     self.autoCloseTimer = eTimer()
     self.autoCloseTimer.timeout.get().append(self.cancel)
     self.startDownloadTimer = eTimer()
     self.startDownloadTimer.timeout.get().append(self.fileDownload)
     self.download = None
     self.downloading(False)
     self.onShown.append(self.setWindowTitle)
     self.onLayoutFinish.append(self.startDownload)
     return
Exemplo n.º 23
0
	def gotSession(self):
		self.FanState = 0
		self.FOnTest = 0
		self.FOffTest = 0
		self.testno = 60
		self.testRTCSet = 0
		self.rstate = 1
		self.recf = 0
		self.ledstatus = 1
		self.FANtimeTimer = eTimer()
		self.LEDtimeTimer = eTimer()
		self.RtimeTimer = eTimer()
		self.RtiminimeTimer = eTimer()
		self.AVptimeTimer = eTimer()
		hw_type = HardwareInfo().get_device_name()
		if hw_type == "me" or hw_type == "minime" :
			self.LEDtimeTimer.callback.append(self.updateLED)
			if hw_type == "minime" :
				self.RtiminimeTimer.callback.append(self.updateCR)
		elif hw_type == 'elite' or hw_type == 'premium' or hw_type == 'premium+' or hw_type == 'ultra' :
			self.LEDtimeTimer.callback.append(self.updateLEDHD)
		if hw_type == 'ultra' or hw_type == 'premium+':
			self.FANtimeTimer.callback.append(self.updateFAN)
		self.RtimeTimer.callback.append(self.updateRT)
		self.AVptimeTimer.callback.append(self.updateAVp)
		self.LEDtimeTimer.start(12000, True)
		self.RtimeTimer.start(12000, True)
		self.FANtimeTimer.start(12000, True)
		self.RtiminimeTimer.start(12000, True)
		self.AVptimeTimer.start(12000, True)
Exemplo n.º 24
0
 def __init__(self):
     self.popup = self.session.instantiateDialog(PopupInputDialog)
     self["config_actions"] = NumberActionMap(["SetupActions"],
     {
         "1": self.keyNumberPressed,
         "2": self.keyNumberPressed,
         "3": self.keyNumberPressed,
         "4": self.keyNumberPressed,
         "5": self.keyNumberPressed,
         "6": self.keyNumberPressed,
         "7": self.keyNumberPressed,
         "8": self.keyNumberPressed,
         "9": self.keyNumberPressed,
         "0": self.keyNumberPressed,
     }, -1) # to prevent left/right overriding the listbox
     # we use extra actions to disable them
     self["SetupActions"] = NumberActionMap(["SetupActions"],
     {
         "cancel": self.hidePopup,
         "deleteForward": self.keyBackspace,
     }, -1)
     self["InputAsciiActions"] = ActionMap(["InputAsciiActions"],
     {
         "gotAsciiCode": self.keyGotAscii
     }, -2)
     self.last_result = -1
     self.__timer = eTimer()
     self.__timer.callback.append(self.__timeout)
     self.__timer_reload = eTimer()
     self.__timer_reload.callback.append(self.__timeout_reload)
     self.onClose.append(self.__onClose)
     self.onLayoutFinish.append(self.__onLayoutFinish)
Exemplo n.º 25
0
	def __init__(self, session):
		Screen.__init__(self, session)
		self["actions"] = ActionMap(["OkCancelActions"], {
				"ok": self._onOk,
				"cancel": self.close},
			- 2)

		self.highPrioActionSlot = eActionMap.getInstance().bindAction('', -0x7FFFFFFF, self._onKeypress) #highest prio

		self._pixmap = MyPixmap()
		self["wallpaper"] = self._pixmap
		self._setupAnimation()
		#picload setup
		size = getDesktop(0).size()
		width, height = size.width(), size.height()
		self._picload = ePicLoad()
		self.__picload_conn = self._picload.PictureData.connect(self._onPixmapReady)
		self._picload.setPara((width, height, width, height, False, 1, '#ff000000'))
		self._nextPixmap = None
		self._timer = eTimer()
		self.__timer_conn = self._timer.timeout.connect(self._onTimeout)
		self._inactivityTimer = eTimer()
		self.__inactivityTimer_conn = self._inactivityTimer.timeout.connect(self._onInactivityTimeout)

		self._immediateShow = True
		self._isEnabled = False
		self._isInitial = True

		self.onShow.append(self._onShow)
		self.onClose.append(self._onClose)
		config.plugins.screensaver.photo.speed.addNotifier(self._setupAnimation, initial_call = False)
Exemplo n.º 26
0
	def _processTimerWakeup(self):
		now = time()
		timeHandlerCallbacks =  eDVBLocalTimeHandler.getInstance().m_timeUpdated.get()
		if self.__nextRecordTimerAfterEventActionAuto and now < eDVBLocalTimeHandler.timeOK:  # 01.01.2004
			print '[Navigation] RECTIMER: wakeup to standby but system time not set.'
			if self._processTimerWakeup not in timeHandlerCallbacks:
				timeHandlerCallbacks.append(self._processTimerWakeup)
			return
		if self._processTimerWakeup in timeHandlerCallbacks:
			timeHandlerCallbacks.remove(self._processTimerWakeup)

		if self.__nextRecordTimerAfterEventActionAuto and abs(self.RecordTimer.getNextRecordingTime() - now) <= 360:
			print '[Navigation] RECTIMER: wakeup to standby detected.'
			f = open("/tmp/was_rectimer_wakeup", "w")
			f.write('1')
			f.close()
			# as we woke the box to record, place the box in standby.
			self.standbytimer = eTimer()
			self.standbytimer.callback.append(self.gotostandby)
			self.standbytimer.start(15000, True)

		elif self.__nextPowerManagerAfterEventActionAuto:
			print '[Navigation] POWERTIMER: wakeup to standby detected.'
			f = open("/tmp/was_powertimer_wakeup", "w")
			f.write('1')
			f.close()
			# as a PowerTimer WakeToStandby was actiond to it.
			self.standbytimer = eTimer()
			self.standbytimer.callback.append(self.gotostandby)
			self.standbytimer.start(15000, True)
Exemplo n.º 27
0
 def __init__(self, session):
     Screen.__init__(self, session)
     self.systemCod = [
         'beta',
         'bis',
         'bul',
         'dream',
         'dre',
         'conax',
         'cw',
         'irdeto',
         'nagra',
         'nds',
         'seca',
         'via']
     self.systemState = [
         'b_fta',
         'b_card',
         'b_emu',
         'b_spider']
     self.systemCaids = {
         '06': 'irdeto',
         '01': 'seca',
         '18': 'nagra',
         '05': 'via',
         '0B': 'conax',
         '17': 'beta',
         '0D': 'cw',
         '4A': 'dream',
         '09': 'nds',
         '4AE0': 'dre',
         '4AE1': 'dre',
         '55': 'bul',
         '26': 'bis' }
     for x in self.systemCod:
         self[x] = MultiColorLabel()
     for x in self.systemState:
         self[x] = Label()
     self['ecm_pict'] = Pixmap()
     self['TunerInfo'] = Label()
     self['SatInfo'] = Label()
     self['EmuInfo'] = Label()
     self['ecmtime'] = Label()
     self['netcard'] = Label()
     self['emuname'] = Label()
     self['hops'] = Label()
     self['reader'] = Label()
     self.path = 'piconSys'
     self.ecm_timer = eTimer()
     self.ecm_timer.timeout.get().append(self._nemesisEI__updateEmuInfo)
     self.ecmTimeStep = 0
     self.emm_timer = eTimer()
     self.emm_timer.timeout.get().append(self._nemesisEI__updateEMMInfo)
     self._nemesisEI__evStart()
     self._nemesisEI__event_tracker = ServiceEventTracker(screen = self, eventmap = {
         iPlayableService.evStart: self._nemesisEI__evStart,
         iPlayableService.evUpdatedInfo: self._nemesisEI__evUpdatedInfo,
         iPlayableService.evTunedIn: self._nemesisEI__evTunedIn })
     self.onHide.append(self._nemesisEI__onHide)
     self.onShow.append(self._nemesisEI__onShow)
Exemplo n.º 28
0
	def __init__(self, session):
		print "[ABMCustomMixSchedule][__init__] Starting..."
		self.session = session
		self.justBootedOrConfigChanged = True
		self.enableImporter = config.plugins.abmImporter.enableImporter.value
		self.leadTime = config.plugins.abmImporter.leadTime.value
		self.mix = config.plugins.abmImporter.mix.value
		try:
			self.enableSchedule = config.autobouquetsmaker.schedule.value
			self.clock = [config.autobouquetsmaker.scheduletime.value[0], config.autobouquetsmaker.scheduletime.value[1]]
			self.repeattype = config.autobouquetsmaker.repeattype.value
			print "[ABMCustomMixSchedule][__init__] ABM config available"
		except:
			self.enableSchedule = False
			self.clock = [0,0]
			self.repeattype = "daily"
			print "[ABMCustomMixSchedule][__init__] ABM config was not available"
		self.fetchtimer = eTimer()
		self.fetchtimer.callback.append(self.doSchedule)
		if self.enableSchedule:
			self.fetchtimer.startLongTimer(0)
		self.configtimer = eTimer()
		self.configtimer.callback.append(self.configChecker)
		self.configtimer.startLongTimer(60)

		assert simpleSchedule.instance is None, "[ABMCustomMixImporter] class simpleSchedule is a singleton class and just one instance of this class is allowed!"
		schedule.instance = self
Exemplo n.º 29
0
	def __init__(self, session):
		self.session = session
		self.channelsimportertimer = eTimer()
		self.channelsimportertimer.callback.append(self.ChannelsImporteronTimer)
		self.channelsimporteractivityTimer = eTimer()
		self.channelsimporteractivityTimer.timeout.get().append(self.channelsimporterchannelsimporterdatedelay)
		now = int(time())
		if config.plugins.ChannelsImporter.importOnRestart.value:
			self.boottimer = eTimer()
			self.boottimer.callback.append(self.doautostartscan)
			print "[ChannelsImporterScheduler][AutoChannelsImporterTimer] Run plugin on boot"
			self.boottimer.start(100, 1)
	
		global ChannelsImporterTime
		if config.plugins.ChannelsImporter.enableSchedule.value:
			print "[ChannelsImporterScheduler][AutoChannelsImporterTimer] Schedule Enabled at ", strftime("%c", localtime(now))
			if now > 1262304000:
				self.channelsimporterdate()
			else:
				print "[ChannelsImporterScheduler][AutoChannelsImporterTimer] Time not yet set."
				ChannelsImporterTime = 0
				self.channelsimporteractivityTimer.start(36000)
		else:
			ChannelsImporterTime = 0
			print "[ChannelsImporterScheduler][AutoChannelsImporterTimer] Schedule Disabled at", strftime("%c", localtime(now))
			self.channelsimporteractivityTimer.stop()

		assert AutoChannelsImporterTimer.instance is None, "class AutoChannelsImporterTimer is a singleton class and just one instance of this class is allowed!"
		AutoChannelsImporterTimer.instance = self
Exemplo n.º 30
0
	def gotSession(self):
		self.FanState = 0
		self.FOnTest = 0
		self.FOffTest = 0
		self.testno = 60
		self.testRTCSet = 0
		self.rstate = 1
		self.recf = 0
		self.ledstatus = 1
		self.FANtimeTimer = eTimer()
		self.LEDtimeTimer = eTimer()
		self.RtimeTimer = eTimer()
		self.RtiminimeTimer = eTimer()
		self.AVptimeTimer = eTimer()
		f = open("/proc/stb/info/model",'r')
		hw_type = f.readline().strip()
		f.close()
		if hw_type in ("me", "minime"):
			self.LEDtimeTimer.callback.append(self.updateLED)
			if hw_type == "minime":
				self.RtiminimeTimer.callback.append(self.updateCR)
		elif hw_type in ('elite', 'premium', 'premium+', 'ultra'):
			self.LEDtimeTimer.callback.append(self.updateLEDHD)
		if hw_type in ('ultra', 'premium+'):
			self.FANtimeTimer.callback.append(self.updateFAN)
		self.RtimeTimer.callback.append(self.updateRT)
		self.AVptimeTimer.callback.append(self.updateAVp)
		self.LEDtimeTimer.start(12000, True)
		self.RtimeTimer.start(12000, True)
		self.FANtimeTimer.start(12000, True)
		self.RtiminimeTimer.start(12000, True)
		self.AVptimeTimer.start(12000, True)
Exemplo n.º 31
0
 def __evStart(self):
     self.switchAudioTimer = enigma.eTimer()
     self.switchAudioTimer.callback.append(self.switchAudio)
     self.switchAudioTimer.start(750, True)  # 750 is a safe-value
Exemplo n.º 32
0
            if n.config.dvbs.configMode in ("loopthrough", "satposdepends"):
                root_id = nimmanager.sec.getRoot(
                    n.slot_id, int(n.config.dvbs.connectedTo.value))
                if n.type == nimmanager.nim_slots[
                        root_id].type:  # check if connected from a DVB-S to DVB-S2 Nim or vice versa
                    continue
            nimList.append((str(n.slot), n.friendly_full_description))
        if nimList:
            session.open(FastScanScreen, nimList)
        else:
            session.open(MessageBox, _("No suitable sat tuner found!"),
                         MessageBox.TYPE_ERROR)


Session = None
FastScanAutoStartTimer = eTimer()
autoproviders = []


def restartScanAutoStartTimer(reply=False):
    if not reply:
        print("[AutoFastScan] Scan was not succesfully retry in one hour")
        FastScanAutoStartTimer.startLongTimer(3600)
    elif reply is not True:
        global autoproviders
        if autoproviders:
            provider = autoproviders.pop(0)
            if provider:
                lastConfiguration = eval(
                    config.misc.fastscan.last_configuration.value)
                lastConfiguration = (lastConfiguration[0], provider,
Exemplo n.º 33
0
	def __init__(self):
		self.timer = eTimer()
Exemplo n.º 34
0
	def __init__(self, session, showSteps=True, showStepSlider=True, showList=True, showConfig=True):
		Screen.__init__(self, session)

		self.isLastWizard = False # can be used to skip a "goodbye"-screen in a wizard

		self.stepHistory = []

		self.wizard = {}
		parser = make_parser()
		if not isinstance(self.xmlfile, list):
			self.xmlfile = [self.xmlfile]
		print("[Wizard] Reading ", self.xmlfile)
		wizardHandler = self.parseWizard(self.wizard)
		parser.setContentHandler(wizardHandler)
		for xmlfile in self.xmlfile:
			if xmlfile[0] != '/':
				parser.parse(eEnv.resolve('${datadir}/enigma2/') + xmlfile)
			else:
				parser.parse(xmlfile)

		self.showSteps = showSteps
		self.showStepSlider = showStepSlider
		self.showList = showList
		self.showConfig = showConfig

		self.numSteps = len(self.wizard)
		self.currStep = self.getStepWithID("start") + 1

		self.timeoutTimer = eTimer()
		self.timeoutTimer.callback.append(self.timeoutCounterFired)

		self["text"] = Label()

		if showConfig:
			self["config"] = ConfigList([], session=session)

		if self.showSteps:
			self["step"] = Label()

		if self.showStepSlider:
			self["stepslider"] = Slider(1, self.numSteps)

		if self.showList:
			self.list = []
			self["list"] = List(self.list, enableWrapAround=True)
			self["list"].onSelectionChanged.append(self.selChanged)
			#self["list"] = MenuList(self.list, enableWrapAround = True)

		self.onShown.append(self.updateValues)

		self.configInstance = None
		self.currentConfigIndex = None

		Wizard.instance = self

		self.lcdCallbacks = []

		self.disableKeys = False

		self["actions"] = NumberActionMap(["WizardActions", "NumberActions", "ColorActions", "SetupActions", "InputAsciiActions", "KeyboardInputActions"],
		{
			"gotAsciiCode": self.keyGotAscii,
			"ok": self.ok,
			"back": self.back,
			"left": self.left,
			"right": self.right,
			"up": self.up,
			"down": self.down,
			"red": self.red,
			"green": self.green,
			"yellow": self.yellow,
			"blue": self.blue,
			"deleteBackward": self.deleteBackward,
			"deleteForward": self.deleteForward,
			"1": self.keyNumberGlobal,
			"2": self.keyNumberGlobal,
			"3": self.keyNumberGlobal,
			"4": self.keyNumberGlobal,
			"5": self.keyNumberGlobal,
			"6": self.keyNumberGlobal,
			"7": self.keyNumberGlobal,
			"8": self.keyNumberGlobal,
			"9": self.keyNumberGlobal,
			"0": self.keyNumberGlobal
		}, -1)

		self["VirtualKB"] = NumberActionMap(["VirtualKeyboardActions"],
		{
			"showVirtualKeyboard": self.KeyText,
		}, -2)

		self["VirtualKB"].setEnabled(False)
Exemplo n.º 35
0
class MediaPlayer(Screen, InfoBarBase, InfoBarSeek, InfoBarScreenSaver,
                  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)
        InfoBarScreenSaver.__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|3gp|3g2|asf|wmv|wma)",
            useServiceRef=True,
            additionalExtensions="4098:m3u 4098:e2pls 4098:pls")
        self["filelist"] = self.filelist

        self.playlist = MyPlayList()
        self.is_closing = False
        self.delname = ""
        self.playlistname = ""

        self["playlist"] = self.playlist

        self["PositionGauge"] = ServicePositionGauge(self.session.nav)

        self["currenttext"] = Label("")

        self["artisttext"] = Label(_("Artist") + ':')
        self["artist"] = Label("")
        self["titletext"] = Label(_("Title") + ':')
        self["title"] = Label("")
        self["albumtext"] = Label(_("Album") + ':')
        self["album"] = Label("")
        self["yeartext"] = Label(_("Year") + ':')
        self["year"] = Label("")
        self["genretext"] = Label(_("Genre") + ':')
        self["genre"] = Label("")
        self["coverArt"] = MediaPixmap()
        self["repeat"] = MultiPixmap()

        self.seek_target = None

        try:
            from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
            hotplugNotifier.append(self.hotplugCB)
        except Exception, ex:
            print "[MediaPlayer] No hotplug support", ex

        class MoviePlayerActionMap(NumberActionMap):
            def __init__(self, player, contexts=[], actions={}, prio=0):
                NumberActionMap.__init__(self, contexts, actions, prio)
                self.player = player

            def action(self, contexts, action):
                self.player.show()
                return NumberActionMap.action(self, contexts, action)

        self["OkCancelActions"] = HelpableActionMap(
            self, "OkCancelActions", {
                "ok": (self.ok, _("Add file to playlist")),
                "cancel": (self.exit, _("Exit mediaplayer")),
            }, -2)

        self["MediaPlayerActions"] = HelpableActionMap(
            self, "MediaPlayerActions", {
                "play": (self.xplayEntry, _("Play entry")),
                "pause": (self.pauseEntry, _("Pause")),
                "stop": (self.stopEntry, _("Stop entry")),
                "previous": (self.previousMarkOrEntry,
                             _("Play from previous mark or playlist entry")),
                "next": (self.nextMarkOrEntry,
                         _("Play from next mark or playlist entry")),
                "menu": (self.showMenu, _("Menu")),
                "skipListbegin":
                (self.skip_listbegin, _("Jump to beginning of list")),
                "skipListend": (self.skip_listend, _("Jump to end of list")),
                "prevBouquet":
                (self.switchLists, _("Switch between filelist/playlist")),
                "nextBouquet":
                (self.switchLists, _("Switch between filelist/playlist")),
                "delete":
                (self.deletePlaylistEntry, _("Delete playlist entry")),
                "shift_stop": (self.clear_playlist, _("Clear playlist")),
                "shift_record":
                (self.playlist.PlayListShuffle, _("Shuffle playlist")),
                "subtitles": (self.subtitleSelection, _("Subtitle selection")),
            }, -2)

        self["InfobarEPGActions"] = HelpableActionMap(
            self, "InfobarEPGActions", {
                "showEventInfo":
                (self.showEventInformation, _("show event details")),
            })

        self["actions"] = MoviePlayerActionMap(
            self, ["DirectionActions"], {
                "right": self.rightDown,
                "rightRepeated": self.doNothing,
                "rightUp": self.rightUp,
                "left": self.leftDown,
                "leftRepeated": self.doNothing,
                "leftUp": self.leftUp,
                "up": self.up,
                "upRepeated": self.up,
                "upUp": self.doNothing,
                "down": self.down,
                "downRepeated": self.down,
                "downUp": self.doNothing,
            }, -2)

        InfoBarSeek.__init__(self, actionmap="MediaPlayerSeekActions")

        self.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):
		Screen.__init__(self, session)
		self.skin = QuickSubtitlesConfigMenu.skin
		self.infobar = infobar or self.session.infobar
		self.wait = eTimer()
		self.wait.timeout.get().append(self.resyncSubtitles)
		self.service = self.session.nav.getCurrentlyPlayingServiceReference()
		servicepath = self.service and self.service.getPath()
		if servicepath and servicepath.startswith("/") and self.service.toString().startswith("1:"):
			info = eServiceCenter.getInstance().info(self.service)
			self.service_string = info and info.getInfoString(self.service, iServiceInformation.sServiceref)
		else:
			self.service_string = self.service.toString()
		self.center_dvb_subs = ConfigYesNo(default = (eDVBDB.getInstance().getFlag(eServiceReference(self.service_string)) & self.FLAG_CENTER_DVB_SUBS) and True)
		self.center_dvb_subs.addNotifier(self.setCenterDvbSubs)
		self["videofps"] = Label("")

		sub = self.infobar.selected_subtitle
		if sub[0] == 0:  # dvb
			menu = [
				getConfigMenuItem("config.subtitles.dvb_subtitles_yellow"),
				getConfigMenuItem("config.subtitles.dvb_subtitles_backtrans"),
				getConfigMenuItem("config.subtitles.dvb_subtitles_original_position"),
				(_("Center DVB subtitles"), self.center_dvb_subs),
				getConfigMenuItem("config.subtitles.subtitle_position"),
				getConfigMenuItem("config.subtitles.subtitle_bad_timing_delay"),
				getConfigMenuItem("config.subtitles.subtitle_noPTSrecordingdelay"),
			]
		elif sub[0] == 1: # teletext
			menu = [
				getConfigMenuItem("config.subtitles.ttx_subtitle_colors"),
				getConfigMenuItem("config.subtitles.ttx_subtitle_original_position"),
				getConfigMenuItem("config.subtitles.ttx_subtitle_position"),
				getConfigMenuItem("config.subtitles.subtitle_fontsize"),
				getConfigMenuItem("config.subtitles.subtitle_rewrap"),
				getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
				getConfigMenuItem("config.subtitles.showbackground"),
				getConfigMenuItem("config.subtitles.subtitle_alignment"),
				getConfigMenuItem("config.subtitles.subtitle_bad_timing_delay"),
				getConfigMenuItem("config.subtitles.subtitle_noPTSrecordingdelay"),
			]
		else: 		# pango
			menu = [
				getConfigMenuItem("config.subtitles.pango_subtitles_delay"),
				getConfigMenuItem("config.subtitles.pango_subtitle_colors"),
				getConfigMenuItem("config.subtitles.pango_subtitle_fontswitch"),
				getConfigMenuItem("config.subtitles.colourise_dialogs"),
				getConfigMenuItem("config.subtitles.subtitle_fontsize"),
				getConfigMenuItem("config.subtitles.subtitle_position"),
				getConfigMenuItem("config.subtitles.subtitle_alignment"),
				getConfigMenuItem("config.subtitles.subtitle_rewrap"),
				getConfigMenuItem("config.subtitles.pango_subtitle_removehi"),
				getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
				getConfigMenuItem("config.subtitles.showbackground"),
				getConfigMenuItem("config.subtitles.pango_subtitles_fps"),
			]
			self["videofps"].setText(_("Video: %s fps") % (self.getFps().rstrip(".000")))

		ConfigListScreen.__init__(self, menu, self.session, on_change = self.changedEntry)

		self["actions"] = NumberActionMap(["SetupActions"],
		{
			"cancel": self.cancel,
			"ok": self.ok,
		},-2)

		self.onLayoutFinish.append(self.layoutFinished)
Exemplo n.º 37
0
 def callLater(self, function):
     self.__callLaterTimer = eTimer()
     self.__callLaterTimer.callback.append(function)
     self.__callLaterTimer.start(0, True)
Exemplo n.º 38
0
	def __init__(self, session, StandbyCounterIncrease=True):
		Screen.__init__(self, session)
		self.skinName = "Standby"
		self.avswitch = AVSwitch()

		print "[Standby] enter standby"
		if os.path.exists("/usr/script/Standby.sh"):
			Console().ePopen("/usr/script/Standby.sh off")
		if os.path.exists("/usr/script/standby_enter.sh"):
			Console().ePopen("/usr/script/standby_enter.sh")

		self["actions"] = ActionMap( [ "StandbyActions" ],
		{
			"power": self.Power,
			"discrete_on": self.Power
		}, -1)

		globalActionMap.setEnabled(False)

		from Screens.InfoBar import InfoBar
		from Screens.SleepTimerEdit import isNextWakeupTime
		self.infoBarInstance = InfoBar.instance
		self.StandbyCounterIncrease = StandbyCounterIncrease
		self.standbyTimeoutTimer = eTimer()
		self.standbyTimeoutTimer.callback.append(self.standbyTimeout)
		self.standbyStopServiceTimer = eTimer()
		self.standbyStopServiceTimer.callback.append(self.stopService)
		self.standbyWakeupTimer = eTimer()
		self.standbyWakeupTimer.callback.append(self.standbyWakeup)
		self.timeHandler = None

		self.setMute()

		# set LCDminiTV off
		if SystemInfo["Display"] and SystemInfo["LCDMiniTV"]:
			setLCDModeMinitTV("0")

		self.paused_service = self.paused_action = False

		self.prev_running_service = self.session.nav.getCurrentlyPlayingServiceOrGroup()
		if Components.ParentalControl.parentalControl.isProtected(self.prev_running_service):
			self.prev_running_service = eServiceReference(config.tv.lastservice.value)
		service = self.prev_running_service and self.prev_running_service.toString()
		if service:
			if service.rsplit(":", 1)[1].startswith("/"):
				self.paused_service = hasattr(self.session.current_dialog, "pauseService") and hasattr(self.session.current_dialog, "unPauseService") and self.session.current_dialog or self.infoBarInstance
				self.paused_action = hasattr(self.paused_service, "seekstate") and hasattr(self.paused_service, "SEEK_STATE_PLAY") and self.paused_service.seekstate == self.paused_service.SEEK_STATE_PLAY
				self.paused_action and self.paused_service.pauseService()
		if not self.paused_service:
			self.timeHandler =  eDVBLocalTimeHandler.getInstance()
			if self.timeHandler.ready():
				if self.session.nav.getCurrentlyPlayingServiceOrGroup():
					self.stopService()
				else:
					self.standbyStopServiceTimer.startLongTimer(5)
				self.timeHandler = None
			else:
				self.timeHandler.m_timeUpdated.get().append(self.stopService)

		if self.session.pipshown:
			self.infoBarInstance and hasattr(self.infoBarInstance, "showPiP") and self.infoBarInstance.showPiP()

		if SystemInfo["ScartSwitch"]:
			self.avswitch.setInput("SCART")
		else:
			self.avswitch.setInput("AUX")

		gotoShutdownTime = int(config.usage.standby_to_shutdown_timer.value)
		if gotoShutdownTime:
			self.standbyTimeoutTimer.startLongTimer(gotoShutdownTime)

		gotoWakeupTime = isNextWakeupTime(True)
		if gotoWakeupTime != -1:
			curtime = localtime(time())
			if curtime.tm_year > 1970:
				wakeup_time = int(gotoWakeupTime - time())
				if wakeup_time > 0:
					self.standbyWakeupTimer.startLongTimer(wakeup_time)

		self.onFirstExecBegin.append(self.__onFirstExecBegin)
		self.onClose.append(self.__onClose)
Exemplo n.º 39
0
 def __init__(self, session):
     Screen.__init__(self, session)
     HelpableScreen.__init__(self)
     self["key_menu"] = StaticText(_("MENU"))
     self["key_info"] = StaticText(_("INFO"))
     self["key_red"] = StaticText()
     self["key_green"] = StaticText()
     self["key_yellow"] = StaticText()
     self["icons"] = MultiPixmap()
     self["icons"].hide()
     self["locales"] = List(None, enableWrapAround=True)
     self["locales"].onSelectionChanged.append(self.selectionChanged)
     self["description"] = StaticText()
     self["selectionActions"] = HelpableActionMap(
         self,
         "LocaleSelectionActions", {
             "menu": (self.keySettings,
                      _("Manage Locale/Language Selection settings")),
             "current": (self.keyCurrent,
                         _("Jump to the currently active locale/language")),
             "select":
             (self.keySelect,
              _("Select the currently highlighted locale/language for the user interface"
                )),
             "close":
             (self.closeRecursive,
              _("Cancel any changes the active locale/language and exit all menus"
                )),
             "cancel":
             (self.keyCancel,
              _("Cancel any changes to the active locale/language and exit")
              ),
             "save":
             (self.keySave,
              _("Apply any changes to the active locale/language and exit"))
         },
         prio=0,
         description=_("Locale/Language Selection Actions"))
     self["manageActions"] = HelpableActionMap(
         self,
         "LocaleSelectionActions", {
             "manage":
             (self.keyManage,
              (_("Purge all but / Add / Delete the currently highlighted locale/language"
                 ),
               _("Purge all but the current and permanent locales/languages.  Add the current locale/language if it is not installed.  Delete the current locale/language if it is installed."
                 )))
         },
         prio=0,
         description=_("Locale/Language Selection Actions"))
     topItem = _("Move up to first line")
     topDesc = _("Move up to the first line in the list.")
     pageUpItem = _("Move up one screen")
     pageUpDesc = _(
         "Move up one screen.  Move to the first line of the screen if this is the first screen."
     )
     upItem = _("Move up one line")
     upDesc = _(
         "Move up one line.  Move to the bottom of the previous screen if this is the first line of the screen.  Move to the last of the entry / list if this is the first line of the list."
     )
     downItem = _("Move down one line")
     downDesc = _(
         "Move down one line.  Move to the top of the next screen if this is the last line of the screen.  Move to the first line of the list if this is the last line on the list."
     )
     pageDownItem = _("Move down one screen")
     pageDownDesc = _(
         "Move down one screen.  Move to the last line of the screen if this is the last screen."
     )
     bottomItem = _("Move down to last line")
     bottomDesc = _("Move down to the last line in the list.")
     self["navigationActions"] = HelpableActionMap(
         self,
         "NavigationActions", {
             "top": (self.keyTop, (topItem, topDesc)),
             "pageUp": (self.keyPageUp, (pageUpItem, pageUpDesc)),
             "up": (self.keyUp, (upItem, upDesc)),
             "first": (self.keyTop, (topItem, topDesc)),
             "left": (self.keyPageUp, (pageUpItem, pageUpDesc)),
             "right": (self.keyPageDown, (pageDownItem, pageDownDesc)),
             "last": (self.keyBottom, (bottomItem, bottomDesc)),
             "down": (self.keyDown, (downItem, downDesc)),
             "pageDown": (self.keyPageDown, (pageDownItem, pageDownDesc)),
             "bottom": (self.keyBottom, (bottomItem, bottomDesc))
         },
         prio=0,
         description=_("List Navigation Actions"))
     self.initialLocale = international.getLocale()
     self.currentLocale = self.initialLocale
     self.packageTimer = eTimer()
     self.packageTimer.callback.append(self.processPackage)
     self.packageDoneTimer = eTimer()
     self.packageDoneTimer.callback.append(self.processPackageDone)
     self.onLayoutFinish.append(self.layoutFinished)
Exemplo n.º 40
0
	def __init__(self, session):
		self.skin = ServicesEditor.skin
		Screen.__init__(self, session)

		self.usk = None
		self.cur_service = None
		self.mainTitle = "ServicesEditor %s" %self.version
		self["actions"] = ActionMap(["ServicesEditorActions"],
			{
				"nextPage"			: self.nextPage,
				"nextPageUp"		: self.selectionKeyUp,
				"nextPageRepeated"	: self.nextPageRepeated,
				"prevPage"			: self.prevPage,
				"prevPageUp"		: self.selectionKeyUp,
				"prevPageRepeated"	: self.prevPageRepeated,
				"displayHelp"		: self.showHelp,
				"displayMenu"		: self.openMenu,
				"displayInfo"		: self.showServiceInfo,
				"select"			: self.editService,
				"exit"				: self.Exit,
				"left"				: self.left,
				"leftUp"			: self.doNothing,
				"leftRepeated"		: self.doNothing,
				"right"				: self.right,
				"rightUp"			: self.doNothing,
				"rightRepeated"		: self.doNothing,
				"upUp"				: self.selectionKeyUp,
				"up"				: self.up,
				"upRepeated"		: self.upRepeated,
				"down" 				: self.down,
				"downUp"			: self.selectionKeyUp,
				"downRepeated"		: self.downRepeated,
				"redUp"				: self.hideService,
				"redLong"			: self.hideServiceMenu,
				"green"				: self.editService,
				"yellow"			: self.addService,
				"blue"				: self.sortColumn,
			},-1)

		self["key_red"] = Button(_("hide/unhide"))
		self["key_green"] = Button(_("edit"))
		self["key_yellow"] = Button(_(" "))
		self["key_blue"] = Button(_("sort"))

		self["infolist"] = MenuList([])
		self["infolist"].l = eListboxPythonMultiContent()
		self["infolist"].l.setSelectionClip(eRect(0,0,0,0))
		self["infolist"].l.setItemHeight(24);
		self["infolist"].l.setFont(0, gFont("Regular", 20))
		
		self["newscaster"] = Newscaster()
		self["head"] = Head()
		self["list"] = ServiceList()
		self.onLayoutFinish.append(self.layoutFinished)
		self.currentSelectedColumn = 1

		self.row = [
			["name", _("Services"), False],
			["provider", _("Providers"), False],
			["position", _("Pos"), False],
			]
		self.typesort = False
		
		self.myTimer = eTimer()
		db = eDVBDB.getInstance()
		db.saveServicelist()
		self.lamedb = Lamedb()
		self.database = self.lamedb.database
		self._initFlag = False
		self.gpsr = session.nav.getCurrentlyPlayingServiceReference().toString().lower()
		print_cy(self.gpsr)
		tmp = self.gpsr.split(":")
		if tmp[0]=="1" and tmp[1]=="0" and tmp[10]=="":
			self.usk = tmp[6].zfill(8)+tmp[4].zfill(4)+tmp[5].zfill(4)+tmp[3].zfill(4)
		print_cy(self.usk)
Exemplo n.º 41
0
 def prepare(self):
     from enigma import eTimer
     self.timer = eTimer()
     self.timer.callback.append(self.trigger)
     self.timer.start(1000)
Exemplo n.º 42
0
 def __init__(self):
     Renderer.__init__(self)
     self.piconsize = (0, 0)
     self.delayPicTime = 100
     self.timer = eTimer()
     self.timer.callback.append(self.showPicture)
 def delay(self):
     self.timer = eTimer()
     self.timer.callback.append(self.infos)
     self.timer.start(100, True)
Exemplo n.º 44
0
    def __init__(self,
                 session,
                 slotid,
                 action,
                 handler=eDVBCI_UI.getInstance(),
                 wait_text="",
                 screen_data=None):
        Screen.__init__(self, session)

        print "[CI] with action" + str(action)

        self.mmiclosed = False
        self.tag = None
        self.slotid = slotid

        self.timer = eTimer()
        self.timer.callback.append(self.keyCancel)

        #else the skins fails
        self["title"] = Label("")
        self["subtitle"] = Label("")
        self["bottom"] = Label("")
        self["entries"] = ConfigList([])

        self["actions"] = NumberActionMap(
            ["SetupActions", "MenuActions"],
            {
                "ok": self.okbuttonClick,
                "cancel": self.keyCancel,
                "menu": self.forceExit,
                #for PIN
                "left": self.keyLeft,
                "right": self.keyRight,
                "1": self.keyNumberGlobal,
                "2": self.keyNumberGlobal,
                "3": self.keyNumberGlobal,
                "4": self.keyNumberGlobal,
                "5": self.keyNumberGlobal,
                "6": self.keyNumberGlobal,
                "7": self.keyNumberGlobal,
                "8": self.keyNumberGlobal,
                "9": self.keyNumberGlobal,
                "0": self.keyNumberGlobal
            },
            -1)

        self.action = action
        self.screen_data = screen_data

        self.is_pin_list = -1
        self.handler = handler
        if wait_text == "":
            self.wait_text = _("wait for ci...")
        else:
            self.wait_text = wait_text

        if action == 2:  #start MMI
            handler.startMMI(self.slotid)
            self.showWait()
        elif action == 3:  #mmi already there (called from infobar)
            self.showScreen()
Exemplo n.º 45
0
	def __init__(self, session, piclist, lastindex, path):

		self.textcolor = config.pic.textcolor.value
		self.color = config.pic.bgcolor.value

		tlf = TemplatedListFonts()
		self._labelFontSize = tlf.size(tlf.SMALLER)
		self._labelFontFace = tlf.face(tlf.SMALLER)

		sizes = componentSizes[Pic_Thumb.SKIN_COMPONENT_KEY]
		self._descSize = sizes.get(Pic_Thumb.SKIN_COMPONENT_DESCRIPTION_SIZE, 35)
		self._margin = sizes.get(Pic_Thumb.SKIN_COMPONENT_MARGIN, 10)
		self._spaceX = sizes.get(Pic_Thumb.SKIN_COMPONENT_SPACE_X, 55)
		self._spaceY = sizes.get(Pic_Thumb.SKIN_COMPONENT_SPACE_Y, 30)
		self._thumbX = sizes.get(Pic_Thumb.SKIN_COMPONENT_THUMP_X, 190)
		self._thumbY = sizes.get(Pic_Thumb.SKIN_COMPONENT_THUMP_Y, 200)

		size_w = getDesktop(0).size().width()
		size_h = getDesktop(0).size().height()
		self.thumbsX = size_w / (self._spaceX + self._thumbX) # thumbnails in X
		self.thumbsY = size_h / (self._spaceY + self._thumbY) # thumbnails in Y
		self.thumbsC = self.thumbsX * self.thumbsY # all thumbnails

		self.positionlist = []
		skincontent = ""

		posX = -1
		for x in range(self.thumbsC):
			posY = x / self.thumbsX
			posX += 1
			if posX >= self.thumbsX:
				posX = 0

			absX = self._spaceX + (posX * (self._spaceX + self._thumbX))
			absY = self._spaceY + (posY * (self._spaceY + self._thumbY))
			self.positionlist.append((absX, absY))
			absX += self._margin
			absY += self._margin
			skincontent += '<widget source="label%s" render="Label" position="%s,%s" size="%s,%s" font="%s;%s" valign="top" halign="center" zPosition="2" transparent="1" foregroundColor="%s"/>' % (x, absX, absY + self._thumbY - self._descSize, self._thumbX, self._descSize, self._labelFontFace, self._labelFontSize, self.textcolor)
			skincontent += '<widget name="thumb%s" position="%s,%s" size="%s,%s" zPosition="2" transparent="1" />' % (x, absX, absY, self._thumbX, self._thumbY - self._descSize - self._margin)

		# Screen, backgroundlabel and MovingPixmap
		doubleMargin = self._margin * 2
		self.skin = """<screen position="0,0" size="{0},{1}" flags="wfNoBorder" >
			<eLabel position="0,0" zPosition="0" size="{0},{1}" backgroundColor="{2}" /> \
			<widget name="frame" position="35,30" size="{3},{4}" pixmap="pic_frame.png" zPosition="1" alphatest="on" />{5}</screen>""".format(size_w, size_h, self.color, self._thumbX + doubleMargin, self._thumbY + doubleMargin, skincontent)

		Screen.__init__(self, session)

		self["actions"] = ActionMap(["OkCancelActions", "ColorActions", "DirectionActions", "MovieSelectionActions"],
		{
			"cancel": self.Exit,
			"ok": self.KeyOk,
			"left": self.key_left,
			"right": self.key_right,
			"up": self.key_up,
			"down": self.key_down,
			"showEventInfo": self.StartExif,
		}, -1)

		self["frame"] = MovingPixmap()
		for x in range(self.thumbsC):
			self["label"+str(x)] = StaticText()
			self["thumb"+str(x)] = Pixmap()

		self.Thumbnaillist = []
		self.filelist = []
		self.currPage = -1
		self.dirlistcount = 0
		self.path = path

		index = 0
		framePos = 0
		Page = 0
		for x in piclist:
			if x[0][1] == False:
				self.filelist.append((index, framePos, Page, x[0][0],  path + x[0][0]))
				index += 1
				framePos += 1
				if framePos > (self.thumbsC -1):
					framePos = 0
					Page += 1
			else:
				self.dirlistcount += 1

		self.maxentry = len(self.filelist)-1
		self.index = lastindex - self.dirlistcount
		if self.index < 0:
			self.index = 0

		self.picload = ePicLoad()
		self.picload_conn = self.picload.PictureData.connect(self.showPic)

		self.onLayoutFinish.append(self.setPicloadConf)

		self.ThumbTimer = eTimer()
		self.ThumbTimer_conn = self.ThumbTimer.timeout.connect(self.showPic)
Exemplo n.º 46
0
    def getFrontend(self):
        print "[TerrestrialScan][getFrontend] searching for available tuner"
        nimList = []
        if self.selectedNIM < 0:  # automatic tuner selection
            for nim in nimmanager.nim_slots:
                if self.config_mode(nim) not in (
                        "nothing", ) and (nim.isCompatible("DVB-T2") or
                                          (nim.isCompatible("DVB-S")
                                           and nim.canBeCompatible("DVB-T2"))):
                    nimList.append(nim.slot)
                    self.isT2tuner = True
            if len(nimList) == 0:
                print "[TerrestrialScan][getFrontend] No T2 tuner found"
                for nim in nimmanager.nim_slots:
                    if self.config_mode(nim) not in ("nothing", ) and (
                            nim.isCompatible("DVB-T") or
                        (nim.isCompatible("DVB-S")
                         and nim.canBeCompatible("DVB-T"))):
                        nimList.append(nim.slot)
            if len(nimList) == 0:
                print "[TerrestrialScan][getFrontend] No terrestrial tuner found"
                self.showError(_('No terrestrial tuner found'))
                return
        else:  # manual tuner selection, and subsequent iterations
            nim = nimmanager.nim_slots[self.selectedNIM]
            if self.config_mode(nim) not in ("nothing", ) and (
                    nim.isCompatible("DVB-T2") or
                (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-T2"))):
                nimList.append(nim.slot)
                self.isT2tuner = True
            if len(nimList) == 0:
                print "[TerrestrialScan][getFrontend] User selected tuner is not T2 compatible"
                if self.config_mode(nim) not in (
                        "nothing", ) and (nim.isCompatible("DVB-T") or
                                          (nim.isCompatible("DVB-S")
                                           and nim.canBeCompatible("DVB-T"))):
                    nimList.append(nim.slot)
            if len(nimList) == 0:
                print "[TerrestrialScan][getFrontend] User selected tuner not configured"
                self.showError(_('Selected tuner is not cofigured'))
                return

        if len(nimList) == 0:
            print "[TerrestrialScan][getFrontend] No terrestrial tuner found"
            self.showError(_('No terrestrial tuner found'))
            return

        resmanager = eDVBResourceManager.getInstance()
        if not resmanager:
            print "[TerrestrialScan][getFrontend] Cannot retrieve Resource Manager instance"
            self.showError(_('Cannot retrieve Resource Manager instance'))
            return

        if self.selectedNIM < 0:  # automatic tuner selection
            print "[TerrestrialScan][getFrontend] Choosing NIM"

        # stop pip if running
        if self.session.pipshown:
            self.session.pipshown = False
            del self.session.pip
            print "[TerrestrialScan][getFrontend] Stopping PIP."

        # Find currently playin NIM
        currentlyPlayingNIM = None
        currentService = self.session and self.session.nav.getCurrentService()
        frontendInfo = currentService and currentService.frontendInfo()
        frontendData = frontendInfo and frontendInfo.getAll(True)
        if frontendData is not None:
            currentlyPlayingNIM = frontendData.get("tuner_number", None)
        del frontendInfo
        del currentService

        current_slotid = -1
        if self.rawchannel:
            del (self.rawchannel)

        self.frontend = None
        self.rawchannel = None

        nimList.reverse()  # start from the last
        for slotid in nimList:
            if current_slotid == -1:  # mark the first valid slotid in case of no other one is free
                current_slotid = slotid
            self.rawchannel = resmanager.allocateRawChannel(slotid)
            if self.rawchannel:
                print "[TerrestrialScan][getFrontend] Nim found on slot id %d" % (
                    slotid)
                current_slotid = slotid
                break

        if current_slotid == -1:
            print "[TerrestrialScan][getFrontend] No valid NIM found"
            self.showError(_('No valid NIM found for terrestrial'))
            return

        if not self.rawchannel:
            # if we are here the only possible option is to close the active service
            if currentlyPlayingNIM in nimList:
                slotid = currentlyPlayingNIM
                print "[TerrestrialScan][getFrontend] Nim found on slot id %d but it's busy. Stopping active service" % slotid
                self.session.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
                )
                self.session.nav.stopService()
                self.rawchannel = resmanager.allocateRawChannel(slotid)
                if self.rawchannel:
                    print "[TerrestrialScan][getFrontend] The active service was stopped, and the NIM is now free to use."
                    current_slotid = slotid

            if not self.rawchannel:
                if self.session.nav.RecordTimer.isRecording():
                    print "[TerrestrialScan][getFrontend] Cannot free NIM because a recording is in progress"
                    self.showError(
                        _('Cannot free NIM because a recording is in progress')
                    )
                    return
                else:
                    print "[TerrestrialScan][getFrontend] Cannot get the NIM"
                    self.showError(_('Cannot get the NIM'))
                    return

        print "[TerrestrialScan][getFrontend] Will wait up to %i seconds for tuner lock." % (
            self.lockTimeout / 10)

        self.selectedNIM = current_slotid  # Remember for next iteration

        self["tuner_text"].setText(chr(ord('A') + current_slotid))

        self.frontend = self.rawchannel.getFrontend()
        if not self.frontend:
            print "[TerrestrialScan][getFrontend] Cannot get frontend"
            self.showError(_('Cannot get frontend'))
            return

        self.rawchannel.requestTsidOnid()

        self.tsid = None
        self.onid = None

        self.demuxer_id = self.rawchannel.reserveDemux()
        if self.demuxer_id < 0:
            print "[TerrestrialScan][getFrontend] Cannot allocate the demuxer"
            self.showError(_('Cannot allocate the demuxer'))
            return

        self.frontend.tune(
            setParamsFe(setParams(self.frequency, self.system,
                                  self.bandwidth)))

        self.lockcounter = 0
        self.locktimer = eTimer()
        self.locktimer.callback.append(self.checkTunerLock)
        self.locktimer.start(100, 1)
Exemplo n.º 47
0
    def go(self):
        from Screens.Standby import inStandby
        self.manager = Manager()
        self.manager.setPath("/etc/enigma2")
        self.manager.setAddPrefix(config.autobouquetsmaker.addprefix.value)

        self.selectedProviders = {}
        self.actionsList = []

        providers_tmp = self.abm_settings_str.split("|")

        for provider_tmp in providers_tmp:
            provider_config = ProviderConfig(provider_tmp)
            if provider_config.isValid() and Providers().providerFileExists(
                    provider_config.getProvider()):
                self.actionsList.append(provider_config.getProvider())
                self.selectedProviders[
                    provider_config.getProvider()] = provider_config

        if config.autobouquetsmaker.keepallbouquets.getValue():
            bouquets = Manager().getBouquetsList()
            bouquets_tv = []
            bouquets_radio = []
            for bouquet in bouquets["tv"]:
                if bouquet["filename"][:len(self.ABM_BOUQUET_PREFIX
                                            )] == self.ABM_BOUQUET_PREFIX:
                    continue
                if len(bouquet["filename"]) > 0:
                    bouquets_tv.append(bouquet["filename"])
            for bouquet in bouquets["radio"]:
                if bouquet["filename"][:len(self.ABM_BOUQUET_PREFIX
                                            )] == self.ABM_BOUQUET_PREFIX:
                    continue
                if len(bouquet["filename"]) > 0:
                    bouquets_radio.append(bouquet["filename"])
            self.manager.setBouquetsToKeep(bouquets_tv, bouquets_radio)
        else:
            bouquets = config.autobouquetsmaker.keepbouquets.value.split("|")
            bouquets_tv = []
            bouquets_radio = []
            for bouquet in bouquets:
                if bouquet.endswith(".tv"):
                    bouquets_tv.append(bouquet)
                elif bouquet.endswith(".radio"):
                    bouquets_radio.append(bouquet)
            self.manager.setBouquetsToKeep(bouquets_tv, bouquets_radio)

        bouquetsToHide = {}
        bouquets = config.autobouquetsmaker.hidesections.value.split("|")
        for bouquet in bouquets:
            tmp = bouquet.split(":")
            if len(tmp) != 2:
                continue

            if tmp[0].strip() not in bouquetsToHide:
                bouquetsToHide[tmp[0].strip()] = []

            bouquetsToHide[tmp[0].strip()].append(int(tmp[1].strip()))
        self.manager.setBouquetsToHide(bouquetsToHide)

        self.manager.load()

        self.progresscount = (len(self.actionsList) * 2) + 3
        self.progresscurrent = 1

        if not inStandby:
            self["progress_text"].range = self.progresscount
            self["progress_text"].value = self.progresscurrent
            self["progress"].setRange((0, self.progresscount))
            self["progress"].setValue(self.progresscurrent)

        self.timer = eTimer()
        self.timer.callback.append(self.doActions)
        self.timer.start(100, 1)
Exemplo n.º 48
0
    def __init__(self,
                 session,
                 text="",
                 filename="",
                 currDir=None,
                 bookmarks=None,
                 userMode=False,
                 windowTitle="Select location",
                 minFree=None,
                 autoAdd=False,
                 editDir=False,
                 inhibitDirs=[],
                 inhibitMounts=[]):
        # Init parents
        Screen.__init__(self, session)
        NumericalTextInput.__init__(self, handleTimeout=False)
        HelpableScreen.__init__(self)

        # Set useable chars
        self.setUseableChars(u'1234567890abcdefghijklmnopqrstuvwxyz')

        # Quickselect Timer
        self.qs_timer = eTimer()
        self.qs_timer.callback.append(self.timeout)
        self.qs_timer_type = 0

        # Initialize Quickselect
        self.curr_pos = -1
        self.quickselect = ""

        # Set Text
        self["text"] = Label(text)
        self["textbook"] = Label(_("Bookmarks"))

        # Save parameters locally
        self.text = text
        self.filename = filename
        self.minFree = minFree
        self.realBookmarks = bookmarks
        self.bookmarks = bookmarks and bookmarks.value[:] or []
        self.userMode = userMode
        self.autoAdd = autoAdd
        self.editDir = editDir
        self.inhibitDirs = inhibitDirs

        # Initialize FileList
        self["filelist"] = FileList(currDir,
                                    showDirectories=True,
                                    showFiles=False,
                                    inhibitMounts=inhibitMounts,
                                    inhibitDirs=inhibitDirs)

        # Initialize BookList
        self["booklist"] = MenuList(self.bookmarks)

        # Buttons
        self["key_green"] = Button(_("OK"))
        self["key_yellow"] = Button(_("Rename"))
        self["key_blue"] = Button(_("Remove bookmark"))
        self["key_red"] = Button(_("Cancel"))
        self["key_ch"] = Label(_("Change list"))

        # Background for Buttons
        self["green"] = Pixmap()
        self["yellow"] = Pixmap()
        self["blue"] = Pixmap()
        self["red"] = Pixmap()

        # Initialize Target
        self["target"] = Label()

        if self.userMode:
            self.usermodeOn()

        # Custom Action Handler
        class LocationBoxActionMap(HelpableActionMap):
            def __init__(self, parent, context, actions={}, prio=0):
                HelpableActionMap.__init__(self, parent, context, actions,
                                           prio)
                self.box = parent

            def action(self, contexts, action):
                # Reset Quickselect
                self.box.timeout(force=True)

                return HelpableActionMap.action(self, contexts, action)

        # Actions that will reset quickselect
        self["WizardActions"] = LocationBoxActionMap(
            self, "WizardActions", {
                "left": self.left,
                "right": self.right,
                "up": self.up,
                "down": self.down,
                "ok": (self.ok, _("select")),
                "back": (self.cancel, _("Cancel")),
            }, -2)

        self["ColorActions"] = LocationBoxActionMap(
            self, "ColorActions", {
                "red": self.cancel,
                "green": self.select,
                "yellow": self.changeName,
                "blue": self.addRemoveBookmark,
            }, -2)

        self["EPGSelectActions"] = LocationBoxActionMap(
            self, "EPGSelectActions", {
                "prevBouquet":
                (self.switchToBookList, _("switch to bookmarks")),
                "nextBouquet":
                (self.switchToFileList, _("switch to filelist")),
            }, -2)

        self["MenuActions"] = LocationBoxActionMap(self, "MenuActions", {
            "menu": (self.showMenu, _("menu")),
        }, -2)

        # Actions used by quickselect
        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
            })

        # Run some functions when shown
        self.onShown.extend((
            boundFunction(self.setTitle, _(windowTitle)),
            self.updateTarget,
            self.showHideRename,
        ))

        self.onLayoutFinish.append(self.switchToFileListOnStart)

        # Make sure we remove our callback
        self.onClose.append(self.disableTimer)
Exemplo n.º 49
0
 def __init__(self):
     Renderer.__init__(self)
     self.vol_timer = eTimer()
     self.vol_timer.callback.append(self.pollme)
Exemplo n.º 50
0
    def doTune(self):
        print >> log, "[ABM-main][doTune] searching for tuner for %s" % self.providers[
            self.currentAction]["name"]
        from Screens.Standby import inStandby
        if self.providers[self.currentAction]["streamtype"] == "dvbs":
            transponder = self.providers[self.currentAction]["transponder"]
        else:
            bouquet_key = None
            providers_tmp = self.abm_settings_str.split("|")
            for provider_tmp in providers_tmp:
                provider_config = ProviderConfig(provider_tmp)
                provider_key = provider_config.getProvider()
                if self.currentAction != provider_key:
                    continue
                bouquet_key = provider_config.getArea()

            if not bouquet_key:
                print >> log, "[ABM-main][doTune] No area found"
                self.showError(_('No area found'))
                return

            transponder = self.providers[
                self.currentAction]["bouquets"][bouquet_key]

        nimList = []
        for nim in nimmanager.nim_slots:
            if self.providers[self.currentAction][
                    "streamtype"] == "dvbs" and nim.isCompatible("DVB-S"):
                try:
                    if nim.isFBCTuner() and not nim.isFBCRoot():
                        continue  # do not load FBC links, only root tuners
                except:
                    pass
            try:  # OpenPLi Hot Switch compatible image
                if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and \
                 {"dvbs": "DVB-S", "dvbc": "DVB-C", "dvbt": "DVB-T"}.get(self.providers[self.currentAction]["streamtype"], "UNKNOWN") in [x[:5] for x in nim.getTunerTypesEnabled()]:
                    nimList.append(nim.slot)
            except AttributeError:
                try:
                    if (nim.config_mode not in ("loopthrough", "satposdepends", "nothing")) and \
                     ((self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.isCompatible("DVB-S")) or \
                     (self.providers[self.currentAction]["streamtype"] == "dvbc" and (nim.isCompatible("DVB-C") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-C")))) or \
                     (self.providers[self.currentAction]["streamtype"] == "dvbt" and (nim.isCompatible("DVB-T") or (nim.isCompatible("DVB-S") and nim.canBeCompatible("DVB-T"))))):
                        nimList.append(nim.slot)
                except AttributeError:  # OpenATV > 5.3
                    if (self.providers[self.currentAction]["streamtype"] == "dvbs" and nim.canBeCompatible("DVB-S") and nim.config_mode_dvbs not in ("loopthrough", "satposdepends", "nothing")) or \
                     (self.providers[self.currentAction]["streamtype"] == "dvbc" and nim.canBeCompatible("DVB-C") and nim.config_mode_dvbc != "nothing") or \
                     (self.providers[self.currentAction]["streamtype"] == "dvbt" and nim.canBeCompatible("DVB-T") and nim.config_mode_dvbt != "nothing"):
                        nimList.append(nim.slot)

        if len(nimList) == 0:
            print >> log, "[ABM-main][doTune] No NIMs found"
            self.showError(
                _('No NIMs found for ') +
                self.providers[self.currentAction]["name"])
            return

        resmanager = eDVBResourceManager.getInstance()
        if not resmanager:
            print >> log, "[ABM-main][doTune] Cannot retrieve Resource Manager instance"
            self.showError(_('Cannot retrieve Resource Manager instance'))
            return

        if self.providers[self.currentAction]["streamtype"] == "dvbs":
            print >> log, "[ABM-main][doTune] Search NIM for orbital position %d" % transponder[
                "orbital_position"]
        else:
            print >> log, "[ABM-main][doTune] Search NIM"

        # stop pip if running
        if self.session.pipshown:
            self.session.pipshown = False
            del self.session.pip
            print >> log, "[ABM-main][doTune] Stopping PIP."

        # stop currently playing service if it is using a tuner in ("loopthrough", "satposdepends")
        currentlyPlayingNIM = None
        currentService = self.session and self.session.nav.getCurrentService()
        frontendInfo = currentService and currentService.frontendInfo()
        frontendData = frontendInfo and frontendInfo.getAll(True)
        if frontendData is not None:
            currentlyPlayingNIM = frontendData.get("tuner_number", None)
            if self.providers[self.currentAction][
                    "streamtype"] == "dvbs" and currentlyPlayingNIM is not None and nimmanager.nim_slots[
                        currentlyPlayingNIM].isCompatible("DVB-S"):
                try:
                    nimConfigMode = nimmanager.nim_slots[
                        currentlyPlayingNIM].config_mode
                except AttributeError:  # OpenATV > 5.3
                    nimConfigMode = nimmanager.nim_slots[
                        currentlyPlayingNIM].config_mode_dvbs
                if nimConfigMode in ("loopthrough", "satposdepends"):
                    self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
                    )
                    self.session.nav.stopService()
                    currentlyPlayingNIM = None
                    print >> log, "[ABM-main][doTune] The active service was using a %s tuner, so had to be stopped (slot id %s)." % (
                        nimConfigMode, currentlyPlayingNIM)
        del frontendInfo
        del currentService

        current_slotid = -1
        self.releaseFrontend()

        nimList.reverse()  # start from the last
        for slotid in nimList:
            if self.providers[self.currentAction]["streamtype"] == "dvbs":
                sats = nimmanager.getSatListForNim(slotid)
                for sat in sats:
                    if sat[0] == transponder["orbital_position"]:
                        if current_slotid == -1:  # mark the first valid slotid in case of no other one is free
                            current_slotid = slotid

                        self.rawchannel = resmanager.allocateRawChannel(slotid)
                        if self.rawchannel:
                            print >> log, "[ABM-main][doTune] Nim found on slot id %d with sat %s" % (
                                slotid, sat[1])
                            current_slotid = slotid
                        break
            else:
                if current_slotid == -1:  # mark the first valid slotid in case of no other one is free
                    current_slotid = slotid
                self.rawchannel = resmanager.allocateRawChannel(slotid)
                if self.rawchannel:
                    print >> log, "[ABM-main][doTune] Nim found on slot id %d" % (
                        slotid)
                    current_slotid = slotid
                    break

            if self.rawchannel:
                break

        if current_slotid == -1:
            print >> log, "[ABM-main][doTune] No valid NIM found"
            self.showError(
                _('No valid NIM found for ') +
                self.providers[self.currentAction]["name"])
            return

        if not self.rawchannel:
            # if we are here the only possible option is to close the active service
            if currentlyPlayingNIM in nimList:
                slotid = currentlyPlayingNIM
                if self.providers[self.currentAction]["streamtype"] == "dvbs":
                    sats = nimmanager.getSatListForNim(slotid)
                    for sat in sats:
                        if sat[0] == transponder["orbital_position"]:
                            print >> log, "[ABM-main][doTune] Nim found on slot id %d but it's busy. Stopping active service" % slotid
                            self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
                            )
                            self.session.nav.stopService()
                            self.rawchannel = resmanager.allocateRawChannel(
                                slotid)
                            if self.rawchannel:
                                print >> log, "[ABM-main][doTune] The active service was stopped, and the NIM is now free to use."
                                current_slotid = slotid
                            break
                else:
                    print >> log, "[ABM-main][doTune] Nim found on slot id %d but it's busy. Stopping active service" % slotid
                    self.postScanService = self.session.nav.getCurrentlyPlayingServiceReference(
                    )
                    self.session.nav.stopService()
                    self.rawchannel = resmanager.allocateRawChannel(slotid)
                    if self.rawchannel:
                        print >> log, "[ABM-main][doTune] The active service was stopped, and the NIM is now free to use."
                        current_slotid = slotid

            if not self.rawchannel:
                if self.session.nav.RecordTimer.isRecording():
                    print >> log, "[ABM-main][doTune] Cannot free NIM because a recording is in progress"
                    self.showError(
                        _('Cannot free NIM because a recording is in progress')
                    )
                    return
                else:
                    print >> log, "[ABM-main][doTune] Cannot get the NIM"
                    self.showError(_('Cannot get the NIM'))
                    return

        # set extended timeout for rotors
        self.motorised = False
        if self.providers[self.currentAction][
                "streamtype"] == "dvbs" and self.isRotorSat(
                    current_slotid, transponder["orbital_position"]):
            self.motorised = True
            self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_ROTOR
            print >> log, "[ABM-main][doTune] Motorised dish. Will wait up to %i seconds for tuner lock." % (
                self.LOCK_TIMEOUT / 10)
        else:
            self.LOCK_TIMEOUT = self.LOCK_TIMEOUT_FIXED
            print >> log, "[ABM-main][doTune] Fixed dish. Will wait up to %i seconds for tuner lock." % (
                self.LOCK_TIMEOUT / 10)

        if not inStandby:
            self["tuner_text"].setText(chr(ord('A') + current_slotid))

        self.frontend = self.rawchannel.getFrontend()
        if not self.frontend:
            print >> log, "[ABM-main][doTune] Cannot get frontend"
            self.showError(_('Cannot get frontend'))
            return

        demuxer_id = self.rawchannel.reserveDemux()
        if demuxer_id < 0:
            print >> log, "[ABM-main][doTune] Cannot allocate the demuxer."
            self.showError(_('Cannot allocate the demuxer.'))
            return

        if self.providers[self.currentAction]["streamtype"] == "dvbs":
            params = eDVBFrontendParametersSatellite()
            params.frequency = transponder["frequency"]
            params.symbol_rate = transponder["symbol_rate"]
            params.polarisation = transponder["polarization"]
            params.fec = transponder["fec_inner"]
            params.inversion = transponder["inversion"]
            params.orbital_position = transponder["orbital_position"]
            params.system = transponder["system"]
            params.modulation = transponder["modulation"]
            params.rolloff = transponder["roll_off"]
            params.pilot = transponder["pilot"]
            if hasattr(eDVBFrontendParametersSatellite, "No_Stream_Id_Filter"):
                params.is_id = eDVBFrontendParametersSatellite.No_Stream_Id_Filter
            if hasattr(eDVBFrontendParametersSatellite, "PLS_Gold"):
                params.pls_mode = eDVBFrontendParametersSatellite.PLS_Gold
            if hasattr(eDVBFrontendParametersSatellite,
                       "PLS_Default_Gold_Code"):
                params.pls_code = eDVBFrontendParametersSatellite.PLS_Default_Gold_Code
            if hasattr(eDVBFrontendParametersSatellite, "No_T2MI_PLP_Id"):
                params.t2mi_plp_id = eDVBFrontendParametersSatellite.No_T2MI_PLP_Id
            if hasattr(eDVBFrontendParametersSatellite, "T2MI_Default_Pid"):
                params.t2mi_pid = eDVBFrontendParametersSatellite.T2MI_Default_Pid
            params_fe = eDVBFrontendParameters()
            params_fe.setDVBS(params, False)

        elif self.providers[self.currentAction]["streamtype"] == "dvbt":
            params = eDVBFrontendParametersTerrestrial()
            params.frequency = transponder["frequency"]
            params.bandwidth = transponder["bandwidth"]
            params.code_rate_hp = transponder["code_rate_hp"]
            params.code_rate_lp = transponder["code_rate_lp"]
            params.inversion = transponder["inversion"]
            params.system = transponder["system"]
            params.modulation = transponder["modulation"]
            params.transmission_mode = transponder["transmission_mode"]
            params.guard_interval = transponder["guard_interval"]
            params.hierarchy = transponder["hierarchy"]
            params_fe = eDVBFrontendParameters()
            params_fe.setDVBT(params)

        elif self.providers[self.currentAction]["streamtype"] == "dvbc":
            params = eDVBFrontendParametersCable()
            params.frequency = transponder["frequency"]
            params.symbol_rate = transponder["symbol_rate"]
            params.fec_inner = transponder["fec_inner"]
            params.inversion = transponder["inversion"]
            params.modulation = transponder["modulation"]
            params_fe = eDVBFrontendParameters()
            params_fe.setDVBC(params)

        try:
            self.rawchannel.requestTsidOnid()
        except (TypeError):
            # for compatibility with some third party images
            self.rawchannel.requestTsidOnid(self.gotTsidOnid)

        self.frontend.tune(params_fe)
        self.manager.setAdapter(0)  # FIX: use the correct device
        self.manager.setDemuxer(demuxer_id)
        self.manager.setFrontend(current_slotid)

        self.current_slotid = current_slotid
        self.lockcounter = 0
        self.locktimer = eTimer()
        self.locktimer.callback.append(self.checkTunerLock)
        self.locktimer.start(100, 1)
Exemplo n.º 51
0
    def wakeupCheck(self, runCheck=True):
        now = time()
        stbytimer = 15  # original was 15

        if runCheck and (
            (self.__wasTimerWakeup or config.workaround.deeprecord.value)
                and now >= self.wakeupwindow_minus
                and now <= self.wakeupwindow_plus):
            if self.syncCount > 0:
                stbytimer = stbytimer - (self.syncCount * 5)
                if stbytimer < 0: stbytimer = 0
                if not self.__wasTimerWakeup:
                    self.__wasTimerWakeup = True
                    print "-" * 100
                    print "[NAVIGATION] was timer wakeup after time sync is = True"
                    print "[NAVIGATION] wakeup time was %s" % ctime(
                        self.wakeuptime)
            print "[NAVIGATION] wakeup type is '%s' %s" % (
                {
                    0: "record-timer",
                    1: "zap-timer",
                    2: "power-timer",
                    3: "plugin-timer"
                }[self.wakeuptyp], {
                    0: "and starts normal",
                    1: "and starts in standby",
                    2: "and starts not in standby"
                }[self.getstandby])
            #record timer, zap timer, some plugin timer or next record timer begins in 15 mins
            if self.wakeuptyp < 2 or self.forcerecord:
                print "[NAVIGATION] timer starts at %s" % ctime(self.timertime)
                if self.forcerecord:
                    print "[NAVIGATION] timer is set from 'vps-plugin' or just before a 'record-timer' starts at %s" % ctime(
                        self.recordtime)
                print "[NAVIGATION] was rectimer wakeup = True"
                self.__wasRecTimerWakeup = True
                f = open("/tmp/was_rectimer_wakeup", "w")
                f.write('1')
                f.close()
            #power timer
            if self.wakeuptyp == 2:
                if not self.forcerecord:
                    print "[NAVIGATION] timer starts at %s" % ctime(
                        self.timertime)
                print "[NAVIGATION] was powertimer wakeup = True"
                self.__wasPowerTimerWakeup = True
                f = open("/tmp/was_powertimer_wakeup", "w")
                f.write('1')
                f.close()
            #plugin timer
            elif self.wakeuptyp == 3:
                if not self.forcerecord:
                    print "[NAVIGATION] timer starts at %s" % ctime(
                        self.timertime)
            #check for standby
            cec = ((self.wakeuptyp == 0 and (
                Screens.Standby.TVinStandby.getTVstandby('zapandrecordtimer')))
                   or (self.wakeuptyp == 1 and
                       (Screens.Standby.TVinStandby.getTVstandby('zaptimer')))
                   or (self.wakeuptyp == 2 and
                       (Screens.Standby.TVinStandby.getTVstandby(
                           'wakeuppowertimer'))))
            if self.getstandby != 1 and (
                (self.wakeuptyp < 3 and self.timertime - now > 60 + stbytimer)
                    or cec):
                self.getstandby = 1
                txt = ""
                if cec: txt = "... or special hdmi-cec settings"
                print "[NAVIGATION] more than 60 seconds to wakeup%s - go in standby now" % txt
            print "=" * 100
            #go in standby
            if self.getstandby == 1:
                if stbytimer:
                    self.standbytimer = eTimer()
                    self.standbytimer.callback.append(self.gotostandby)
                    self.standbytimer.start(stbytimer * 1000, True)
                else:
                    self.gotostandby()
        else:
            if self.__wasTimerWakeup:
                print '+' * 100
                print "[NAVIGATION] wrong signal 'was timer wakeup' detected - please activate the deep standby workaround."
                print "[NAVIGATION] secure timer wakeup detection window: %s - %s" % (
                    ctime(self.wakeupwindow_minus),
                    ctime(self.wakeupwindow_plus))
                print '+' * 100
            if self.timertime > 0:
                print "[NAVIGATION] next '%s' starts at %s" % (
                    {
                        0: "record-timer",
                        1: "zap-timer",
                        2: "power-timer",
                        3: "plugin-timer"
                    }[self.wakeuptyp], ctime(self.timertime))
                if self.recordtime > 0 and self.timertime != self.recordtime:
                    print "[NAVIGATION] next 'record-timer' starts at %s" % ctime(
                        self.recordtime)
                else:
                    print "[NAVIGATION] no next 'record-timer'"
            else:
                print "[NAVIGATION] no next timer"
            print "=" * 100
            self.getstandby = 0

        #workaround for normal operation if no time sync after e2 start - box is in standby
        if self.getstandby != 1 and not self.skipWakeup:
            self.gotopower()
Exemplo n.º 52
0
	def startSatelliteTransponderSearch(self, nim_idx, orb_pos):
		if hasattr(self, 'self.frontend'):
			del self.frontend
		if hasattr(self, 'self.channel'):
			del self.channel
		self.frontend = self.channel = None
		self.orb_pos = orb_pos
		self.nim = nimmanager.nim_slots[nim_idx]
		tunername = nimmanager.getNimName(nim_idx)
		print "tunername", tunername
		self.__tlist = [ ]
		self.tp_found = [ ]
		self.current_range = None
		self.range_list = [ ]
		tuner_no = -1

		self.auto_scan = nimmanager.nim_slots[nim_idx].supportsBlindScan() or tunername.startswith('Si216')
		if self.auto_scan or tunername == "Alps BSBE1 C01A/D01A." or (tunername != "BCM4501" and "BCM45" in tunername):
			(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
			if not self.frontend:
				self.session.nav.stopService()
				(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
				if not self.frontend:
					if self.session.pipshown:
						if hasattr(self.session, 'infobar'):
							try:
								slist = self.session.infobar.servicelist
								if slist and slist.dopipzap:
									slist.togglePipzap()
							except:
								pass
						self.session.pipshown = False
						if hasattr(self.session, 'pip'):
							del self.session.pip
					(self.channel, self.frontend) = self.tryGetRawFrontend(nim_idx, False, False)
					if not self.frontend:
						print "couldn't allocate tuner %d for blindscan!!!" %nim_idx
						text = _("Sorry, this tuner is in use.")
						if self.session.nav.getRecordings():
							text += "\n"
							text += _("Maybe the reason that recording is currently running.")
						self.session.open(MessageBox, text, MessageBox.TYPE_ERROR)
						return

			band_cutoff_frequency = 11700001

			s1 = self.scan_sat.bs_freq_start.value * 1000
			s2 = self.scan_sat.bs_freq_stop.value * 1000

			start = self.min_freq = min(s1,s2)
			stop = self.max_freq = max(s1,s2)

			if self.auto_scan: # hack for driver based blindscan... extend search range +/- 50Mhz
				limits = self.scan_sat.bs_freq_limits
				start -= 50000
				stop += 50000
				if start < limits[0]:
					start = limits[0]
				if stop >limits[1]:
					stop = limits[1]

			if self.scan_sat.bs_horizontal.value:
				if self.auto_scan and band_cutoff_frequency and stop > band_cutoff_frequency:
					if start < band_cutoff_frequency:
						self.range_list.append((start, min(stop, band_cutoff_frequency), eDVBFrontendParametersSatellite.Polarisation_Horizontal))
					if stop > band_cutoff_frequency:
						self.range_list.append((max(band_cutoff_frequency, start), stop, eDVBFrontendParametersSatellite.Polarisation_Horizontal))
				else:
					self.range_list.append((start, stop, eDVBFrontendParametersSatellite.Polarisation_Horizontal))

			if self.scan_sat.bs_vertical.value:
				if self.auto_scan and band_cutoff_frequency:
					if start < band_cutoff_frequency:
						self.range_list.append((start, min(stop, band_cutoff_frequency), eDVBFrontendParametersSatellite.Polarisation_Vertical))
					if stop > band_cutoff_frequency:
						self.range_list.append((max(band_cutoff_frequency, start), stop, eDVBFrontendParametersSatellite.Polarisation_Vertical))
				else:
					self.range_list.append((start, stop, eDVBFrontendParametersSatellite.Polarisation_Vertical))

			self.parm = self.setNextRange()
			if self.parm is not None:
				tparm = eDVBFrontendParameters()
				tparm.setDVBS(self.parm, False)
				self.frontend.tune(tparm, True)
				self.start_time = time()
				tmpstr = _("Try to find used satellite transponders...")
			else:
				tmpstr = _("Nothing to scan! Press Exit!")
			x = { }
			data = self.frontend.getFrontendData(x)
			tuner_no = x["tuner_number"]
		else:
			if "Sundtek DVB-S/S2" in tunername and "V" in tunername:
				tmpstr = _("Use Sundtek full hardware blind scan!")
			else:
				tmpstr = _("Hardware blind scan is not supported by this tuner (%s)!") % tunername
			self.session.open(MessageBox, tmpstr, MessageBox.TYPE_ERROR)
			return
		self.satellite_search_session = self.session.openWithCallback(self.satelliteTransponderSearchSessionClosed, SatBlindscanState, tuner_no, tmpstr)
		#if self.auto_scan:
		self.timer = eTimer()
		self.timer.callback.append(self.updateStateSat)
		self.timer.stop()
		self.updateStateSat()
Exemplo n.º 53
0
    def __init__(self, session, infobar):
        Screen.__init__(self, session)
        self.skin = QuickSubtitlesConfigMenu.skin
        self.infobar = infobar or self.session.infobar

        self.wait = eTimer()
        self.wait.timeout.get().append(self.resyncSubtitles)

        self["videofps"] = Label("")

        sub = self.infobar.selected_subtitle
        if sub[0] == 0:  # dvb
            menu = [
                getConfigMenuItem("config.subtitles.dvb_subtitles_yellow"),
                getConfigMenuItem("config.subtitles.dvb_subtitles_centered"),
                getConfigMenuItem("config.subtitles.dvb_subtitles_backtrans"),
                getConfigMenuItem(
                    "config.subtitles.dvb_subtitles_original_position"),
                getConfigMenuItem("config.subtitles.subtitle_position"),
                getConfigMenuItem(
                    "config.subtitles.subtitle_bad_timing_delay"),
                getConfigMenuItem(
                    "config.subtitles.subtitle_noPTSrecordingdelay"),
            ]
        elif sub[0] == 1:  # teletext
            menu = [
                getConfigMenuItem("config.subtitles.ttx_subtitle_colors"),
                getConfigMenuItem(
                    "config.subtitles.ttx_subtitle_original_position"),
                getConfigMenuItem("config.subtitles.subtitle_fontsize"),
                getConfigMenuItem("config.subtitles.subtitle_position"),
                getConfigMenuItem("config.subtitles.subtitle_rewrap"),
                getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
                getConfigMenuItem("config.subtitles.showbackground"),
                getConfigMenuItem("config.subtitles.subtitle_alignment"),
                getConfigMenuItem(
                    "config.subtitles.subtitle_bad_timing_delay"),
                getConfigMenuItem(
                    "config.subtitles.subtitle_noPTSrecordingdelay"),
            ]
        else:  # pango
            menu = [
                getConfigMenuItem("config.subtitles.pango_subtitles_delay"),
                getConfigMenuItem("config.subtitles.pango_subtitle_colors"),
                getConfigMenuItem(
                    "config.subtitles.pango_subtitle_fontswitch"),
                getConfigMenuItem("config.subtitles.colourise_dialogs"),
                getConfigMenuItem("config.subtitles.subtitle_fontsize"),
                getConfigMenuItem("config.subtitles.subtitle_position"),
                getConfigMenuItem("config.subtitles.subtitle_alignment"),
                getConfigMenuItem("config.subtitles.subtitle_rewrap"),
                getConfigMenuItem("config.subtitles.subtitle_borderwidth"),
                getConfigMenuItem("config.subtitles.showbackground"),
                getConfigMenuItem("config.subtitles.pango_subtitles_fps"),
            ]
            self["videofps"].setText(
                _("Video: %s fps") % (self.getFps().rstrip(".000")))

        ConfigListScreen.__init__(self,
                                  menu,
                                  self.session,
                                  on_change=self.changedEntry)

        self["actions"] = NumberActionMap(["SetupActions"], {
            "cancel": self.cancel,
            "ok": self.ok,
        }, -2)

        self.onLayoutFinish.append(self.layoutFinished)
Exemplo n.º 54
0
    def __init__(self, wakeupData=None):
        if NavigationInstance.instance is not None:
            raise NavigationInstance.instance

        NavigationInstance.instance = self
        self.ServiceHandler = eServiceCenter.getInstance()

        import Navigation as Nav
        Nav.navcore = self

        self.pnav = pNavigation()
        self.pnav.m_event.get().append(self.dispatchEvent)
        self.pnav.m_record_event.get().append(self.dispatchRecordEvent)
        self.event = []
        self.record_event = []
        self.currentlyPlayingServiceReference = None
        self.currentlyPlayingServiceOrGroup = None
        self.currentlyPlayingService = None

        Screens.Standby.TVstate()
        self.skipWakeup = False
        self.skipTVWakeup = False

        self.RecordTimer = None
        self.isRecordTimerImageStandard = False
        for p in plugins.getPlugins(PluginDescriptor.WHERE_RECORDTIMER):
            self.RecordTimer = p()
            if self.RecordTimer:
                break
        if not self.RecordTimer:
            self.RecordTimer = RecordTimer.RecordTimer()
            self.isRecordTimerImageStandard = True

        self.PowerTimer = None
        self.PowerTimer = PowerTimer.PowerTimer()
        self.__wasTimerWakeup = False
        self.__wasRecTimerWakeup = False
        self.__wasPowerTimerWakeup = False

        if not path.exists("/etc/enigma2/.deep"
                           ):  #flag file comes from "/usr/bin/enigma2.sh"
            print "=" * 100
            print "[NAVIGATION] Receiver does not start from Deep Standby - skip wake up detection"
            print "=" * 100
            self.gotopower()
            return
        remove("/etc/enigma2/.deep")

        #wakeup data
        now = time()
        try:
            self.lastshutdowntime, self.wakeuptime, self.timertime, self.wakeuptyp, self.getstandby, self.recordtime, self.forcerecord = [
                int(n) for n in wakeupData.split(',')
            ]
        except:
            print "=" * 100
            print "[NAVIGATION] ERROR: can't read wakeup data"
            self.lastshutdowntime, self.wakeuptime, self.timertime, self.wakeuptyp, self.getstandby, self.recordtime, self.forcerecord = int(
                now), -1, -1, 0, 0, -1, 0
        self.syncCount = 0
        hasFakeTime = (
            now <= 31536000 or now - self.lastshutdowntime <= 120
        ) and self.getstandby < 2  #set hasFakeTime only if lower than values and was last shutdown to deep standby
        wasTimerWakeup, wasTimerWakeup_failure = getFPWasTimerWakeup(True)
        #TODO: verify wakeup-state for boxes where only after shutdown removed the wakeup-state (for boxes where "/proc/stb/fp/was_timer_wakeup" is not writable (clearFPWasTimerWakeup() in StbHardware.py has no effect -> after x hours and restart/reboot is wasTimerWakeup = True)

        if 0:  #debug
            print "#" * 100
            print "[NAVIGATION] timediff from last shutdown to now = %ds" % (
                now - self.lastshutdowntime)
            print "[NAVIGATION] shutdowntime: %s, wakeuptime: %s timertime: %s, recordtime: %s" % (
                ctime(self.lastshutdowntime), ctime(self.wakeuptime),
                ctime(self.timertime), ctime(self.recordtime))
            print "[NAVIGATION] wakeuptyp: %s, getstandby: %s, forcerecord: %s" % (
                {
                    0: "record-timer",
                    1: "zap-timer",
                    2: "power-timer",
                    3: "plugin-timer"
                }[self.wakeuptyp], {
                    0: "no standby",
                    1: "standby",
                    2: "no standby (box was not in deepstandby)"
                }[self.getstandby], self.forcerecord)
            print "#" * 100

        print "=" * 100
        print "[NAVIGATION] was timer wakeup = %s" % wasTimerWakeup
        print "[NAVIGATION] current time is %s -> it's fake-time suspected: %s" % (
            ctime(now), hasFakeTime)
        print "-" * 100

        thisBox = getBoxType()
        if not config.workaround.deeprecord.value and (
                wasTimerWakeup_failure or thisBox in
            ('ixussone', 'uniboxhd1', 'uniboxhd2', 'uniboxhd3', 'sezam5000hd',
             'mbtwin', 'beyonwizt3', 'et8000') or getBrandOEM()
                in ('ebox', 'azbox', 'xp', 'ini', 'fulan', 'entwopia')
                or getMachineBuild() in ('dags7335', 'dags7356', 'dags7362')):
            print "[NAVIGATION] FORCED DEEPSTANDBY-WORKAROUND FOR THIS BOXTYPE (%s)" % thisBox
            print "-" * 100
            config.workaround.deeprecord.setValue(True)
            config.workaround.deeprecord.save()
            config.save()

        if config.workaround.deeprecord.value:  #work-around for boxes where driver not sent was_timer_wakeup signal to e2
            print "[NAVIGATION] starting deepstandby-workaround"
            self.wakeupwindow_plus = self.timertime + 300
            self.wakeupwindow_minus = self.wakeuptime - (
                config.workaround.wakeupwindow.value * 60)
            wasTimerWakeup = False
            if not hasFakeTime and now >= self.wakeupwindow_minus and now <= self.wakeupwindow_plus:  # if there is a recording sheduled, set the wasTimerWakeup flag
                wasTimerWakeup = True
                f = open("/tmp/was_timer_wakeup_workaround.txt", "w")
                file = f.write(str(wasTimerWakeup))
                f.close()
        else:
            #secure wakeup window to prevent a wrong 'wasTimerWakeup' value as timer wakeup detection
            self.wakeupwindow_plus = self.timertime + 900
            self.wakeupwindow_minus = self.wakeuptime - 3600

        if self.wakeuptime > 0:
            print "[NAVIGATION] wakeup time from deep-standby expected: *** %s ***" % (
                ctime(self.wakeuptime))
            if config.workaround.deeprecord.value:
                print "[NAVIGATION] timer wakeup detection window: %s - %s" % (
                    ctime(self.wakeupwindow_minus),
                    ctime(self.wakeupwindow_plus))
        else:
            print "[NAVIGATION] wakeup time was not set"
        print "-" * 100

        if wasTimerWakeup:
            self.__wasTimerWakeup = True
            if not hasFakeTime:
                self.wakeupCheck()
                return

        if hasFakeTime and self.wakeuptime > 0:  # check for NTP-time sync, if no sync, wait for transponder time
            if Screens.Standby.TVinStandby.getTVstandby(
                    'waitfortimesync') and not wasTimerWakeup:
                self.skipTVWakeup = True
                Screens.Standby.TVinStandby.setTVstate('power')
            self.savedOldTime = now
            self.timesynctimer = eTimer()
            self.timesynctimer.callback.append(self.TimeSynctimer)
            self.timesynctimer.start(5000, True)
            print "[NAVIGATION] wait for time sync"
            print "~" * 100
        else:
            self.wakeupCheck(False)
Exemplo n.º 55
0
 def __init__(self):
     self.WeatherInfo = WeatherInfo = {
         "currentLocation": "N/A",
         "currentCountry": "N/A",
         "currentRegion": "N/A",
         "windChill": "N/A",
         "windDirectionShort": "N/A",
         "windDirectionLong": "N/A",
         "windSpeed": "N/A",
         "atmoHumidity": "N/A",
         "atmoPressure": "N/A",
         "atmoRising": "N/A",
         "atmoVisibility": "N/A",
         "astroSunrise": "N/A",
         "astroSunset": "N/A",
         "geoData": "N/A",
         "geoLat": "N/A",
         "geoLong": "N/A",
         "downloadDate": "N/A",
         "downloadTime": "N/A",
         "currentWeatherCode": "(",
         "currentWeatherText": "N/A",
         "currentWeatherTemp": "0",
         "currentWeatherPicon": "3200",
         "forecastTodayCode": "(",
         "forecastTodayDay": "N/A",
         "forecastTodayDate": "N/A",
         "forecastTodayTempMin": "0",
         "forecastTodayTempMax": "0",
         "forecastTodayText": "N/A",
         "forecastTodayPicon": "3200",
         "forecastTomorrowCode": "(",
         "forecastTomorrowDay": "N/A",
         "forecastTomorrowDate": "N/A",
         "forecastTomorrowTempMin": "0",
         "forecastTomorrowTempMax": "0",
         "forecastTomorrowText": "N/A",
         "forecastTomorrowPicon": "3200",
         "forecastTomorrow1Code": "(",
         "forecastTomorrow1Day": "N/A",
         "forecastTomorrow1Date": "N/A",
         "forecastTomorrow1TempMin": "0",
         "forecastTomorrow1TempMax": "0",
         "forecastTomorrow1Text": "N/A",
         "forecastTomorrow1Picon": "3200",
         "forecastTomorrow2Code": "(",
         "forecastTomorrow2Day": "N/A",
         "forecastTomorrow2Date": "N/A",
         "forecastTomorrow2TempMin": "0",
         "forecastTomorrow2TempMax": "0",
         "forecastTomorrow2Text": "N/A",
         "forecastTomorrow2Picon": "3200",
         "forecastTomorrow3Code": "(",
         "forecastTomorrow3Day": "N/A",
         "forecastTomorrow3Date": "N/A",
         "forecastTomorrow3TempMin": "0",
         "forecastTomorrow3TempMax": "0",
         "forecastTomorrow3Text": "N/A",
         "forecastTomorrow3Picon": "3200",
         "forecastTomorrow4Code": "(",
         "forecastTomorrow4Day": "N/A",
         "forecastTomorrow4Date": "N/A",
         "forecastTomorrow4TempMin": "0",
         "forecastTomorrow4TempMax": "0",
         "forecastTomorrow4Text": "N/A",
         "forecastTomorrow4Picon": "3200",
         "forecastTomorrow5Code": "(",
         "forecastTomorrow5Day": "N/A",
         "forecastTomorrow5Date": "N/A",
         "forecastTomorrow5TempMin": "0",
         "forecastTomorrow5TempMax": "0",
         "forecastTomorrow5Text": "N/A",
         "forecastTomorrow5Picon": "3200",
         "forecastTomorrow6Code": "(",
         "forecastTomorrow6Day": "N/A",
         "forecastTomorrow6Date": "N/A",
         "forecastTomorrow6TempMin": "0",
         "forecastTomorrow6TempMax": "0",
         "forecastTomorrow6Text": "N/A",
         "forecastTomorrow6Picon": "3200",
         "forecastTomorrow7Code": "(",
         "forecastTomorrow7Day": "N/A",
         "forecastTomorrow7Date": "N/A",
         "forecastTomorrow7TempMin": "0",
         "forecastTomorrow7TempMax": "0",
         "forecastTomorrow7Text": "N/A",
         "forecastTomorrow7Picon": "3200",
         "forecastTomorrow8Code": "(",
         "forecastTomorrow8Day": "N/A",
         "forecastTomorrow8Date": "N/A",
         "forecastTomorrow8TempMin": "0",
         "forecastTomorrow8TempMax": "0",
         "forecastTomorrow8Text": "N/A",
         "forecastTomorrow8Picon": "3200",
     }
     if config.plugins.AtileHD.refreshInterval.value > 0:
         self.timer = eTimer()
         self.timer.callback.append(self.GetWeather)
         self.GetWeather()
Exemplo n.º 56
0
 def delay(self):
     self.timer = eTimer()
     self.timer.callback.append(self.showPoster)
     self.timer.start(30, True)
Exemplo n.º 57
0
        refreshServiceList()
        self.close(result > 0)

    def Power(self):
        from Screens.Standby import inStandby
        inStandby.Power()
        print("[CableScan] aborted due to power button pressed")
        self.close(True)

    def createSummary(self):
        from Screens.Standby import StandbySummary
        return StandbySummary


Session = None
CableScanAutoStartTimer = eTimer()


def CableScanMain(session, **kwargs):
    session.open(CableScanScreen, nimmanager.getEnabledNimListOfType("DVB-C"))


def restartScanAutoStartTimer(reply=False):
    if reply:
        CableScanAutoStartTimer.startLongTimer(86400)
    else:
        print("[CableScan] Scan was not successful retry in one hour")
        CableScanAutoStartTimer.startLongTimer(3600)


def CableScanAuto():
Exemplo n.º 58
0
 def startProgressTimer(self):
     self.progressTimer = eTimer()
     self.progressTimer.start(5000, True)
     self.progressTimer.callback.append(self.endTimer)
Exemplo n.º 59
0
    def __init__(self, session, piclist, lastindex, path):
        self["key_red"] = Button("")
        self["key_green"] = Button("Slide Show")
        self["key_yellow"] = Button("File View")
        self["key_blue"] = Button(_("Settings"))
        self.textcolor = config.plugins.mc_pp.textcolor.value
        self.color = config.plugins.mc_pp.bgcolor.value
        textsize = 20
        self.spaceX = 20
        self.spaceY = 28
        self.picX = config.plugins.mc_pp.ThumbWidth.value
        self.picY = config.plugins.mc_pp.ThumbHeight.value
        size_w = getDesktop(0).size().width()
        size_h = getDesktop(0).size().height()

        if size_w == 1280:
            self.spaceTop = 130
            self.spaceLeft = 50
            self.ButtonPosY = 95
        else:
            self.spaceTop = 120
            self.spaceLeft = 25
            self.ButtonPosY = 72

        self.thumbsX = size_w / (self.spaceX + self.picX)  # thumbnails in X
        self.thumbsY = size_h / (self.spaceY + self.picY)  # thumbnails in Y
        self.thumbsC = self.thumbsX * self.thumbsY  # all thumbnails
        self.positionlist = []
        skincontent = ""

        posX = -1
        for x in range(self.thumbsC):
            posY = x / self.thumbsX
            posX += 1
            if posX >= self.thumbsX:
                posX = 0
            absX = self.spaceLeft + self.spaceX + (posX *
                                                   (self.spaceX + self.picX))
            absY = self.spaceTop + self.spaceY + (posY *
                                                  (self.spaceY + self.picY))
            self.positionlist.append((absX, absY))
            skincontent += "<widget name=\"label" + str(
                x
            ) + "\" position=\"" + str(absX + 5) + "," + str(
                absY + self.picY - textsize
            ) + "\" size=\"" + str(self.picX - 10) + "," + str(
                textsize
            ) + "\" font=\"Regular;14\" zPosition=\"2\" transparent=\"1\" noWrap=\"1\" foregroundColor=\"" + self.textcolor + "\" />"
            skincontent += "<widget name=\"thumb" + str(
                x) + "\" position=\"" + str(absX + 5) + "," + str(
                    absY + 5
                ) + "\" size=\"" + str(self.picX - 10) + "," + str(
                    self.picY - (textsize * 2)
                ) + "\" zPosition=\"2\" transparent=\"1\" alphatest=\"on\" />"
        # Screen, buttons, backgroundlabel and MovingPixmap
        self.skin = "<screen position=\"0,0\" size=\"" + str(
            size_w
        ) + "," + str(size_h) + "\" flags=\"wfNoBorder\" > \
			<ePixmap name=\"mb_bg\" position=\"0,0\" zPosition=\"1\" size=\"" + str(
            size_w
        ) + "," + str(
            size_h
        ) + "\" pixmap=\"" + mcpath + "skins/defaultHD/images/background.png\" /> \
			<ePixmap pixmap=\"" + mcpath + "icons/key-red.png\" position=\"60," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
			<ePixmap pixmap=\"" + mcpath + "icons/key-green.png\" position=\"210," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
			<ePixmap pixmap=\"" + mcpath + "icons/key-yellow.png\" position=\"360," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
			<ePixmap pixmap=\"" + mcpath + "icons/key-blue.png\" position=\"510," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"2\" size=\"140,40\" transparent=\"1\" alphatest=\"on\" /> \
			<widget name=\"key_red\" position=\"60," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#9f1313\" transparent=\"1\" /> \
			<widget name=\"key_green\" position=\"210," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#1f771f\" transparent=\"1\" /> \
			<widget name=\"key_yellow\" position=\"360," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#a08500\" transparent=\"1\" /> \
			<widget name=\"key_blue\" position=\"510," + str(
            self.ButtonPosY
        ) + "\" zPosition=\"3\" size=\"140,40\" font=\"Regular;20\" valign=\"center\" halign=\"center\" backgroundColor=\"#18188b\" transparent=\"1\" /> \
			<eLabel position=\"0,0\" zPosition=\"0\" size=\"" + str(size_w) + "," + str(
            size_h
        ) + "\" backgroundColor=\"" + self.color + "\" /> \
			<widget name=\"frame\" position=\"35,30\" size=\"" + str(
            self.picX + 1
        ) + "," + str(
            self.picY +
            10
        ) + "\" pixmap=\"pic_frame.png\" zPosition=\"3\" alphatest=\"on\" />" + skincontent + "</screen>"
        Screen.__init__(self, session)

        self["actions"] = HelpableActionMap(
            self, "MC_PictureViewerActions", {
                "ok": (self.KeyOk, "Show Picture"),
                "cancel": (self.Exit, "Exit Picture Viewer"),
                "left": (self.key_left, "List Top"),
                "right": (self.key_right, "List Bottom"),
                "up": (self.key_up, "List up"),
                "down": (self.key_down, "List down"),
                "info": (self.StartExif, "Show File Info"),
                "green": (self.startslideshow, "Start Slideshow"),
                "yellow": (self.close, "File View"),
                "blue": (self.Settings, "Settings"),
            }, -2)
        self["frame"] = MovingPixmap()
        for x in range(self.thumbsC):
            self["label" + str(x)] = Label()
            self["thumb" + str(x)] = Pixmap()
        self.Thumbnaillist = []
        self.filelist = []
        self.currPage = -1
        self.dirlistcount = 0
        self.path = path
        index = 0
        framePos = 0
        Page = 0
        for x in piclist:
            if x[0][1] == False:
                self.filelist.append(
                    (index, framePos, Page, x[0][0], path + x[0][0]))
                index += 1
                framePos += 1
                if framePos > (self.thumbsC - 1):
                    framePos = 0
                    Page += 1
            else:
                self.dirlistcount += 1

        self.maxentry = len(self.filelist) - 1
        self.index = lastindex - self.dirlistcount
        if self.index < 0:
            self.index = 0

        self.picload = ePicLoad()
        self.picload.PictureData.get().append(self.showPic)
        self.onLayoutFinish.append(self.setPicloadConf)
        self.ThumbTimer = eTimer()
        self.ThumbTimer.callback.append(self.showPic)
Exemplo n.º 60
0
	def __init__(self, session, args = 0):
		self.session = session
		Screen.__init__(self, session)
		self.text=""
		self.text="Emu OScam, Ncam, Gcam and CCcam arm mips All ipk and deb For enigma2"
### EDit By RAED To DreamOS OE2.5/2.6
		if fileExists('/var/lib/dpkg/status'):
		     self.wget = "/usr/bin/wget2 --no-check-certificate"
		else:
		     self.wget = "/usr/bin/wget"

### End
		self["myText"] = Label()
		self["go"] = Label()	
		self["goto"] = Label()		
		self["prombt"] = Label()	      
		self["myRedBtn"] = Label(_("Cancel"))
		self["myGreenBtn"] = Label(_("OSCAM"))
		self["myYellowBtn"] = Label(_("NCAM"))
		self["myBlueBtn"] = Label(_("GCAM"))                		
		self.cmdlist = []
		self['text'] = Label()
                self["key_blue"] = Label()
                self["key_yellow"] = Label()
                self["key_green"] = Label()
                self["key_red"] = Label()	
		self['icon'] = Pixmap()  
		self['icon2'] = Pixmap()                  
		self['icon3'] = Pixmap() 
		self['icon4'] = Pixmap()                                           
                self['Btn'] = Pixmap()
                self['Bt1'] = Pixmap()
                self['Bt2'] = Pixmap()
                self['Bt3'] = Pixmap()    
                self['Bt4'] = Pixmap() 
                self['Bt5'] = Pixmap()  
                self['Bt6'] = Pixmap()                                		
		#self["myMenu"] = MenuList(list)
		self['actions'] = ActionMap(['MovieSelectionActions', 'SetupActions', 'DirectionActions', 'ColorActions'], {'ok': self.close,
                        "showEventInfo": self.gotoa,	
                        '0': self.restart, 
                        '1': self.goc,                           		
                        'blue': self.got,   
                        'yellow': self.goto,                        
                        #'ok': self.go,		                           
                        'red': self.close,
                        'cancel': self.cancel,
                        'green': self.go}, -1)
                self.onShown.append(self.setMyText)
                self.go               
		self.goto
                self.got               
		self.goc
		self.prombt
        	self.onChangedEntry = []
		self.timer_list = []
		self.processed_timers = [] 
		self.timer = eTimer()
		self.initialservice = session.nav.getCurrentlyPlayingServiceReference()
		self.updateTimer = eTimer()
		self.timer.start(2000, True)