class PositionerSetup(Screen): @staticmethod def satposition2metric(position): if position > 1800: position = 3600 - position orientation = "west" else: orientation = "east" return position, orientation @staticmethod def orbital2metric(position, orientation): if orientation == "west": position = 360 - position if orientation == "south": position = - position return position @staticmethod def longitude2orbital(position): if position >= 180: return 360 - position, "west" else: return position, "east" @staticmethod def latitude2orbital(position): if position >= 0: return position, "north" else: return -position, "south" UPDATE_INTERVAL = 50 # milliseconds STATUS_MSG_TIMEOUT = 2 # seconds LOG_SIZE = 16 * 1024 # log buffer size def __init__(self, session, feid): self.session = session Screen.__init__(self, session) self.feid = feid self.oldref = None log.open(self.LOG_SIZE) if config.Nims[self.feid].configMode.value == 'advanced': self.advanced = True self.advancedconfig = config.Nims[self.feid].advanced self.advancedsats = self.advancedconfig.sat self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid)) else: self.advanced = False cur = { } if not self.openFrontend(): self.oldref = session.nav.getCurrentlyPlayingServiceReference() service = session.nav.getCurrentService() feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData(True) del feInfo del service session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if session.pipshown: # try to disable pip service = self.session.pip.pipservice feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData(True) del feInfo del service from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() if not self.openFrontend(): self.frontend = None # in normal case this should not happen if hasattr(self, 'raw_channel'): del self.raw_channel self.frontendStatus = { } self.diseqc = Diseqc(self.frontend) # True means we dont like that the normal sec stuff sends commands to the rotor! self.tuner = Tuner(self.frontend, ignore_rotor = True) tp = ( cur.get("frequency", 0) / 1000, cur.get("symbol_rate", 0) / 1000, cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal), cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto), cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown), cur.get("orbital_position", 0), cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S), cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK), cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)) self.tuner.tune(tp) self.isMoving = False self.stopOnLock = False self.red = Button("") self["key_red"] = self.red self.green = Button("") self["key_green"] = self.green self.yellow = Button("") self["key_yellow"] = self.yellow self.blue = Button("") self["key_blue"] = self.blue self.list = [] self["list"] = ConfigList(self.list) self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus) self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus) self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus) self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus) self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus) self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus) self["frequency_value"] = Label("") self["symbolrate_value"] = Label("") self["fec_value"] = Label("") self["polarisation"] = Label("") self["status_bar"] = Label("") self.statusMsgTimeoutTicks = 0 self.statusMsgBlinking = False self.statusMsgBlinkCount = 0 self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL # milliseconds self.tuningChangedTo(tp) self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"], { "ok": self.keyOK, "cancel": self.keyCancel, "up": self.keyUp, "down": self.keyDown, "left": self.keyLeft, "right": self.keyRight, "red": self.redKey, "green": self.greenKey, "yellow": self.yellowKey, "blue": self.blueKey, "log": self.showLog, "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.updateColors("tune") self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) self.collectingStatistics = False self.statusTimer.start(self.UPDATE_INTERVAL, True) self.dataAvailable = Event() self.onClose.append(self.__onClose) self.createConfig() self.createSetup() def __onClose(self): self.statusTimer.stop() log.close() self.session.nav.playService(self.oldref) def restartPrevService(self, yesno): if yesno: if self.frontend: self.frontend = None del self.raw_channel else: self.oldref=None self.close(None) def keyCancel(self): if self.oldref: self.session.openWithCallback(self.restartPrevService, MessageBox, _("Zap back to service before positioner setup?"), MessageBox.TYPE_YESNO) else: self.restartPrevService(False) def openFrontend(self): res_mgr = eDVBResourceManager.getInstance() if res_mgr: self.raw_channel = res_mgr.allocateRawChannel(self.feid) if self.raw_channel: self.frontend = self.raw_channel.getFrontend() if self.frontend: return True else: print "getFrontend failed" else: print "getRawChannel failed" else: print "getResourceManager instance failed" return False def setLNB(self, lnb): try: self.sitelon = lnb.longitude.float self.longitudeOrientation = lnb.longitudeOrientation.value self.sitelat = lnb.latitude.float self.latitudeOrientation = lnb.latitudeOrientation.value self.tuningstepsize = lnb.tuningstepsize.float self.rotorPositions = lnb.rotorPositions.value self.turningspeedH = lnb.turningspeedH.float self.turningspeedV = lnb.turningspeedV.float except: # some reasonable defaults from NimManager self.sitelon = 5.1 self.longitudeOrientation = 'east' self.sitelat = 50.767 self.latitudeOrientation = 'north' self.tuningstepsize = 0.36 self.rotorPositions = 99 self.turningspeedH = 2.3 self.turningspeedV = 1.7 self.sitelat = PositionerSetup.orbital2metric(self.sitelat, self.latitudeOrientation) self.sitelon = PositionerSetup.orbital2metric(self.sitelon, self.longitudeOrientation) def getLNBfromConfig(self, orb_pos): lnb = None if orb_pos in self.availablesats: lnbnum = int(self.advancedsats[orb_pos].lnb.value) if not lnbnum: for allsats in range(3601, 3607): lnbnum = int(self.advancedsats[allsats].lnb.value) if lnbnum: break if lnbnum: self.printMsg(_("Using LNB %d") % lnbnum) lnb = self.advancedconfig.lnb[lnbnum] if not lnb: self.logMsg(_("Warning: no LNB; using factory defaults."), timeout = 4) return lnb def createConfig(self): rotorposition = 1 orb_pos = 0 self.printMsg(_("Using tuner %s") % chr(0x41 + self.feid)) if not self.advanced: self.printMsg(_("Configuration mode: %s") % _("simple")) nim = config.Nims[self.feid] self.sitelon = nim.longitude.float self.longitudeOrientation = nim.longitudeOrientation.value self.sitelat = nim.latitude.float self.latitudeOrientation = nim.latitudeOrientation.value self.sitelat = PositionerSetup.orbital2metric(self.sitelat, self.latitudeOrientation) self.sitelon = PositionerSetup.orbital2metric(self.sitelon, self.longitudeOrientation) self.tuningstepsize = nim.tuningstepsize.float self.rotorPositions = nim.rotorPositions.value self.turningspeedH = nim.turningspeedH.float self.turningspeedV = nim.turningspeedV.float else: # it is advanced self.printMsg(_("Configuration mode: %s") % _("advanced")) fe_data = { } self.frontend.getFrontendData(fe_data) self.frontend.getTransponderData(fe_data, True) orb_pos = fe_data.get("orbital_position", None) if orb_pos in self.availablesats: rotorposition = int(self.advancedsats[orb_pos].rotorposition.value) self.setLNB(self.getLNBfromConfig(orb_pos)) self.positioner_tune = ConfigNothing() self.positioner_move = ConfigNothing() self.positioner_finemove = ConfigNothing() self.positioner_limits = ConfigNothing() self.positioner_storage = ConfigInteger(default = rotorposition, limits = (1, self.rotorPositions)) self.allocatedIndices = [] m = PositionerSetup.satposition2metric(orb_pos) self.orbitalposition = ConfigFloat(default = [int(m[0] / 10), m[0] % 10], limits = [(0,180),(0,9)]) self.orientation = ConfigSelection([("east", _("East")), ("west", _("West"))], m[1]) def createSetup(self): self.list.append((_("Tune and focus"), self.positioner_tune, "tune")) self.list.append((_("Movement"), self.positioner_move, "move")) self.list.append((_("Fine movement"), self.positioner_finemove, "finemove")) self.list.append((_("Set limits"), self.positioner_limits, "limits")) self.list.append((_("Memory index"), self.positioner_storage, "storage")) self.list.append((_("Goto"), self.orbitalposition, "goto")) self.list.append((" ", self.orientation, "goto")) self["list"].l.setList(self.list) def keyOK(self): pass def getCurrentConfigPath(self): return self["list"].getCurrent()[2] def keyUp(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveUp) self.updateColors(self.getCurrentConfigPath()) def keyDown(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveDown) self.updateColors(self.getCurrentConfigPath()) def keyNumberGlobal(self, number): self["list"].handleKey(KEY_0 + number) def keyLeft(self): self["list"].handleKey(KEY_LEFT) def keyRight(self): self["list"].handleKey(KEY_RIGHT) def updateColors(self, entry): if entry == "tune": self.red.setText(_("Tune")) self.green.setText(_("Auto focus")) self.yellow.setText(_("Calibrate")) self.blue.setText(_("Calculate")) elif entry == "move": if self.isMoving: self.red.setText(_("Stop")) self.green.setText(_("Stop")) self.yellow.setText(_("Stop")) self.blue.setText(_("Stop")) else: self.red.setText(_("Move west")) self.green.setText(_("Search west")) self.yellow.setText(_("Search east")) self.blue.setText(_("Move east")) elif entry == "finemove": self.red.setText("") self.green.setText(_("Step west")) self.yellow.setText(_("Step east")) self.blue.setText("") elif entry == "limits": self.red.setText(_("Limits off")) self.green.setText(_("Limit west")) self.yellow.setText(_("Limit east")) self.blue.setText(_("Limits on")) elif entry == "storage": self.red.setText("") self.green.setText(_("Store position")) self.yellow.setText(_("Goto position")) if self.advanced: self.blue.setText(_("Allocate")) else: self.blue.setText("") elif entry == "goto": self.red.setText("") self.green.setText(_("Goto 0")) self.yellow.setText(_("Goto X")) self.blue.setText("") else: self.red.setText("") self.green.setText("") self.yellow.setText("") self.blue.setText("") def printMsg(self, msg): print msg print>>log, msg def stopMoving(self): self.printMsg(_("Stop")) self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False self.statusMsg(_("Stopped"), timeout = self.STATUS_MSG_TIMEOUT) def redKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Move west")) self.diseqccommand("moveWest", 0) self.isMoving = True self.statusMsg(_("Moving west ..."), blinking = True) self.updateColors("move") elif entry == "limits": self.printMsg(_("Limits off")) self.diseqccommand("limitOff") self.statusMsg(_("Limits cancelled"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "tune": fe_data = { } self.frontend.getFrontendData(fe_data) self.frontend.getTransponderData(fe_data, True) feparm = self.tuner.lastparm.getDVBS() fe_data["orbital_position"] = feparm.orbital_position self.statusTimer.stop() self.session.openWithCallback(self.tune, TunerScreen, self.feid, fe_data) def greenKey(self): entry = self.getCurrentConfigPath() if entry == "tune": # Auto focus self.printMsg(_("Auto focus")) print>>log, (_("Site latitude") + " : %5.1f %s") % PositionerSetup.latitude2orbital(self.sitelat) print>>log, (_("Site longitude") + " : %5.1f %s") % PositionerSetup.longitude2orbital(self.sitelon) Thread(target = self.autofocus).start() elif entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Search west")) self.isMoving = True self.stopOnLock = True self.diseqccommand("moveWest", 0) self.statusMsg(_("Searching west ..."), blinking = True) self.updateColors("move") elif entry == "finemove": self.printMsg(_("Step west")) self.diseqccommand("moveWest", 0xFF) # one step self.statusMsg(_("Stepped west"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "storage": self.printMsg(_("Store at index")) index = int(self.positioner_storage.value) self.diseqccommand("store", index) self.statusMsg((_("Position stored at index") + " %2d") % index, timeout = self.STATUS_MSG_TIMEOUT) elif entry == "limits": self.printMsg(_("Limit west")) self.diseqccommand("limitWest") self.statusMsg(_("West limit set"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "goto": self.printMsg(_("Goto 0")) self.diseqccommand("moveTo", 0) self.statusMsg(_("Moved to position 0"), timeout = self.STATUS_MSG_TIMEOUT) def yellowKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Move east")) self.isMoving = True self.stopOnLock = True self.diseqccommand("moveEast", 0) self.statusMsg(_("Searching east ..."), blinking = True) self.updateColors("move") elif entry == "finemove": self.printMsg(_("Step east")) self.diseqccommand("moveEast", 0xFF) # one step self.statusMsg(_("Stepped east"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "storage": self.printMsg(_("Goto index position")) index = int(self.positioner_storage.value) self.diseqccommand("moveTo", index) self.statusMsg((_("Moved to position at index") + " %2d") % index, timeout = self.STATUS_MSG_TIMEOUT) elif entry == "limits": self.printMsg(_("Limit east")) self.diseqccommand("limitEast") self.statusMsg(_("East limit set"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "goto": self.printMsg(_("Move to position X")) satlon = self.orbitalposition.float position = "%5.1f %s" % (satlon, self.orientation.value) print>>log, (_("Satellite longitude:") + " %s") % position satlon = PositionerSetup.orbital2metric(satlon, self.orientation.value) self.statusMsg((_("Moving to position") + " %s") % position, timeout = self.STATUS_MSG_TIMEOUT) self.gotoX(satlon) elif entry == "tune": # Start USALS calibration self.printMsg(_("USALS calibration")) print>>log, (_("Site latitude") + " : %5.1f %s") % PositionerSetup.latitude2orbital(self.sitelat) print>>log, (_("Site longitude") + " : %5.1f %s") % PositionerSetup.longitude2orbital(self.sitelon) Thread(target = self.gotoXcalibration).start() def blueKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Move east")) self.diseqccommand("moveEast", 0) self.isMoving = True self.statusMsg(_("Moving east ..."), blinking = True) self.updateColors("move") elif entry == "limits": self.printMsg(_("Limits on")) self.diseqccommand("limitOn") self.statusMsg(_("Limits enabled"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "tune": # Start (re-)calculate self.session.openWithCallback(self.recalcConfirmed, MessageBox, _("This will (re-)calculate all positions of your rotor and may remove previously memorised positions and fine-tuning!\nAre you sure?"), MessageBox.TYPE_YESNO, default = False, timeout = 10) elif entry == "storage": if self.advanced: self.printMsg(_("Allocate unused memory index")) while True: if not len(self.allocatedIndices): for sat in self.availablesats: current_index = int(self.advancedsats[sat].rotorposition.value) if current_index not in self.allocatedIndices: self.allocatedIndices.append(current_index) if len(self.allocatedIndices) == self.rotorPositions: self.statusMsg(_("No free index available"), timeout = self.STATUS_MSG_TIMEOUT) break index = 1 if len(self.allocatedIndices): for i in sorted(self.allocatedIndices): if i != index: break index += 1 if index <= self.rotorPositions: self.positioner_storage.value = index self["list"].invalidateCurrent() self.allocatedIndices.append(index) self.statusMsg((_("Index allocated:") + " %2d") % index, timeout = self.STATUS_MSG_TIMEOUT) break else: self.allocatedIndices = [] def recalcConfirmed(self, yesno): if yesno: self.printMsg(_("Calculate all positions")) print>>log, (_("Site latitude") + " : %5.1f %s") % PositionerSetup.latitude2orbital(self.sitelat) print>>log, (_("Site longitude") + " : %5.1f %s") % PositionerSetup.longitude2orbital(self.sitelon) lon = self.sitelon if lon >= 180: lon -= 360 if lon < -30: # americas, make unsigned binary west positive polarity lon = -lon lon = int(round(lon)) & 0xFF lat = int(round(self.sitelat)) & 0xFF index = int(self.positioner_storage.value) & 0xFF self.diseqccommand("calc", (((index << 8) | lon) << 8) | lat) self.statusMsg(_("Calculation complete"), timeout = self.STATUS_MSG_TIMEOUT) def showLog(self): self.session.open(PositionerSetupLog) def diseqccommand(self, cmd, param = 0): print>>log, "Diseqc(%s, %X)" % (cmd, param) self.diseqc.command(cmd, param) self.tuner.retune() def tune(self, transponder): # re-start the update timer self.statusTimer.start(self.UPDATE_INTERVAL, True) if transponder is not None: self.tuner.tune(transponder) self.tuningChangedTo(transponder) feparm = self.tuner.lastparm.getDVBS() orb_pos = feparm.orbital_position m = PositionerSetup.satposition2metric(orb_pos) self.orbitalposition.value = [int(m[0] / 10), m[0] % 10] self.orientation.value = m[1] if self.advanced: if orb_pos in self.availablesats: rotorposition = int(self.advancedsats[orb_pos].rotorposition.value) self.positioner_storage.value = rotorposition self.allocatedIndices = [] self.setLNB(self.getLNBfromConfig(orb_pos)) def isLocked(self): return self.frontendStatus.get("tuner_locked", 0) == 1 def statusMsg(self, msg, blinking = False, timeout = 0): # timeout in seconds self.statusMsgBlinking = blinking if not blinking: self["status_bar"].visible = True self["status_bar"].setText(msg) self.statusMsgTimeoutTicks = (timeout * 1000 + self.UPDATE_INTERVAL / 2) / self.UPDATE_INTERVAL def updateStatus(self): self.statusTimer.start(self.UPDATE_INTERVAL, True) if self.frontend: self.frontend.getFrontendStatus(self.frontendStatus) self["snr_db"].update() self["snr_percentage"].update() self["ber_value"].update() self["snr_bar"].update() self["ber_bar"].update() self["lock_state"].update() if self.statusMsgBlinking: self.statusMsgBlinkCount += 1 if self.statusMsgBlinkCount == self.statusMsgBlinkRate: self.statusMsgBlinkCount = 0 self["status_bar"].visible = not self["status_bar"].visible if self.statusMsgTimeoutTicks > 0: self.statusMsgTimeoutTicks -= 1 if self.statusMsgTimeoutTicks == 0: self["status_bar"].setText("") self.statusMsgBlinking = False self["status_bar"].visible = True if self.isLocked() and self.isMoving and self.stopOnLock: self.stopMoving() self.updateColors(self.getCurrentConfigPath()) if self.collectingStatistics: self.low_rate_adapter_count += 1 if self.low_rate_adapter_count == self.MAX_LOW_RATE_ADAPTER_COUNT: self.low_rate_adapter_count = 0 self.snr_percentage += self["snr_percentage"].getValue(TunerInfo.SNR) self.lock_count += self["lock_state"].getValue(TunerInfo.LOCK) self.stat_count += 1 if self.stat_count == self.max_count: self.collectingStatistics = False count = float(self.stat_count) self.lock_count /= count self.snr_percentage *= 100.0 / 0x10000 / count self.dataAvailable.set() def tuningChangedTo(self, tp): def setLowRateAdapterCount(symbolrate): # change the measurement time and update interval in case of low symbol rate, # since more time is needed for the front end in that case. # It is an heuristic determination without any pretence. For symbol rates # of 5000 the interval is multiplied by 3 until 15000 which is seen # as a high symbol rate. Linear interpolation elsewhere. return max(int(round((3 - 1) * (symbolrate - 15000) / (5000 - 15000) + 1)), 1) self.symbolrate = tp[1] self.polarisation = tp[2] self.MAX_LOW_RATE_ADAPTER_COUNT = setLowRateAdapterCount(self.symbolrate) transponderdata = ConvertToHumanReadable(self.tuner.getTransponderData(), "DVB-S") self["frequency_value"].setText(str(transponderdata.get("frequency"))) self["symbolrate_value"].setText(str(transponderdata.get("symbol_rate"))) self["fec_value"].setText(str(transponderdata.get("fec_inner"))) self["polarisation"].setText(str(transponderdata.get("polarization"))) @staticmethod def rotorCmd2Step(rotorCmd, stepsize): return round(float(rotorCmd & 0xFFF) / 0x10 / stepsize) * (1 - ((rotorCmd & 0x1000) >> 11)) @staticmethod def gotoXcalc(satlon, sitelat, sitelon): def azimuth2Rotorcode(angle): gotoXtable = (0x00, 0x02, 0x03, 0x05, 0x06, 0x08, 0x0A, 0x0B, 0x0D, 0x0E) a = int(round(abs(angle) * 10.0)) return ((a / 10) << 4) + gotoXtable[a % 10] satHourAngle = rotor_calc.calcSatHourangle(satlon, sitelat, sitelon) if sitelat >= 0: # Northern Hemisphere rotorCmd = azimuth2Rotorcode(180 - satHourAngle) if satHourAngle <= 180: # the east rotorCmd |= 0xE000 else: # west rotorCmd |= 0xD000 else: # Southern Hemisphere if satHourAngle <= 180: # the east rotorCmd = azimuth2Rotorcode(satHourAngle) | 0xD000 else: # west rotorCmd = azimuth2Rotorcode(360 - satHourAngle) | 0xE000 return rotorCmd def gotoX(self, satlon): rotorCmd = PositionerSetup.gotoXcalc(satlon, self.sitelat, self.sitelon) self.diseqccommand("gotoX", rotorCmd) x = PositionerSetup.rotorCmd2Step(rotorCmd, self.tuningstepsize) print>>log, (_("Rotor step position:") + " %4d") % x return x def getTurningspeed(self): if self.polarisation == eDVBFrontendParametersSatellite.Polarisation_Horizontal: turningspeed = self.turningspeedH else: turningspeed = self.turningspeedV return max(turningspeed, 0.1) TURNING_START_STOP_DELAY = 1.600 # seconds MAX_SEARCH_ANGLE = 12.0 # degrees MAX_FOCUS_ANGLE = 6.0 # degrees LOCK_LIMIT = 0.1 # ratio MEASURING_TIME = 2.500 # seconds def measure(self, time = MEASURING_TIME): # time in seconds self.snr_percentage = 0.0 self.lock_count = 0.0 self.stat_count = 0 self.low_rate_adapter_count = 0 self.max_count = max(int((time * 1000 + self.UPDATE_INTERVAL / 2)/ self.UPDATE_INTERVAL), 1) self.collectingStatistics = True self.dataAvailable.clear() self.dataAvailable.wait() def logMsg(self, msg, timeout = 0): self.statusMsg(msg, timeout = timeout) self.printMsg(msg) def sync(self): self.lock_count = 0.0 n = 0 while self.lock_count < (1 - self.LOCK_LIMIT) and n < 5: self.measure(time = 0.500) n += 1 if self.lock_count < (1 - self.LOCK_LIMIT): return False return True randomGenerator = None def randomBool(self): if self.randomGenerator is None: self.randomGenerator = SystemRandom() return self.randomGenerator.random() >= 0.5 def gotoXcalibration(self): def move(x): z = self.gotoX(x + satlon) time = int(abs(x - prev_pos) / turningspeed + 2 * self.TURNING_START_STOP_DELAY) sleep(time * self.MAX_LOW_RATE_ADAPTER_COUNT) return z def reportlevels(pos, level, lock): print>>log, (_("Signal quality") + " %5.1f" + chr(176) + " : %6.2f") % (pos, level) print>>log, (_("Lock ratio") + " %5.1f" + chr(176) + " : %6.2f") % (pos, lock) def optimise(readings): xi = readings.keys() yi = map(lambda (x, y) : x, readings.values()) x0 = sum(map(mul, xi, yi)) / sum(yi) xm = xi[yi.index(max(yi))] return x0, xm def toGeopos(x): if x < 0: return _("W") else: return _("E") def toGeoposEx(x): if x < 0: return _("west") else: return _("east") self.logMsg(_("GotoX calibration")) satlon = self.orbitalposition.float print>>log, (_("Satellite longitude:") + " %5.1f" + chr(176) + " %s") % (satlon, self.orientation.value) satlon = PositionerSetup.orbital2metric(satlon, self.orientation.value) prev_pos = 0.0 # previous relative position w.r.t. satlon turningspeed = self.getTurningspeed() x = 0.0 # relative position w.r.t. satlon dir = 1 if self.randomBool(): dir = -dir while abs(x) < self.MAX_SEARCH_ANGLE: if self.sync(): break x += (1.0 * dir) # one degree east/west self.statusMsg((_("Searching") + " " + toGeoposEx(dir) + " %2d" + chr(176)) % abs(x), blinking = True) move(x) prev_pos = x else: x = 0.0 dir = -dir while abs(x) < self.MAX_SEARCH_ANGLE: x += (1.0 * dir) # one degree east/west self.statusMsg((_("Searching") + " " + toGeoposEx(dir) + " %2d" + chr(176)) % abs(x), blinking = True) move(x) prev_pos = x if self.sync(): break else: msg = _("Cannot find any signal ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return x = round(x / self.tuningstepsize) * self.tuningstepsize move(x) prev_pos = x measurements = {} self.measure() print>>log, (_("Initial signal quality") + " %5.1f" + chr(176) + ": %6.2f") % (x, self.snr_percentage) print>>log, (_("Initial lock ratio") + " %5.1f" + chr(176) + ": %6.2f") % (x, self.lock_count) measurements[x] = (self.snr_percentage, self.lock_count) start_pos = x x = 0.0 dir = 1 if self.randomBool(): dir = -dir while x < self.MAX_FOCUS_ANGLE: x += self.tuningstepsize * dir # one step east/west self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %5.1f" + chr(176)) % abs(x + start_pos), blinking = True) move(x + start_pos) prev_pos = x + start_pos self.measure() measurements[x + start_pos] = (self.snr_percentage, self.lock_count) reportlevels(x + start_pos, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return x = 0.0 dir = -dir self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %5.1f" + chr(176)) % abs(start_pos), blinking = True) move(start_pos) prev_pos = start_pos if not self.sync(): msg = _("Sync failure moving back to origin !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return while abs(x) < self.MAX_FOCUS_ANGLE: x += self.tuningstepsize * dir # one step west/east self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %5.1f" + chr(176)) % abs(x + start_pos), blinking = True) move(x + start_pos) prev_pos = x + start_pos self.measure() measurements[x + start_pos] = (self.snr_percentage, self.lock_count) reportlevels(x + start_pos, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return (x0, xm) = optimise(measurements) x = move(x0) if satlon > 180: satlon -= 360 x0 += satlon xm += satlon print>>log, (_("Weighted position") + " : %5.1f" + chr(176) + " %s") % (abs(x0), toGeopos(x0)) print>>log, (_("Strongest position") + " : %5.1f" + chr(176) + " %s") % (abs(xm), toGeopos(xm)) self.logMsg((_("Final position at") + " %5.1f" + chr(176) + " %s / %d; " + _("offset is") + " %4.1f" + chr(176)) % (abs(x0), toGeopos(x0), x, x0 - satlon), timeout = 10) def autofocus(self): def move(x): if x > 0: self.diseqccommand("moveEast", (-x) & 0xFF) elif x < 0: self.diseqccommand("moveWest", x & 0xFF) if x != 0: time = int(abs(x) * self.tuningstepsize / turningspeed + 2 * self.TURNING_START_STOP_DELAY) sleep(time * self.MAX_LOW_RATE_ADAPTER_COUNT) def reportlevels(pos, level, lock): print>>log, (_("Signal quality") + " [%2d] : %6.2f") % (pos, level) print>>log, (_("Lock ratio") + " [%2d] : %6.2f") % (pos, lock) def optimise(readings): xi = readings.keys() yi = map(lambda (x, y) : x, readings.values()) x0 = int(round(sum(map(mul, xi, yi)) / sum(yi))) xm = xi[yi.index(max(yi))] return x0, xm def toGeoposEx(x): if x < 0: return _("west") else: return _("east") self.logMsg(_("Auto focus commencing ...")) turningspeed = self.getTurningspeed() measurements = {} maxsteps = max(min(round(self.MAX_FOCUS_ANGLE / self.tuningstepsize), 0x1F), 3) self.measure() print>>log, (_("Initial signal quality:") + " %6.2f") % self.snr_percentage print>>log, (_("Initial lock ratio") + " : %6.2f") % self.lock_count if self.lock_count < 1 - self.LOCK_LIMIT: msg = _("There is no signal to lock on !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return print>>log, _("Signal OK, proceeding") x = 0 dir = 1 if self.randomBool(): dir = -dir measurements[x] = (self.snr_percentage, self.lock_count) nsteps = 0 while nsteps < maxsteps: x += dir self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %2d") % abs(x), blinking = True) move(dir) # one step self.measure() measurements[x] = (self.snr_percentage, self.lock_count) reportlevels(x, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break nsteps += 1 else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return dir = -dir self.statusMsg(_("Moving") + " " + toGeoposEx(dir) + " 0", blinking = True) move(-x) if not self.sync(): msg = _("Sync failure moving back to origin !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return x = 0 nsteps = 0 while nsteps < maxsteps: x += dir self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %2d") % abs(x), blinking = True) move(dir) # one step self.measure() measurements[x] = (self.snr_percentage, self.lock_count) reportlevels(x, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break nsteps += 1 else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return (x0, xm) = optimise(measurements) print>>log, (_("Weighted position") + " : %2d") % x0 print>>log, (_("Strongest position") + " : %2d") % xm self.logMsg((_("Final position at index") + " %2d (%5.1f" + chr(176) + ")") % (x0, x0 * self.tuningstepsize), timeout = 6) move(x0 - x)
def __init__(self, session, items, service=None): Screen.__init__(self, session) self.skinName = SkinTools.appendResolution( "AdvancedMovieSelectionDownload") self.onShow.append(self.selectionChanged) self.service = service self["logo"] = Pixmap() self["info"] = Label() self["title"] = Label() self["poster"] = Pixmap() self["poster"].hide() self["description"] = ScrollLabel() self["key_red"] = Button(_("Cancel")) self["key_green"] = Button("") self["key_yellow"] = Button("") self["key_yellow"] = Label(_("Manual search")) if self.service is not None: self["key_green"] = Label(_("Save infos/cover")) else: self["key_green"] = Label(_("Background")) self["key_yellow"].hide() self["ActionsMap"] = ActionMap( ["SetupActions", "ColorActions"], { "ok": self.titleSelected, "green": self.titleSelected, "red": self.__cancel, "yellow": self.editTitle, "cancel": self.__cancel, "left": self.scrollLabelPageUp, "right": self.scrollLabelPageDown }, -1) self.onShown.append(self.setWindowTitle) self.l = [] self["list"] = MenuList(self.l) self["list"].onSelectionChanged.append(self.selectionChanged) self.picload = ePicLoad() self.picload.PictureData.get().append(self.paintPosterPixmap) self.refreshTimer = eTimer() self.refreshTimer.callback.append(self.refresh) self.tmdb3 = tmdb.init_tmdb3() if self.service is not None: global movie_title movie_title = ServiceCenter.getInstance().info( self.service).getName( self.service).encode("utf-8").split(" - ")[0].strip() self.refreshTimer.start(1, True) return global fetchingMovies, this_session, is_hidden if fetchingMovies is None: fetchingMovies = FetchingMovies(items) else: fetchingMovies.cancel = False self.progressTimer = eTimer() self.progressTimer.callback.append(self.updateProgress) self.progressTimer.start(250, False) this_session = session is_hidden = False
def __init__(self, session, timer, menu_path=""): Screen.__init__(self, session) screentitle = _("Timer sanity error") self.menu_path = menu_path if config.usage.show_menupath.value == 'large': self.menu_path += screentitle title = self.menu_path self["menu_path_compressed"] = StaticText("") self.menu_path += ' / ' elif config.usage.show_menupath.value == 'small': title = screentitle condtext = "" if self.menu_path and not self.menu_path.endswith(' / '): condtext = self.menu_path + " >" elif self.menu_path: condtext = self.menu_path[:-3] + " >" self["menu_path_compressed"] = StaticText(condtext) self.menu_path += screentitle + ' / ' else: title = screentitle self["menu_path_compressed"] = StaticText("") Screen.setTitle(self, title) self.timer = timer print "[TimerEdit] TimerSanityConflict" self["timer1"] = TimerList(self.getTimerList(timer[0])) self.list = [] self.list2 = [] count = 0 for x in timer: if count != 0: self.list.append( (_("Conflicting timer") + " " + str(count), x)) self.list2.append((timer[count], False)) count += 1 if count == 1: self.list.append((_("Channel not in services list"))) self["list"] = MenuList(self.list) self["timer2"] = TimerList(self.list2) self["key_red"] = Button(_("Edit new entry")) # self["key_green"] = Button(" ") self["key_yellow"] = Button(" ") self["key_blue"] = Button(" ") self.key_green_choice = self.EMPTY self.key_yellow_choice = self.EMPTY self.key_blue_choice = self.EMPTY self["actions"] = ActionMap( [ "OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions" ], { "ok": self.leave_ok, "cancel": self.leave_cancel, "red": self.editTimer1, "up": self.up, "down": self.down }, -1) self.onShown.append(self.updateState)
class PositionerSetup(Screen): @staticmethod def satposition2metric(position): if position > 1800: position = 3600 - position orientation = "west" else: orientation = "east" return (position, orientation) @staticmethod def orbital2metric(position, orientation): if orientation == "west": position = 360 - position if orientation == "south": position = - position return position @staticmethod def longitude2orbital(position): if position >= 180: return 360 - position, "west" else: return position, "east" @staticmethod def latitude2orbital(position): if position >= 0: return position, "north" else: return -position, "south" UPDATE_INTERVAL = 50 # milliseconds STATUS_MSG_TIMEOUT = 2 # seconds LOG_SIZE = 16 * 1024 # log buffer size def __init__(self, session, feid): self.session = session Screen.__init__(self, session) self.feid = feid self.oldref = None log.open(self.LOG_SIZE) if config.Nims[self.feid].configMode.value == 'advanced': self.advanced = True self.advancedconfig = config.Nims[self.feid].advanced self.advancedsats = self.advancedconfig.sat self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid)) else: self.advanced = False cur = { } if not self.openFrontend(): self.oldref = session.nav.getCurrentlyPlayingServiceReference() service = session.nav.getCurrentService() feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData(True) del feInfo del service session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if session.pipshown: # try to disable pip service = self.session.pip.pipservice feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData() del feInfo del service session.pipshown = False del session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen del self.raw_channel self.frontendStatus = { } self.diseqc = Diseqc(self.frontend) # True means we dont like that the normal sec stuff sends commands to the rotor! self.tuner = Tuner(self.frontend, ignore_rotor = True) tp = ( cur.get("frequency", 0) / 1000, cur.get("symbol_rate", 0) / 1000, cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal), cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto), cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown), cur.get("orbital_position", 0), cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S), cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK), cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)) self.tuner.tune(tp) self.isMoving = False self.stopOnLock = False self.red = Button("") self["key_red"] = self.red self.green = Button("") self["key_green"] = self.green self.yellow = Button("") self["key_yellow"] = self.yellow self.blue = Button("") self["key_blue"] = self.blue self.list = [] self["list"] = ConfigList(self.list) self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus) self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus) self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus) self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus) self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus) self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus) self["frequency_value"] = Label("") self["symbolrate_value"] = Label("") self["fec_value"] = Label("") self["polarisation"] = Label("") self["status_bar"] = Label("") self.statusMsgTimeoutTicks = 0 self.statusMsgBlinking = False self.statusMsgBlinkCount = 0 self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL # milliseconds self.tuningChangedTo(tp) self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"], { "ok": self.keyOK, "cancel": self.keyCancel, "up": self.keyUp, "down": self.keyDown, "left": self.keyLeft, "right": self.keyRight, "red": self.redKey, "green": self.greenKey, "yellow": self.yellowKey, "blue": self.blueKey, "log": self.showLog, "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.updateColors("tune") self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) self.collectingStatistics = False self.statusTimer.start(self.UPDATE_INTERVAL, True) self.dataAvailable = Event() self.onClose.append(self.__onClose) self.createConfig() self.createSetup() def __onClose(self): self.statusTimer.stop() log.close(); self.session.nav.playService(self.oldref) def restartPrevService(self, yesno): if yesno: if self.frontend: self.frontend = None del self.raw_channel else: self.oldref=None self.close(None) def keyCancel(self): if self.oldref: self.session.openWithCallback(self.restartPrevService, MessageBox, _("Zap back to service before positioner setup?"), MessageBox.TYPE_YESNO) else: self.restartPrevService(False) def openFrontend(self): res_mgr = eDVBResourceManager.getInstance() if res_mgr: self.raw_channel = res_mgr.allocateRawChannel(self.feid) if self.raw_channel: self.frontend = self.raw_channel.getFrontend() if self.frontend: return True else: print "getFrontend failed" else: print "getRawChannel failed" else: print "getResourceManager instance failed" return False def setLNB(self, lnb): try: self.sitelon = lnb.longitude.float self.longitudeOrientation = lnb.longitudeOrientation.value self.sitelat = lnb.latitude.float self.latitudeOrientation = lnb.latitudeOrientation.value self.tuningstepsize = lnb.tuningstepsize.float self.rotorPositions = lnb.rotorPositions.value self.turningspeedH = lnb.turningspeedH.float self.turningspeedV = lnb.turningspeedV.float except: # some reasonable defaults from NimManager self.sitelon = 5.1 self.longitudeOrientation = 'east' self.sitelat = 50.767 self.latitudeOrientation = 'north' self.tuningstepsize = 0.36 self.rotorPositions = 49 self.turningspeedH = 2.3 self.turningspeedV = 1.7 self.sitelat = PositionerSetup.orbital2metric(self.sitelat, self.latitudeOrientation) self.sitelon = PositionerSetup.orbital2metric(self.sitelon, self.longitudeOrientation) def getLNBfromConfig(self, orb_pos): lnb = None if orb_pos in self.availablesats: lnbnum = int(self.advancedsats[orb_pos].lnb.value) if not lnbnum: for allsats in range(3601, 3604): lnbnum = int(self.advancedsats[allsats].lnb.value) if lnbnum: break if lnbnum: self.printMsg(_("Using LNB %d") % lnbnum) lnb = self.advancedconfig.lnb[lnbnum] if not lnb: self.logMsg(_("Warning: no LNB; using factory defaults."), timeout = 4) return lnb def createConfig(self): rotorposition = 1 orb_pos = 0 self.printMsg(_("Using tuner %s") % chr(0x41 + self.feid)) if not self.advanced: self.printMsg(_("Configuration mode: %s") % _("simple")) nim = config.Nims[self.feid] self.sitelon = nim.longitude.float self.longitudeOrientation = nim.longitudeOrientation.value self.sitelat = nim.latitude.float self.latitudeOrientation = nim.latitudeOrientation.value self.sitelat = PositionerSetup.orbital2metric(self.sitelat, self.latitudeOrientation) self.sitelon = PositionerSetup.orbital2metric(self.sitelon, self.longitudeOrientation) self.tuningstepsize = nim.tuningstepsize.float self.rotorPositions = nim.rotorPositions.value self.turningspeedH = nim.turningspeedH.float self.turningspeedV = nim.turningspeedV.float else: # it is advanced self.printMsg(_("Configuration mode: %s") % _("advanced")) fe_data = { } self.frontend.getFrontendData(fe_data) self.frontend.getTransponderData(fe_data, True) orb_pos = fe_data.get("orbital_position", None) if orb_pos in self.availablesats: rotorposition = int(self.advancedsats[orb_pos].rotorposition.value) self.setLNB(self.getLNBfromConfig(orb_pos)) self.positioner_tune = ConfigNothing() self.positioner_move = ConfigNothing() self.positioner_finemove = ConfigNothing() self.positioner_limits = ConfigNothing() self.positioner_storage = ConfigInteger(default = rotorposition, limits = (1, self.rotorPositions)) self.allocatedIndices = [] m = PositionerSetup.satposition2metric(orb_pos) self.orbitalposition = ConfigFloat(default = [int(m[0] / 10), m[0] % 10], limits = [(0,180),(0,9)]) self.orientation = ConfigSelection([("east", _("East")), ("west", _("West"))], m[1]) def createSetup(self): self.list.append((_("Tune and focus"), self.positioner_tune, "tune")) self.list.append((_("Movement"), self.positioner_move, "move")) self.list.append((_("Fine movement"), self.positioner_finemove, "finemove")) self.list.append((_("Set limits"), self.positioner_limits, "limits")) self.list.append((_("Memory index"), self.positioner_storage, "storage")) self.list.append((_("Goto"), self.orbitalposition, "goto")) self.list.append((" ", self.orientation, "goto")) self["list"].l.setList(self.list) def keyOK(self): pass def getCurrentConfigPath(self): return self["list"].getCurrent()[2] def keyUp(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveUp) self.updateColors(self.getCurrentConfigPath()) def keyDown(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveDown) self.updateColors(self.getCurrentConfigPath()) def keyNumberGlobal(self, number): self["list"].handleKey(KEY_0 + number) def keyLeft(self): self["list"].handleKey(KEY_LEFT) def keyRight(self): self["list"].handleKey(KEY_RIGHT) def updateColors(self, entry): if entry == "tune": self.red.setText(_("Tune")) self.green.setText(_("Auto focus")) self.yellow.setText(_("Calibrate")) self.blue.setText(_("Calculate")) elif entry == "move": if self.isMoving: self.red.setText(_("Stop")) self.green.setText(_("Stop")) self.yellow.setText(_("Stop")) self.blue.setText(_("Stop")) else: self.red.setText(_("Move west")) self.green.setText(_("Search west")) self.yellow.setText(_("Search east")) self.blue.setText(_("Move east")) elif entry == "finemove": self.red.setText("") self.green.setText(_("Step west")) self.yellow.setText(_("Step east")) self.blue.setText("") elif entry == "limits": self.red.setText(_("Limits off")) self.green.setText(_("Limit west")) self.yellow.setText(_("Limit east")) self.blue.setText(_("Limits on")) elif entry == "storage": self.red.setText("") self.green.setText(_("Store position")) self.yellow.setText(_("Goto position")) if self.advanced: self.blue.setText(_("Allocate")) else: self.blue.setText("") elif entry == "goto": self.red.setText("") self.green.setText(_("Goto 0")) self.yellow.setText(_("Goto X")) self.blue.setText("") else: self.red.setText("") self.green.setText("") self.yellow.setText("") self.blue.setText("") def printMsg(self, msg): print msg print>>log, msg def stopMoving(self): self.printMsg(_("Stop")) self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False self.statusMsg(_("Stopped"), timeout = self.STATUS_MSG_TIMEOUT) def redKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Move west")) self.diseqccommand("moveWest", 0) self.isMoving = True self.statusMsg(_("Moving west ..."), blinking = True) self.updateColors("move") elif entry == "limits": self.printMsg(_("Limits off")) self.diseqccommand("limitOff") self.statusMsg(_("Limits cancelled"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "tune": fe_data = { } self.frontend.getFrontendData(fe_data) self.frontend.getTransponderData(fe_data, True) feparm = self.tuner.lastparm.getDVBS() fe_data["orbital_position"] = feparm.orbital_position self.statusTimer.stop() self.session.openWithCallback(self.tune, TunerScreen, self.feid, fe_data) def greenKey(self): entry = self.getCurrentConfigPath() if entry == "tune": # Auto focus self.printMsg(_("Auto focus")) print>>log, (_("Site latitude") + " : %5.1f %s") % PositionerSetup.latitude2orbital(self.sitelat) print>>log, (_("Site longitude") + " : %5.1f %s") % PositionerSetup.longitude2orbital(self.sitelon) Thread(target = self.autofocus).start() elif entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Search west")) self.isMoving = True self.stopOnLock = True self.diseqccommand("moveWest", 0) self.statusMsg(_("Searching west ..."), blinking = True) self.updateColors("move") elif entry == "finemove": self.printMsg(_("Step west")) self.diseqccommand("moveWest", 0xFF) # one step self.statusMsg(_("Stepped west"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "storage": self.printMsg(_("Store at index")) index = int(self.positioner_storage.value) self.diseqccommand("store", index) self.statusMsg((_("Position stored at index") + " %2d") % index, timeout = self.STATUS_MSG_TIMEOUT) elif entry == "limits": self.printMsg(_("Limit west")) self.diseqccommand("limitWest") self.statusMsg(_("West limit set"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "goto": self.printMsg(_("Goto 0")) self.diseqccommand("moveTo", 0) self.statusMsg(_("Moved to position 0"), timeout = self.STATUS_MSG_TIMEOUT) def yellowKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Move east")) self.isMoving = True self.stopOnLock = True self.diseqccommand("moveEast", 0) self.statusMsg(_("Searching east ..."), blinking = True) self.updateColors("move") elif entry == "finemove": self.printMsg(_("Step east")) self.diseqccommand("moveEast", 0xFF) # one step self.statusMsg(_("Stepped east"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "storage": self.printMsg(_("Goto index position")) index = int(self.positioner_storage.value) self.diseqccommand("moveTo", index) self.statusMsg((_("Moved to position at index") + " %2d") % index, timeout = self.STATUS_MSG_TIMEOUT) elif entry == "limits": self.printMsg(_("Limit east")) self.diseqccommand("limitEast") self.statusMsg(_("East limit set"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "goto": self.printMsg(_("Move to position X")) satlon = self.orbitalposition.float position = ("%5.1f %s") % (satlon, self.orientation.value) print>>log, (_("Satellite longitude:") + " %s") % position satlon = PositionerSetup.orbital2metric(satlon, self.orientation.value) self.statusMsg((_("Moving to position") + " %s") % position, timeout = self.STATUS_MSG_TIMEOUT) self.gotoX(satlon) elif entry == "tune": # Start USALS calibration self.printMsg(_("USALS calibration")) print>>log, (_("Site latitude") + " : %5.1f %s") % PositionerSetup.latitude2orbital(self.sitelat) print>>log, (_("Site longitude") + " : %5.1f %s") % PositionerSetup.longitude2orbital(self.sitelon) Thread(target = self.gotoXcalibration).start() def blueKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.stopMoving() else: self.printMsg(_("Move east")) self.diseqccommand("moveEast", 0) self.isMoving = True self.statusMsg(_("Moving east ..."), blinking = True) self.updateColors("move") elif entry == "limits": self.printMsg(_("Limits on")) self.diseqccommand("limitOn") self.statusMsg(_("Limits enabled"), timeout = self.STATUS_MSG_TIMEOUT) elif entry == "tune": # Start (re-)calculate self.session.openWithCallback(self.recalcConfirmed, MessageBox, _("This will (re-)calculate all positions of your rotor and may remove previously memorised positions and fine-tuning!\nAre you sure?"), MessageBox.TYPE_YESNO, default = False, timeout = 10) elif entry == "storage": if self.advanced: self.printMsg(_("Allocate unused memory index")) while(True): if not len(self.allocatedIndices): for sat in self.availablesats: self.allocatedIndices.append(int(self.advancedsats[sat].rotorposition.value)) if len(self.allocatedIndices) == self.rotorPositions: self.statusMsg(_("No free index available"), timeout = self.STATUS_MSG_TIMEOUT) break index = 1 for i in sorted(self.allocatedIndices): if i != index: break index += 1 if index <= self.rotorPositions: self.positioner_storage.value = index self["list"].invalidateCurrent() self.allocatedIndices.append(index) self.statusMsg((_("Index allocated:") + " %2d") % index, timeout = self.STATUS_MSG_TIMEOUT) break else: self.allocatedIndices = [] def recalcConfirmed(self, yesno): if yesno: self.printMsg(_("Calculate all positions")) print>>log, (_("Site latitude") + " : %5.1f %s") % PositionerSetup.latitude2orbital(self.sitelat) print>>log, (_("Site longitude") + " : %5.1f %s") % PositionerSetup.longitude2orbital(self.sitelon) lon = self.sitelon if lon >= 180: lon -= 360 if lon < -30: # americas, make unsigned binary west positive polarity lon = -lon lon = int(round(lon)) & 0xFF lat = int(round(self.sitelat)) & 0xFF index = int(self.positioner_storage.value) & 0xFF self.diseqccommand("calc", (((index << 8) | lon) << 8) | lat) self.statusMsg(_("Calculation complete"), timeout = self.STATUS_MSG_TIMEOUT) def showLog(self): self.session.open(PositionerSetupLog) def diseqccommand(self, cmd, param = 0): print>>log, "Diseqc(%s, %X)" % (cmd, param) self.diseqc.command(cmd, param) self.tuner.retune() def tune(self, transponder): # re-start the update timer self.statusTimer.start(self.UPDATE_INTERVAL, True) if transponder is not None: self.tuner.tune(transponder) self.tuningChangedTo(transponder) feparm = self.tuner.lastparm.getDVBS() orb_pos = feparm.orbital_position m = PositionerSetup.satposition2metric(orb_pos) self.orbitalposition.value = [int(m[0] / 10), m[0] % 10] self.orientation.value = m[1] if self.advanced: if orb_pos in self.availablesats: rotorposition = int(self.advancedsats[orb_pos].rotorposition.value) self.positioner_storage.value = rotorposition self.allocatedIndices = [] self.setLNB(self.getLNBfromConfig(orb_pos)) def isLocked(self): return self.frontendStatus.get("tuner_locked", 0) == 1 def statusMsg(self, msg, blinking = False, timeout = 0): # timeout in seconds self.statusMsgBlinking = blinking if not blinking: self["status_bar"].visible = True self["status_bar"].setText(msg) self.statusMsgTimeoutTicks = (timeout * 1000 + self.UPDATE_INTERVAL / 2) / self.UPDATE_INTERVAL def updateStatus(self): self.statusTimer.start(self.UPDATE_INTERVAL, True) if self.frontend: self.frontend.getFrontendStatus(self.frontendStatus) self["snr_db"].update() self["snr_percentage"].update() self["ber_value"].update() self["snr_bar"].update() self["ber_bar"].update() self["lock_state"].update() if self.statusMsgBlinking: self.statusMsgBlinkCount += 1 if self.statusMsgBlinkCount == self.statusMsgBlinkRate: self.statusMsgBlinkCount = 0 self["status_bar"].visible = not self["status_bar"].visible if self.statusMsgTimeoutTicks > 0: self.statusMsgTimeoutTicks -= 1 if self.statusMsgTimeoutTicks == 0: self["status_bar"].setText("") self.statusMsgBlinking = False self["status_bar"].visible = True if self.isLocked() and self.isMoving and self.stopOnLock: self.stopMoving() self.updateColors(self.getCurrentConfigPath()) if self.collectingStatistics: self.low_rate_adapter_count += 1 if self.low_rate_adapter_count == self.MAX_LOW_RATE_ADAPTER_COUNT: self.low_rate_adapter_count = 0 self.snr_percentage += self["snr_percentage"].getValue(TunerInfo.SNR) self.lock_count += self["lock_state"].getValue(TunerInfo.LOCK) self.stat_count += 1 if self.stat_count == self.max_count: self.collectingStatistics = False count = float(self.stat_count) self.lock_count /= count self.snr_percentage *= 100.0 / 0x10000 / count self.dataAvailable.set() def tuningChangedTo(self, tp): def setLowRateAdapterCount(symbolrate): # change the measurement time and update interval in case of low symbol rate, # since more time is needed for the front end in that case. # It is an heuristic determination without any pretence. For symbol rates # of 5000 the interval is multiplied by 3 until 15000 which is seen # as a high symbol rate. Linear interpolation elsewhere. return max(int(round((3 - 1) * (symbolrate - 15000) / (5000 - 15000) + 1)), 1) self.symbolrate = tp[1] self.polarisation = tp[2] self.MAX_LOW_RATE_ADAPTER_COUNT = setLowRateAdapterCount(self.symbolrate) transponderdata = ConvertToHumanReadable(self.tuner.getTransponderData(), "DVB-S") frequency = transponderdata.get("frequency") if frequency: frequency_text = str(frequency / 1000) else: frequency_text = "" self["frequency_value"].setText(frequency_text) symbolrate = transponderdata.get("symbol_rate") if symbolrate: symbolrate_text = str(symbolrate / 1000) else: symbolrate_text = "" self["symbolrate_value"].setText(symbolrate_text) fec_inner = transponderdata.get("fec_inner") if fec_inner: fec_text = str(fec_inner) else: fec_text = "" self["fec_value"].setText(fec_text) polarisation = transponderdata.get("polarization") if polarisation: polarisation_text = str(polarisation) else: polarisation_text = "" self["polarisation"].setText(polarisation_text) @staticmethod def rotorCmd2Step(rotorCmd, stepsize): return round(float(rotorCmd & 0xFFF) / 0x10 / stepsize) * (1 - ((rotorCmd & 0x1000) >> 11)) @staticmethod def gotoXcalc(satlon, sitelat, sitelon): def azimuth2Rotorcode(angle): gotoXtable = (0x00, 0x02, 0x03, 0x05, 0x06, 0x08, 0x0A, 0x0B, 0x0D, 0x0E) a = int(round(abs(angle) * 10.0)) return ((a / 10) << 4) + gotoXtable[a % 10] satHourAngle = rotor_calc.calcSatHourangle(satlon, sitelat, sitelon) if sitelat >= 0: # Northern Hemisphere rotorCmd = azimuth2Rotorcode(180 - satHourAngle) if satHourAngle <= 180: # the east rotorCmd |= 0xE000 else: # west rotorCmd |= 0xD000 else: # Southern Hemisphere if satHourAngle <= 180: # the east rotorCmd = azimuth2Rotorcode(satHourAngle) | 0xD000 else: # west rotorCmd = azimuth2Rotorcode(360 - satHourAngle) | 0xE000 return rotorCmd def gotoX(self, satlon): rotorCmd = PositionerSetup.gotoXcalc(satlon, self.sitelat, self.sitelon) self.diseqccommand("gotoX", rotorCmd) x = PositionerSetup.rotorCmd2Step(rotorCmd, self.tuningstepsize) print>>log, (_("Rotor step position:") + " %4d") % x return x def getTurningspeed(self): if self.polarisation == eDVBFrontendParametersSatellite.Polarisation_Horizontal: turningspeed = self.turningspeedH else: turningspeed = self.turningspeedV return max(turningspeed, 0.1) TURNING_START_STOP_DELAY = 1.600 # seconds MAX_SEARCH_ANGLE = 12.0 # degrees MAX_FOCUS_ANGLE = 6.0 # degrees LOCK_LIMIT = 0.1 # ratio MEASURING_TIME = 2.500 # seconds def measure(self, time = MEASURING_TIME): # time in seconds self.snr_percentage = 0.0 self.lock_count = 0.0 self.stat_count = 0 self.low_rate_adapter_count = 0 self.max_count = max(int((time * 1000 + self.UPDATE_INTERVAL / 2)/ self.UPDATE_INTERVAL), 1) self.collectingStatistics = True self.dataAvailable.clear() self.dataAvailable.wait() def logMsg(self, msg, timeout = 0): self.statusMsg(msg, timeout = timeout) self.printMsg(msg) def sync(self): self.lock_count = 0.0 n = 0 while self.lock_count < (1 - self.LOCK_LIMIT) and n < 5: self.measure(time = 0.500) n += 1 if self.lock_count < (1 - self.LOCK_LIMIT): return False return True randomGenerator = None def randomBool(self): if self.randomGenerator is None: self.randomGenerator = SystemRandom() return self.randomGenerator.random() >= 0.5 def gotoXcalibration(self): def move(x): z = self.gotoX(x + satlon) time = int(abs(x - prev_pos) / turningspeed + 2 * self.TURNING_START_STOP_DELAY) sleep(time * self.MAX_LOW_RATE_ADAPTER_COUNT) return z def reportlevels(pos, level, lock): print>>log, (_("Signal quality") + " %5.1f" + chr(176) + " : %6.2f") % (pos, level) print>>log, (_("Lock ratio") + " %5.1f" + chr(176) + " : %6.2f") % (pos, lock) def optimise(readings): xi = readings.keys() yi = map(lambda (x, y) : x, readings.values()) x0 = sum(map(mul, xi, yi)) / sum(yi) xm = xi[yi.index(max(yi))] return (x0, xm) def toGeopos(x): if x < 0: return _("W") else: return _("E") def toGeoposEx(x): if x < 0: return _("west") else: return _("east") self.logMsg(_("GotoX calibration")) satlon = self.orbitalposition.float print>>log, (_("Satellite longitude:") + " %5.1f" + chr(176) + " %s") % (satlon, self.orientation.value) satlon = PositionerSetup.orbital2metric(satlon, self.orientation.value) prev_pos = 0.0 # previous relative position w.r.t. satlon turningspeed = self.getTurningspeed() x = 0.0 # relative position w.r.t. satlon dir = 1 if self.randomBool(): dir = -dir while abs(x) < self.MAX_SEARCH_ANGLE: if self.sync(): break x += (1.0 * dir) # one degree east/west self.statusMsg((_("Searching") + " " + toGeoposEx(dir) + " %2d" + chr(176)) % abs(x), blinking = True) move(x) prev_pos = x else: x = 0.0 dir = -dir while abs(x) < self.MAX_SEARCH_ANGLE: x += (1.0 * dir) # one degree east/west self.statusMsg((_("Searching") + " " + toGeoposEx(dir) + " %2d" + chr(176)) % abs(x), blinking = True) move(x) prev_pos = x if self.sync(): break else: msg = _("Cannot find any signal ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return x = round(x / self.tuningstepsize) * self.tuningstepsize move(x) prev_pos = x measurements = {} self.measure() print>>log, (_("Initial signal quality") + " %5.1f" + chr(176) + ": %6.2f") % (x, self.snr_percentage) print>>log, (_("Initial lock ratio") + " %5.1f" + chr(176) + ": %6.2f") % (x, self.lock_count) measurements[x] = (self.snr_percentage, self.lock_count) start_pos = x x = 0.0 dir = 1 if self.randomBool(): dir = -dir while x < self.MAX_FOCUS_ANGLE: x += self.tuningstepsize * dir # one step east/west self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %5.1f" + chr(176)) % abs(x + start_pos), blinking = True) move(x + start_pos) prev_pos = x + start_pos self.measure() measurements[x + start_pos] = (self.snr_percentage, self.lock_count) reportlevels(x + start_pos, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return x = 0.0 dir = -dir self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %5.1f" + chr(176)) % abs(start_pos), blinking = True) move(start_pos) prev_pos = start_pos if not self.sync(): msg = _("Sync failure moving back to origin !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return while abs(x) < self.MAX_FOCUS_ANGLE: x += self.tuningstepsize * dir # one step west/east self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %5.1f" + chr(176)) % abs(x + start_pos), blinking = True) move(x + start_pos) prev_pos = x + start_pos self.measure() measurements[x + start_pos] = (self.snr_percentage, self.lock_count) reportlevels(x + start_pos, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return (x0, xm) = optimise(measurements) x = move(x0) if satlon > 180: satlon -= 360 x0 += satlon xm += satlon print>>log, (_("Weighted position") + " : %5.1f" + chr(176) + " %s") % (abs(x0), toGeopos(x0)) print>>log, (_("Strongest position") + " : %5.1f" + chr(176) + " %s") % (abs(xm), toGeopos(xm)) self.logMsg((_("Final position at") + " %5.1f" + chr(176) + " %s / %d; " + _("offset is") + " %4.1f" + chr(176)) % (abs(x0), toGeopos(x0), x, x0 - satlon), timeout = 10) def autofocus(self): def move(x): if x > 0: self.diseqccommand("moveEast", (-x) & 0xFF) elif x < 0: self.diseqccommand("moveWest", x & 0xFF) if x != 0: time = int(abs(x) * self.tuningstepsize / turningspeed + 2 * self.TURNING_START_STOP_DELAY) sleep(time * self.MAX_LOW_RATE_ADAPTER_COUNT) def reportlevels(pos, level, lock): print>>log, (_("Signal quality") + " [%2d] : %6.2f") % (pos, level) print>>log, (_("Lock ratio") + " [%2d] : %6.2f") % (pos, lock) def optimise(readings): xi = readings.keys() yi = map(lambda (x, y) : x, readings.values()) x0 = int(round(sum(map(mul, xi, yi)) / sum(yi))) xm = xi[yi.index(max(yi))] return (x0, xm) def toGeoposEx(x): if x < 0: return _("west") else: return _("east") self.logMsg(_("Auto focus commencing ...")) turningspeed = self.getTurningspeed() measurements = {} maxsteps = max(min(round(self.MAX_FOCUS_ANGLE / self.tuningstepsize), 0x1F), 3) self.measure() print>>log, (_("Initial signal quality:") + " %6.2f") % self.snr_percentage print>>log, (_("Initial lock ratio") + " : %6.2f") % self.lock_count if self.lock_count < 1 - self.LOCK_LIMIT: msg = _("There is no signal to lock on !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return print>>log, _("Signal OK, proceeding") x = 0 dir = 1 if self.randomBool(): dir = -dir measurements[x] = (self.snr_percentage, self.lock_count) nsteps = 0 while nsteps < maxsteps: x += dir self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %2d") % abs(x), blinking = True) move(dir) # one step self.measure() measurements[x] = (self.snr_percentage, self.lock_count) reportlevels(x, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break nsteps += 1 else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return dir = -dir self.statusMsg(_("Moving") + " " + toGeoposEx(dir) + " 0", blinking = True) move(-x) if not self.sync(): msg = _("Sync failure moving back to origin !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return x = 0 nsteps = 0 while nsteps < maxsteps: x += dir self.statusMsg((_("Moving") + " " + toGeoposEx(dir) + " %2d") % abs(x), blinking = True) move(dir) # one step self.measure() measurements[x] = (self.snr_percentage, self.lock_count) reportlevels(x, self.snr_percentage, self.lock_count) if self.lock_count < self.LOCK_LIMIT: break nsteps += 1 else: msg = _("Cannot determine") + " " + toGeoposEx(dir) + " " + _("limit ..., aborting !") self.printMsg(msg) self.statusMsg("") self.session.open(MessageBox, msg, MessageBox.TYPE_ERROR, timeout = 5) return (x0, xm) = optimise(measurements) print>>log, (_("Weighted position") + " : %2d") % x0 print>>log, (_("Strongest position") + " : %2d") % xm self.logMsg((_("Final position at index") + " %2d (%5.1f" + chr(176) + ")") % (x0, x0 * self.tuningstepsize), timeout = 6) move(x0 - x)
def __init__(self, session, text="", filename="", currDir=None, bookmarks=None, userMode=False, windowTitle=_("Select location"), minFree=None, autoAdd=False, editDir=False, inhibitDirs=None, inhibitMounts=None): # Init parents if not inhibitDirs: inhibitDirs = [] if not inhibitMounts: inhibitMounts = [] 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")) # Background for Buttons self["green"] = Pixmap() self["yellow"] = Pixmap() self["blue"] = Pixmap() self["red"] = Pixmap() # Initialize Target self["target"] = Label() self["targetfreespace"] = Label() if self.userMode: self.usermodeOn() # Custom Action Handler class LocationBoxActionMap(HelpableActionMap): def __init__(self, parent, context, actions=None, prio=0): if not actions: actions = {} 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", { "ok": (self.ok, _("select")), "back": (self.cancel, _("Cancel")), }, -2) self["DirectionActions"] = LocationBoxActionMap(self, "DirectionActions", { "left": self.left, "right": self.right, "up": self.up, "down": self.down, }, -2) self["ColorActions"] = LocationBoxActionMap(self, "ColorActions", { "red": self.cancel, "green": self.select, "yellow": self.changeName, "blue": self.addRemoveBookmark, }, -2) self["EPGSelectActions"] = LocationBoxActionMap(self, "EPGSelectActions", { "prevService": (self.switchToBookList, _("switch to bookmarks")), "nextService": (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, _("Select Location")), self.updateTarget, self.showHideRename, )) self.onLayoutFinish.append(self.switchToFileListOnStart) # Make sure we remove our callback self.onClose.append(self.disableTimer)
def __init__(self, session, args=0): self.session = session Screen.__init__(self, session) if debug: print pluginPrintname, "Displays config screen" self.onChangedEntry = [] self.list = [ getConfigListEntry(_("Active Time Profile"), config.plugins.elektro.profile, _("The active Time Profile is (1 or 2).")), getConfigListEntry( _("Enable Elektro Power Save"), config.plugins.elektro.enable, _("Unless this is enabled, this plugin won't run automatically." )), getConfigListEntry( _("Use both profiles alternately"), config.plugins.elektro.profileShift, _("Both profiles are used alternately. When shutting down the other profile is enabled. This allows two time cycles per day. Do not overlap the times." )), getConfigListEntry(_("Standby on boot"), config.plugins.elektro.standbyOnBoot, _("Puts the box in standby mode after boot.")), getConfigListEntry( _("Standby on manual boot"), config.plugins.elektro.standbyOnManualBoot, _("Whether to put the box in standby when booted manually. On manual boot the box will not go to standby before the next deep standby interval starts, even if this option is set. This option is only active if 'Standby on boot' option is set, too." )), getConfigListEntry( _("Force sleep (even when not in standby)"), config.plugins.elektro.force, _("Forces deep standby, even when not in standby mode. Scheduled recordings remain unaffected." )), getConfigListEntry( _("Avoid deep standby when HDD is active, e.g. for FTP"), config.plugins.elektro.hddsleep, _("Wait for the HDD to enter sleep mode. Depending on the configuration this can prevent the box entirely from entering deep standby mode." )), getConfigListEntry( _("Avoid deep standby on network activity, e.g. for Streaming" ), config.plugins.elektro.netsleep, _("Wait for the network to enter sleep mode.")), getConfigListEntry( _("Check IPs (press OK to edit)"), config.plugins.elektro.IPenable, _("This list of IP addresses is checked. Elektro waits until addresses no longer responds to ping." )), getConfigListEntry( _("NAS Poweroff (press OK to edit)"), config.plugins.elektro.NASenable, _("A NAS/Server can be shut down. Is required activated Telnet." )), getConfigListEntry( _("Don't wake up"), config.plugins.elektro.dontwakeup, _("Do not wake up at the end of next deep standby interval.")), getConfigListEntry( _("Holiday mode (experimental)"), config.plugins.elektro.holiday, _("The box always enters deep standby mode, except for recording." )), getConfigListEntry( _("Show in"), config.plugins.elektro.menu, _("Specify whether plugin shall show up in plugin menu or extensions menu (needs GUI restart)" )), getConfigListEntry( _("Name"), config.plugins.elektro.name, _("Specify plugin name to be used in menu (needs GUI restart)." )), getConfigListEntry( _("Description"), config.plugins.elektro.description, _("Specify plugin description to be used in menu (needs GUI restart)." )), ] ConfigListScreen.__init__(self, self.list, session=session, on_change=self.changed) def selectionChanged(): if self["config"].current: self["config"].current[1].onDeselect(self.session) self["config"].current = self["config"].getCurrent() if self["config"].current: self["config"].current[1].onSelect(self.session) for x in self["config"].onSelectionChanged: x() self["config"].selectionChanged = selectionChanged self["config"].onSelectionChanged.append(self.configHelp) self["key_red"] = Button(_("Cancel")) self["key_green"] = Button(_("Ok")) self["key_yellow"] = Button(_("Help")) self["key_blue"] = Button(_("Times")) self["help"] = StaticText() self["setupActions"] = ActionMap( ["SetupActions", "ColorActions"], { "red": self.keyCancel, "green": self.keySave, "yellow": self.help, "blue": self.profile, "save": self.keySave, "cancel": self.keyCancel, "ok": self.keyOK, }, -2) # Trigger change self.changed() self.onLayoutFinish.append(self.setCustomTitle)
def __init__(self, session, tlist, menuTitle): Screen.__init__(self, session) self.skinName = 'Iconmain' self.tlist = tlist ipage = 1 list = [] nopic = len(self.tlist) self.pos = [] self.ipage = 1 self.index = 0 title = menuTitle self['title'] = Button(title) self.icons = [] self.indx = [] n1 = len(tlist) self.picnum = n1 list = [] tlist = [] self['label1'] = StaticText() self['label2'] = StaticText() self['label3'] = StaticText() self['label4'] = StaticText() self['label5'] = StaticText() self['label6'] = StaticText() self['label1s'] = StaticText() self['label2s'] = StaticText() self['label3s'] = StaticText() self['label4s'] = StaticText() self['label5s'] = StaticText() self['label6s'] = StaticText() self['pointer'] = Pixmap() self['pixmap1'] = Pixmap() self['pixmap2'] = Pixmap() self['pixmap3'] = Pixmap() self['pixmap4'] = Pixmap() self['pixmap5'] = Pixmap() self['pixmap6'] = Pixmap() self['red'] = Button(_('Exit')) self['green'] = Button(_('Select')) self['yellow'] = Button(_('Config')) self['actions'] = NumberActionMap( [ 'OkCancelActions', 'MenuActions', 'DirectionActions', 'NumberActions', 'ColorActions' ], { 'ok': self.okbuttonClick, 'cancel': self.closeNonRecursive, 'left': self.key_left, 'right': self.key_right, 'up': self.key_up, 'down': self.key_down, 'red': self.cancel, 'green': self.okbuttonClick, 'yellow': self.key_menu, 'menu': self.closeRecursive, '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 }) self.index = 0 i = 0 self.maxentry = 29 self.istart = 0 i = 0 self.onShown.append(self.openTest)
def __init__(self, session, text='', filename='', currDir=None, bookmarks=None, userMode=False, windowTitle=_('Select location'), minFree=None, autoAdd=False, editDir=False, inhibitDirs=None, inhibitMounts=None): if not inhibitDirs: inhibitDirs = [] if not inhibitMounts: inhibitMounts = [] Screen.__init__(self, session) NumericalTextInput.__init__(self, handleTimeout=False) HelpableScreen.__init__(self) self.setUseableChars(u'1234567890abcdefghijklmnopqrstuvwxyz') self.qs_timer = eTimer() self.qs_timer.callback.append(self.timeout) self.qs_timer_type = 0 self.curr_pos = -1 self.quickselect = '' self['text'] = Label(text) self['textbook'] = Label(_('Bookmarks')) 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 self['filelist'] = FileList(currDir, showDirectories=True, showFiles=False, inhibitMounts=inhibitMounts, inhibitDirs=inhibitDirs) self['booklist'] = MenuList(self.bookmarks) self['key_green'] = Button(_('OK')) self['key_yellow'] = Button(_('Rename')) self['key_blue'] = Button(_('Remove bookmark')) self['key_red'] = Button(_('Cancel')) self['green'] = Pixmap() self['yellow'] = Pixmap() self['blue'] = Pixmap() self['red'] = Pixmap() self['target'] = Label() if self.userMode: self.usermodeOn() class LocationBoxActionMap(HelpableActionMap): def __init__(self, parent, context, actions=None, prio=0): if not actions: actions = {} HelpableActionMap.__init__(self, parent, context, actions, prio) self.box = parent def action(self, contexts, action): self.box.timeout(force=True) return HelpableActionMap.action(self, contexts, action) self['WizardActions'] = LocationBoxActionMap(self, 'WizardActions', { 'ok': (self.ok, _('select')), 'back': (self.cancel, _('Cancel')) }, -2) self['DirectionActions'] = LocationBoxActionMap( self, 'DirectionActions', { 'left': self.left, 'right': self.right, 'up': self.up, 'down': self.down }, -2) self['ColorActions'] = LocationBoxActionMap( self, 'ColorActions', { 'red': self.cancel, 'green': self.select, 'yellow': self.changeName, 'blue': self.addRemoveBookmark }, -2) self['EPGSelectActions'] = LocationBoxActionMap( self, 'EPGSelectActions', { 'prevService': (self.switchToBookList, _('switch to bookmarks')), 'nextService': (self.switchToFileList, _('switch to filelist')) }, -2) self['MenuActions'] = LocationBoxActionMap( self, 'MenuActions', {'menu': (self.showMenu, _('menu'))}, -2) self['NumberActions'] = NumberActionMap( ['NumberActions'], { '1': self.keyNumberGlobal, '2': self.keyNumberGlobal, '3': self.keyNumberGlobal, '4': self.keyNumberGlobal, '5': self.keyNumberGlobal, '6': self.keyNumberGlobal, '7': self.keyNumberGlobal, '8': self.keyNumberGlobal, '9': self.keyNumberGlobal, '0': self.keyNumberGlobal }) self.onShown.extend((boundFunction(self.setTitle, _('Select Location')), self.updateTarget, self.showHideRename)) self.onLayoutFinish.append(self.switchToFileListOnStart) self.onClose.append(self.disableTimer)
def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("About")) hddsplit, = skin.parameters.get("AboutHddSplit", (0,)) AboutText = _("Hardware: ") + about.getHardwareTypeString() + "\n" AboutText += _("CPU: ") + about.getCPUInfoString() + "\n" AboutText += _("Image: ") + about.getImageTypeString() + "\n" #AboutText += _("Installed: ") + about.getFlashDateString() + "\n" AboutText += _("Kernel version: ") + about.getKernelVersionString() + "\n" EnigmaVersion = "Enigma: " + about.getEnigmaVersionString() self["EnigmaVersion"] = StaticText(EnigmaVersion) AboutText += EnigmaVersion + "\n" AboutText += _("Enigma (re)starts: %d\n") % config.misc.startCounter.value #GStreamerVersion = "GStreamer: " + about.getGStreamerVersionString().replace("GStreamer","") #self["GStreamerVersion"] = StaticText(GStreamerVersion) #AboutText += GStreamerVersion + "\n" self["GStreamerVersion"] = StaticText("") ImageVersion = _("Last upgrade: ") + about.getImageVersionString() self["ImageVersion"] = StaticText(ImageVersion) AboutText += ImageVersion + "\n" AboutText += _("DVB drivers: ") + about.getDriverInstalledDate() + "\n" AboutText += _("Python version: ") + about.getPythonVersionString() + "\n" fp_version = getFPVersion() if fp_version is None or fp_version == 0: fp_version = "" else: fp_version = _("Frontprocessor version: %d") % fp_version AboutText += fp_version + "\n" self["FPVersion"] = StaticText(fp_version) self["TunerHeader"] = StaticText(_("Detected NIMs:")) AboutText += "\n" + _("Detected NIMs:") + "\n" nims = nimmanager.nimList() for count in range(len(nims)): if count < 4: self["Tuner" + str(count)] = StaticText(nims[count]) else: self["Tuner" + str(count)] = StaticText("") AboutText += nims[count] + "\n" self["HDDHeader"] = StaticText(_("Detected HDD:")) AboutText += "\n" + _("Detected HDD:") + "\n" hddlist = harddiskmanager.HDDList() hddinfo = "" if hddlist: formatstring = hddsplit and "%s:%s, %.1f %sB %s" or "%s\n(%s, %.1f %sB %s)" for count in range(len(hddlist)): if hddinfo: hddinfo += "\n" hdd = hddlist[count][1] if int(hdd.free()) > 1024: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free()/1024.0, "G", _("free")) else: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free(), "M", _("free")) else: hddinfo = _("none") self["hddA"] = StaticText(hddinfo) AboutText += hddinfo self["AboutScrollLabel"] = ScrollLabel(AboutText) self["key_green"] = Button(_("Translations")) self["key_red"] = Button(_("Latest Commits")) self["key_blue"] = Button(_("Memory Info")) self["actions"] = ActionMap(["ColorActions", "SetupActions", "DirectionActions"], { "cancel": self.close, "ok": self.close, "red": self.showCommits, "green": self.showTranslationInfo, "blue": self.showMemoryInfo, "up": self["AboutScrollLabel"].pageUp, "down": self["AboutScrollLabel"].pageDown })
def __init__(self, session): Screen.__init__(self, session) HelpableScreen.__init__(self) ChannelsBase.__init__(self) WebChannels.__init__(self) self.session = session self.skinName = ["SeriesPluginChannelEditor"] log.debug("ChannelEditor") from plugin import NAME, VERSION self.setup_title = NAME + " " + _("Channel Editor") + " " + VERSION # Buttons self["key_red"] = Button(_("Cancel")) self["key_green"] = Button(_("OK")) self["key_blue"] = Button(_("Remove")) self["key_yellow"] = Button(_("Auto match")) # Define Actions self["actions_1"] = HelpableActionMap( self, "SetupActions", { "ok": (self.keyAdd, _("Show popup to add Stb Channel")), "cancel": (self.keyCancel, _("Cancel and close")), "deleteForward": (self.keyResetChannelMapping, _("Reset channels")), }, -1) self["actions_2"] = HelpableActionMap( self, "DirectionActions", { "left": (self.keyLeft, _("Previeous page")), "right": (self.keyRight, _("Next page")), "up": (self.keyUp, _("One row up")), "down": (self.keyDown, _("One row down")), }, -1) self["actions_3"] = HelpableActionMap( self, "ChannelSelectBaseActions", { "nextBouquet": (self.nextBouquet, _("Next bouquet")), "prevBouquet": (self.prevBouquet, _("Previous bouquet")), }, -1) self["actions_4"] = HelpableActionMap( self, "ColorActions", { "red": (self.keyCancel, _("Cancel and close")), "green": (self.keySave, _("Save and close")), "blue": (self.keyRemove, _("Remove channel")), "yellow": (self.tryToMatchChannels, _("Auto match")), }, -2) # higher priority self.helpList[0][2].sort() self["helpActions"] = ActionMap([ "HelpActions", ], {"displayHelp": self.showHelp}, 0) self['list'] = MatchList() self['list'].show() self.stbChlist = [] self.webChlist = [] self.stbToWebChlist = [] self.bouquet = None self.onLayoutFinish.append(self.readChannels) self.onShown.append(self.showMessage)
def __init__(self, event, Ref, callback=None, similarEPGCB=None, parent=None): self.similarEPGCB = similarEPGCB self.cbFunc = callback self.currentService = Ref self.isRecording = (not Ref.ref.flags & eServiceReference.isGroup) and Ref.ref.getPath() self.event = event self["Service"] = ServiceEvent() self["Event"] = Event() self["epg_eventname"] = ScrollLabel() self["epg_description"] = ScrollLabel() self["FullDescription"] = ScrollLabel() self["datetime"] = Label() self["channel"] = Label() self["duration"] = Label() if self['Event'] == StaticText: self["key_red"] = StaticText("") else: self["key_red"] = Button("") if similarEPGCB is not None: self.SimilarBroadcastTimer = eTimer() self.SimilarBroadcastTimer.callback.append(self.getSimilarEvents) else: self.SimilarBroadcastTimer = None self.key_green_choice = self.ADD_TIMER if self.isRecording: if self["Event"] == StaticText: self["key_green"] = StaticText("") else: self["key_green"] = Button("") else: if self["Event"] == StaticText: self["key_green"] = StaticText(_("Add timer")) else: self["key_green"] = Button(_("Add timer")) if self["Event"] == StaticText: self["key_yellow"] = StaticText("") self["key_blue"] = StaticText("") else: self["key_yellow"] = Button("") self["key_blue"] = Button("") self["actions"] = ActionMap( ["OkCancelActions", "EventViewActions"], { "cancel": self.close, "ok": self.close, "pageUp": self.pageUp, "pageDown": self.pageDown, "prevEvent": self.prevEvent, "nextEvent": self.nextEvent, "timerAdd": self.timerAdd, "openSimilarList": self.openSimilarList, "contextMenu": self.doContext, }) if parent and hasattr(parent, "fallbackTimer"): self.fallbackTimer = parent.fallbackTimer self.onLayoutFinish.append(self.onCreate) else: self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def __init__(self, session, *args): Screen.__init__(self, session) self.skinName = ["EPGSearch", "EPGSelection"] self.searchargs = args self.currSearch = "" # XXX: we lose sort begin/end here self["key_yellow"] = Button(_("New Search")) self["key_blue"] = Button(_("History")) # begin stripped copy of EPGSelection.__init__ self.bouquetChangeCB = None self.serviceChangeCB = None self.ask_time = -1 #now self["key_red"] = Button("") self.closeRecursive = False self.saved_title = None self["Service"] = ServiceEvent() self["Event"] = Event() self.type = EPG_TYPE_SINGLE self.currentService = None self.zapFunc = None self.sort_type = 0 self["key_green"] = Button(_("Add timer")) self.key_green_choice = self.ADD_TIMER self.key_red_choice = self.EMPTY self["list"] = EPGSearchList(type=self.type, selChangedCB=self.onSelectionChanged, timer=session.nav.RecordTimer) self["actions"] = ActionMap(["EPGSelectActions", "OkCancelActions", "MenuActions"], { "menu": self.menu, "cancel": self.closeScreen, "ok": self.eventSelected, "timerAdd": self.timerAdd, "yellow": self.yellowButtonPressed, "blue": self.blueButtonPressed, "info": self.infoKeyPressed, "red": self.zapToselect, # needed --> Partnerbox "nextBouquet": self.nextBouquet, # just used in multi epg yet "prevBouquet": self.prevBouquet, # just used in multi epg yet "nextService": self.nextService, # just used in single epg yet "prevService": self.prevService, # just used in single epg yet }) self["actions"].csel = self self.onLayoutFinish.append(self.onCreate) # end stripped copy of EPGSelection.__init__ self.select = False self.do_filter = None self.eventid = None self.isTMBD = fileExists("/usr/lib/enigma2/python/Plugins/Extensions/TMBD/plugin.pyo") # Partnerbox if PartnerBoxIconsEnabled: EPGSelection.PartnerboxInit(self, False) if self.isTMBD: self["key_red"].setText(_("Choice list")) self.select = True else: if self.isTMBD: self["key_red"].setText(_("Lookup in TMBD")) # Hook up actions for yttrailer if installed try: from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__ except ImportError as ie: pass else: if baseEPGSelection__init__ is not None: self["trailerActions"] = ActionMap(["InfobarActions", "InfobarTeletextActions"], { "showTv": self.showTrailer, "showRadio": self.showTrailerList, "startTeletext": self.showConfig })
def __init__(self, session, server): Screen.__init__(self, session) self.server = server self["actions"] = ActionMap(["SetupActions", "ColorActions"], { "green": self.keySave, "red": self.keyCancel, "cancel": self.keyCancel }, -2) self["key_red"] = Button(_("Cancel")) self["key_green"] = Button(_("OK")) self["key_yellow"] = Button("") self["key_blue"] = Button("") cfglist = [] cfglist.append( getConfigListEntry(_("Server Profile Name"), server.name())) cfglist.append( getConfigListEntry(_("Enter VLC-Server as FQDN or IP-Address"), server.addressType())) self.hostConfigListEntry = getConfigListEntry(_("Server Address"), server.host()) cfglist.append(self.hostConfigListEntry) cfglist.append(getConfigListEntry(_("HTTP Port"), server.httpPort())) cfglist.append( getConfigListEntry(_("HTTP Password"), server.password())) cfglist.append( getConfigListEntry(_("Movie Directory"), server.basedir())) cfglist.append( getConfigListEntry(_("DVD Device (leave empty for default)"), server.dvdPath())) cfglist.append( getConfigListEntry(_("Transcode MPEG/DVD Video"), server.transcodeVideo())) cfglist.append( getConfigListEntry(_("Video Codec"), server.videoCodec())) cfglist.append( getConfigListEntry(_("Video Bitrate"), server.videoBitrate())) cfglist.append(getConfigListEntry(_("Video Norm"), server.videoNorm())) cfglist.append( getConfigListEntry( _("Overscan Correction [in %(percentsign)s of Video width]") % {"percentsign": "%"}, server.overscanCorrection())) cfglist.append( getConfigListEntry(_("Subtitle overlay"), server.sOverlay())) cfglist.append( getConfigListEntry(_("Transcode MPEG/DVD Audio"), server.transcodeAudio())) cfglist.append( getConfigListEntry(_("Audio Codec"), server.audioCodec())) cfglist.append( getConfigListEntry(_("Audio Bitrate"), server.audioBitrate())) cfglist.append( getConfigListEntry(_("Audio Samplerate"), server.samplerate())) cfglist.append( getConfigListEntry(_("Audio Channels"), server.audioChannels())) ConfigListScreen.__init__(self, cfglist, session) server.addressType().addNotifier(self.switchAddressType, False) self.onClose.append(self.__onClose)
def __init__(self, session, text='', filename='', currDir=None, location=None, userMode=False, windowTitle=_('Choose backup location'), minFree=None, autoAdd=False, editDir=False, inhibitDirs=[], inhibitMounts=[]): Screen.__init__(self, session) HelpableScreen.__init__(self) self['text'] = StaticText(_('Selected memory place:')) self['oktext'] = StaticText(_('for select sublist!')) self.text = text self.filename = filename self.minFree = minFree self.reallocation = location if not (location and location.value[:]): self.location = [] self.userMode = userMode self.autoAdd = autoAdd self.editDir = editDir self.inhibitDirs = inhibitDirs self.inhibitMounts = inhibitMounts inhibitDirs = [ '/bin', '/boot', '/dev', '/lib', '/proc', '/sbin', '/sys', '/mnt', '/var', '/home', '/tmp', '/srv', '/etc', '/share', '/usr', '/ba', '/MB_Images' ] inhibitMounts = ['/mnt', '/ba', '/MB_Images'] self['filelist'] = FileList(currDir, showDirectories=True, showFiles=False, inhibitMounts=inhibitMounts, inhibitDirs=inhibitDirs) self['mountlist'] = MenuList(mountedDevs) self['key_green'] = Button(_('Save')) self['key_red'] = Button(_('Close')) self['green'] = Pixmap() self['red'] = Pixmap() self['target'] = Label() self.userMode and self.usermodeOn() class BackupLocationActionMap(HelpableActionMap): def __init__(self, parent, context, actions={}, prio=0): HelpableActionMap.__init__(self, parent, context, actions, prio) self['WizardActions'] = BackupLocationActionMap( 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'] = BackupLocationActionMap(self, 'ColorActions', { 'red': self.cancel, 'green': self.select }, -2) self.setWindowTitle() self.onLayoutFinish.append(self.switchToFileListOnStart)
class HddFastRemove(Screen): skin = """ <screen name="HddFastRemove" position="center,115" size="900,530" title="HddFastRemove" flags="wfBorder"> <ePixmap position="10,497" size="35,27" pixmap="skin_default/buttons/red.png" alphatest="blend" /> <ePixmap position="230,497" size="35,27" pixmap="skin_default/buttons/green.png" alphatest="blend" /> <ePixmap position="464,497" size="35,27" pixmap="skin_default/buttons/yellow.png" alphatest="blend" /> <ePixmap position="695,497" size="35,27" pixmap="skin_default/buttons/blue.png" alphatest="blend" /> <widget name="key_red" position="48,498" zPosition="2" size="150,22" valign="center" halign="center" font="Regular; 20" transparent="1" shadowColor="black" shadowOffset="-1,-1" /> <widget name="key_green" position="273,499" zPosition="2" size="150,22" valign="center" halign="center" font="Regular;21" transparent="1" shadowColor="black" shadowOffset="-1,-1" backgroundColor="foreground" /> <widget name="key_yellow" position="508,499" zPosition="3" size="150,22" valign="center" halign="center" font="Regular; 21" transparent="1" backgroundColor="foreground" /> <widget name="key_blue" position="736,499" zPosition="3" size="150,22" valign="center" halign="center" font="Regular; 21" transparent="1" backgroundColor="foreground" /> <eLabel text="Hard Drive Remove" zPosition="2" position="10,11" size="880,40" halign="left" font="Regular;28" foregroundColor="un538eff" transparent="1" shadowColor="black" shadowOffset="-1,-1" backgroundColor="black" /> <widget source="menu" render="Listbox" position="11,58" size="880,410" scrollbarMode="showOnDemand" transparent="1"> <convert type="TemplatedMultiContent"> {"template": [ MultiContentEntryPixmapAlphaTest(pos = (5, 0), size = (48, 48), png = 0), MultiContentEntryText(pos = (65, 3), size = (190, 38), font=0, flags = RT_HALIGN_LEFT|RT_VALIGN_TOP, text = 1), MultiContentEntryText(pos = (65, 27), size = (190, 38), font=1, flags = RT_HALIGN_LEFT|RT_VALIGN_TOP, text = 2), ], "fonts": [gFont("Regular", 22), gFont("Regular", 18)], "itemHeight": 50 } </convert> </widget> </screen>""" def __init__(self, session): Screen.__init__(self, session) self.mdisks = Disks() self.mountpoints = MountPoints() self.mountpoints.read() self.disks = list () self.mounts = list () for disk in self.mdisks.disks: if disk[2] == True: diskname = disk[3] for partition in disk[5]: mp = "" rmp = "" try: mp = self.mountpoints.get(partition[0][:3], int(partition[0][3:])) rmp = self.mountpoints.getRealMount(partition[0][:3], int(partition[0][3:])) except Exception, e: pass if len(mp) > 0: self.disks.append(MountEntry(disk[3], "P.%s (Fixed: %s)" % (partition[0][3:], mp))) self.mounts.append(mp) elif len(rmp) > 0: self.disks.append(MountEntry(disk[3], "P.%s (Fast: %s)" % (partition[0][3:], rmp))) self.mounts.append(rmp) self["menu"] = List(self.disks) self["key_red"] = Button(_("Umount")) self["key_blue"] = Button(_("Exit")) self["actions"] = ActionMap(["OkCancelActions", "ColorActions"], { "blue": self.quit, "red": self.red, "cancel": self.quit, }, -2)
def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("About")) hddsplit = skin.parameters.get("AboutHddSplit", 0) AboutText = _("Model: %s %s") % (getMachineBrand(), getMachineName()) + "\n" AboutText += _("Image: ") + about.getImageTypeString() + "\n" AboutText += _("Kernel version: ") + about.getKernelVersionString() + "\n" if path.exists('/proc/stb/info/chipset'): AboutText += _("Chipset: %s") % about.getChipSetString() + "\n" AboutText += _("CPU: %s") % about.getCPUString() + "\n" AboutText += _("Version: %s") % getImageVersion() + "\n" imagestarted = "" bootname = '' if path.exists('/boot/bootname'): f = open('/boot/bootname', 'r') bootname = f.readline().split('=')[1] f.close() if getMachineBuild() in ('cc1','sf8008'): if path.exists('/boot/STARTUP'): f = open('/boot/STARTUP', 'r') f.seek(5) image = f.read(4) if image == "emmc": image = "1" elif image == "usb0": f.seek(13) image = f.read(1) if image == "1": image = "2" elif image == "3": image = "3" elif image == "5": image = "4" elif image == "7": image = "5" f.close() if bootname: bootname = " (%s)" %bootname AboutText += _("Selected Image:\t%s") % "STARTUP_" + image + bootname + "\n" if path.exists('/boot/STARTUP'): f = open('/boot/STARTUP', 'r') f.seek(22) image = f.read(1) f.close() if bootname: bootname = " (%s)" %bootname AboutText += _("Image started:\t%s") % "STARTUP_" + image + bootname + "\n" AboutText += _("Build: %s") % getImageBuild() + "\n" if path.exists('/proc/stb/info/release') and getBoxType() in ('et7000', 'et7500', 'et8500'): realdriverdate = open("/proc/stb/info/release", 'r') for line in realdriverdate: tmp = line.strip() AboutText += _("Drivers: %s") % tmp + "\n" realdriverdate.close() else: string = getDriverDate() year = string[0:4] month = string[4:6] day = string[6:8] driversdate = '-'.join((year, month, day)) AboutText += _("Drivers: %s") % driversdate + "\n" EnigmaVersion = "Enigma: " + about.getEnigmaVersionString() self["EnigmaVersion"] = StaticText(EnigmaVersion) AboutText += EnigmaVersion + "\n" AboutText += _("Enigma (re)starts: %d\n") % config.misc.startCounter.value GStreamerVersion = "GStreamer: " + about.getGStreamerVersionString().replace("GStreamer","") self["GStreamerVersion"] = StaticText(GStreamerVersion) AboutText += GStreamerVersion + "\n" ImageVersion = _("Last upgrade: ") + about.getImageVersionString() self["ImageVersion"] = StaticText(ImageVersion) AboutText += ImageVersion + "\n" AboutText += _("Python version: ") + about.getPythonVersionString() + "\n" + "\n" AboutText += _("Enigma (re)starts: %d\n") % config.misc.startCounter.value fp_version = getFPVersion() if fp_version is None: fp_version = "" else: fp_version = _("Frontprocessor version: %s") % fp_version AboutText += fp_version + "\n" self["FPVersion"] = StaticText(fp_version) skinWidth = getDesktop(0).size().width() skinHeight = getDesktop(0).size().height() AboutText += _("Skin Name: %s") % config.skin.primary_skin.value[0:-9] + _(" (%s x %s)") % (skinWidth, skinHeight) + "\n" if path.exists('/etc/enigma2/EtRcType'): rfp = open('/etc/enigma2/EtRcType', "r") Remote = rfp.read() rfp.close AboutText += _("Remote control type") + _(": ") + Remote + "\n" else: AboutText += _("Remote control type") + _(": ") + iRcTypeControl.getBoxType() + "\n" if path.exists('/proc/stb/ir/rc/type'): fp = open('/proc/stb/ir/rc/type', "r") RcID = fp.read() fp.close AboutText += _("Remote control ID") + _(": ") + RcID AboutText += _('Skin & Resolution: %s (%sx%s)\n') % (config.skin.primary_skin.value[0:-9], getDesktop(0).size().width(), getDesktop(0).size().height()) self["TunerHeader"] = StaticText(_("Detected NIMs:")) AboutText += "\n" + _("Detected NIMs:") + "\n" nims = nimmanager.nimListCompressed() for count in range(len(nims)): if count < 4: self["Tuner" + str(count)] = StaticText(nims[count]) else: self["Tuner" + str(count)] = StaticText("") AboutText += nims[count] + "\n" self["HDDHeader"] = StaticText(_("Detected HDD:")) AboutText += "\n" + _("Detected HDD:") + "\n" hddlist = harddiskmanager.HDDList() hddinfo = "" if hddlist: formatstring = hddsplit and "%s:%s, %.1f %sB %s" or "%s\n(%s, %.1f %sB %s)" for count in range(len(hddlist)): if hddinfo: hddinfo += "\n" hdd = hddlist[count][1] if int(hdd.free()) > 1024: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free()/1024.0, "G", _("free")) else: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free(), "M", _("free")) else: hddinfo = _("none") self["hddA"] = StaticText(hddinfo) AboutText += hddinfo + "\n\n" + _("Network Info:") for x in about.GetIPsFromNetworkInterfaces(): AboutText += "\n" + x[0] + ": " + x[1] self["AboutScrollLabel"] = ScrollLabel(AboutText) self["key_green"] = Button(_("Troubleshoot")) self["key_red"] = Button(_("Latest Commits")) self["key_yellow"] = Button(_("Memory Info")) self["key_blue"] = Button(_("%s ") % getMachineName() + _("picture")) self["actions"] = ActionMap(["ColorActions", "SetupActions", "DirectionActions", "ChannelSelectEPGActions"], { "cancel": self.close, "ok": self.close, "info": self.showTranslationInfo, "red": self.showCommits, "green": self.showTroubleshoot, "yellow": self.showMemoryInfo, "blue": self.showModelPic, "up": self["AboutScrollLabel"].pageUp, "down": self["AboutScrollLabel"].pageDown })
def __init__(self, session, tlist, menuTitle): Screen.__init__(self, session) self.skinName = "Iconmain" self.tlist = tlist ipage = 1 list = [] nopic = len(self.tlist) self.pos = [] self.ipage = 1 self.index = 0 title = menuTitle self["title"] = Button(title) self.icons = [] self.indx = [] n1 = len(tlist) self.picnum = n1 list = [] tlist = [] self["label1"] = StaticText() self["label2"] = StaticText() self["label3"] = StaticText() self["label4"] = StaticText() self["label5"] = StaticText() self["label6"] = StaticText() self["label1s"] = StaticText() self["label2s"] = StaticText() self["label3s"] = StaticText() self["label4s"] = StaticText() self["label5s"] = StaticText() self["label6s"] = StaticText() self["pointer"] = Pixmap() self["pixmap1"] = Pixmap() self["pixmap2"] = Pixmap() self["pixmap3"] = Pixmap() self["pixmap4"] = Pixmap() self["pixmap5"] = Pixmap() self["pixmap6"] = Pixmap() self["red"] = Button(_("Exit")) self["green"] = Button(_("Select")) self["yellow"] = Button(_("Config")) self["actions"] = NumberActionMap(["OkCancelActions", "MenuActions", "DirectionActions", "NumberActions", "ColorActions"], { "ok": self.okbuttonClick, "cancel": self.closeNonRecursive, "left": self.key_left, "right": self.key_right, "up": self.key_up, "down": self.key_down, "red": self.cancel, "green": self.okbuttonClick, "yellow": self.key_menu, "menu": self.closeRecursive, "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 }) self.index = 0 i = 0 self.maxentry = 29 self.istart = 0 i = 0 self.onShown.append(self.openTest)
def __init__(self, session, menu_path=""): Screen.__init__(self, session) screentitle = _("Memory") if config.usage.show_menupath.value == 'large': menu_path += screentitle title = menu_path self["menu_path_compressed"] = StaticText("") elif config.usage.show_menupath.value == 'small': title = screentitle self["menu_path_compressed"] = StaticText( menu_path + " >" if not menu_path.endswith(' / ') else menu_path[:-3] + " >" or "") else: title = screentitle self["menu_path_compressed"] = StaticText("") Screen.setTitle(self, title) self.skinName = ["SystemMemoryInfo", "About"] self["lab1"] = StaticText(_("Open Black Hole Image")) self["lab2"] = StaticText(_("By Bh Team")) self["lab3"] = StaticText( _("Support at") + " www.vuplus-community.net") self["AboutScrollLabel"] = ScrollLabel() self["key_red"] = Button(_("Close")) self["actions"] = ActionMap(["SetupActions", "ColorActions"], { "cancel": self.close, "ok": self.close, "red": self.close, }) out_lines = file("/proc/meminfo").readlines() self.AboutText = _("RAM") + '\n\n' RamTotal = "-" RamFree = "-" for lidx in range(len(out_lines) - 1): tstLine = out_lines[lidx].split() if "MemTotal:" in tstLine: MemTotal = out_lines[lidx].split() self.AboutText += _( "Total memory:") + "\t" + MemTotal[1] + "\n" if "MemFree:" in tstLine: MemFree = out_lines[lidx].split() self.AboutText += _("Free memory:") + "\t" + MemFree[1] + "\n" if "Buffers:" in tstLine: Buffers = out_lines[lidx].split() self.AboutText += _("Buffers:") + "\t" + Buffers[1] + "\n" if "Cached:" in tstLine: Cached = out_lines[lidx].split() self.AboutText += _("Cached:") + "\t" + Cached[1] + "\n" if "SwapTotal:" in tstLine: SwapTotal = out_lines[lidx].split() self.AboutText += _("Total swap:") + "\t" + SwapTotal[1] + "\n" if "SwapFree:" in tstLine: SwapFree = out_lines[lidx].split() self.AboutText += _("Free swap:") + "\t" + SwapFree[1] + "\n\n" self["actions"].setEnabled(False) self.Console = Console() self.Console.ePopen("df -mh / | grep -v '^Filesystem'", self.Stage1Complete)
def __init__(self, session, tlist, menuTitle): Screen.__init__(self, session) self.skinName = 'Animmain' self.tlist = tlist ipage = 1 list = [] nopic = len(tlist) self.pos = [] self.index = 0 title = menuTitle self['title'] = Button(title) list = [] tlist = [] self['label1'] = StaticText() self['label2'] = StaticText() self['label3'] = StaticText() self['label4'] = StaticText() self['label5'] = StaticText() self['red'] = Button(_('Exit')) self['green'] = Button(_('Select')) self['yellow'] = Button(_('Config')) self['actions'] = NumberActionMap( [ 'OkCancelActions', 'MenuActions', 'DirectionActions', 'NumberActions', 'ColorActions' ], { 'ok': self.okbuttonClick, 'cancel': self.closeNonRecursive, 'left': self.key_left, 'right': self.key_right, 'up': self.key_up, 'down': self.key_down, 'red': self.cancel, 'green': self.okbuttonClick, 'yellow': self.key_menu, 'menu': self.closeRecursive, '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 }) nop = len(self.tlist) self.nop = nop nh = 1 if nop == 1: nh = 1 elif nop == 2: nh = 2 elif nop == 3: nh = 2 elif nop == 4: nh = 3 elif nop == 5: nh = 3 else: nh = int(float(nop) / 2) self.index = nh i = 0 self.onShown.append(self.openTest)
def __init__(self, session): Screen.__init__(self, session) AboutText = _("Hardware: ") + about.getHardwareTypeString() + "\n" AboutText += _("Image: ") + about.getImageTypeString() + "\n" AboutText += _( "Kernel version: ") + about.getKernelVersionString() + "\n" EnigmaVersion = "Enigma: " + about.getEnigmaVersionString() self["EnigmaVersion"] = StaticText(EnigmaVersion) AboutText += EnigmaVersion + "\n" ImageVersion = _("Last upgrade: ") + about.getImageVersionString() self["ImageVersion"] = StaticText(ImageVersion) AboutText += ImageVersion + "\n" fp_version = getFPVersion() if fp_version is None: fp_version = "" else: fp_version = _("Frontprocessor version: %d") % fp_version AboutText += fp_version + "\n" self["FPVersion"] = StaticText(fp_version) self["TunerHeader"] = StaticText(_("Detected NIMs:")) AboutText += "\n" + _("Detected NIMs:") + "\n" nims = nimmanager.nimList() for count in range(len(nims)): if count < 4: self["Tuner" + str(count)] = StaticText(nims[count]) else: self["Tuner" + str(count)] = StaticText("") AboutText += nims[count] + "\n" self["HDDHeader"] = StaticText(_("Detected HDD:")) AboutText += "\n" + _("Detected HDD:") + "\n" hddlist = harddiskmanager.HDDList() hddinfo = "" if hddlist: for count in range(len(hddlist)): if hddinfo: hddinfo += "\n" hdd = hddlist[count][1] if int(hdd.free()) > 1024: hddinfo += "%s\n(%s, %d GB %s)" % ( hdd.model(), hdd.capacity(), hdd.free() / 1024, _("free")) else: hddinfo += "%s\n(%s, %d MB %s)" % ( hdd.model(), hdd.capacity(), hdd.free(), _("free")) else: hddinfo = _("none") self["hddA"] = StaticText(hddinfo) AboutText += hddinfo self["AboutScrollLabel"] = ScrollLabel(AboutText) self["key_green"] = Button(_("Translations")) self["key_red"] = Button(_("Latest Commits")) self["actions"] = ActionMap( ["ColorActions", "SetupActions", "DirectionActions"], { "cancel": self.close, "ok": self.close, "red": self.showCommits, "green": self.showTranslationInfo, "up": self["AboutScrollLabel"].pageUp, "down": self["AboutScrollLabel"].pageDown })
def __init__(self, session, eventName, callbackNeeded=False): Screen.__init__(self, session) self.eventName = eventName self.callbackNeeded = callbackNeeded self.callbackData = "" self.callbackGenre = "" self.dictionary_init() self["poster"] = Pixmap() self.picload = ePicLoad() self.picload.PictureData.get().append(self.paintPosterPixmapCB) self["stars"] = ProgressBar() self["starsbg"] = Pixmap() self["stars"].hide() self["starsbg"].hide() self.ratingstars = -1 self["title"] = StaticText(_("The Internet Movie Database")) # map new source -> old component def setText(txt): StaticText.setText(self["title"], txt) self["titellabel"].setText(txt) self["title"].setText = setText self["titellabel"] = Label() self["detailslabel"] = ScrollLabel("") self["castlabel"] = ScrollLabel("") self["extralabel"] = ScrollLabel("") self["statusbar"] = Label("") self["ratinglabel"] = Label("") self.resultlist = [] self["menu"] = MenuList(self.resultlist) self["menu"].hide() self["key_red"] = Button(_("Exit")) self["key_green"] = Button("") self["key_yellow"] = Button("") self["key_blue"] = Button("") # 0 = multiple query selection menu page # 1 = movie info page # 2 = extra infos page self.Page = 0 self["actions"] = ActionMap( [ "OkCancelActions", "ColorActions", "MovieSelectionActions", "DirectionActions" ], { "ok": self.showDetails, "cancel": self.exit, "down": self.pageDown, "up": self.pageUp, "red": self.exit, "green": self.showMenu, "yellow": self.showDetails, "blue": self.showExtras, "contextMenu": self.contextMenuPressed, "showEventInfo": self.showDetails }, -1) self.getIMDB()
def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("About")) hddsplit = skin.parameters.get("AboutHddSplit", 0) AboutText = _("Hardware: ") + about.getHardwareTypeString() + "\n" AboutText += _("CPU: ") + about.getCPUInfoString() + "\n" AboutText += _("Image: ") + about.getImageTypeString() + "\n" AboutText += _("Build date: ") + about.getBuildDateString() + "\n" AboutText += _("Last upgrade: ") + about.getUpdateDateString() + "\n" # [WanWizard] Removed until we find a reliable way to determine the installation date # AboutText += _("Installed: ") + about.getFlashDateString() + "\n" EnigmaVersion = about.getEnigmaVersionString() EnigmaVersion = EnigmaVersion.rsplit("-", EnigmaVersion.count("-") - 2) if len(EnigmaVersion) == 3: EnigmaVersion = EnigmaVersion[0] + " (" + EnigmaVersion[ 2] + "-" + EnigmaVersion[1] + ")" else: EnigmaVersion = EnigmaVersion[0] + " (" + EnigmaVersion[1] + ")" EnigmaVersion = _("Enigma version: ") + EnigmaVersion self["EnigmaVersion"] = StaticText(EnigmaVersion) AboutText += "\n" + EnigmaVersion + "\n" AboutText += _( "Kernel version: ") + about.getKernelVersionString() + "\n" AboutText += _( "DVB driver version: ") + about.getDriverInstalledDate() + "\n" GStreamerVersion = _( "GStreamer version: ") + about.getGStreamerVersionString().replace( "GStreamer", "") self["GStreamerVersion"] = StaticText(GStreamerVersion) AboutText += GStreamerVersion + "\n" AboutText += _( "Python version: ") + about.getPythonVersionString() + "\n" AboutText += _( "Enigma (re)starts: %d\n") % config.misc.startCounter.value fp_version = getFPVersion() if fp_version is None: fp_version = "" else: fp_version = _("Frontprocessor version: %s") % fp_version AboutText += fp_version + "\n" self["FPVersion"] = StaticText(fp_version) AboutText += _('Skin & Resolution: %s (%sx%s)\n') % ( config.skin.primary_skin.value[0:-9], getDesktop(0).size().width(), getDesktop(0).size().height()) self["TunerHeader"] = StaticText(_("Detected NIMs:")) AboutText += "\n" + _("Detected NIMs:") + "\n" nims = nimmanager.nimListCompressed() for count in range(len(nims)): if count < 4: self["Tuner" + str(count)] = StaticText(nims[count]) else: self["Tuner" + str(count)] = StaticText("") AboutText += nims[count] + "\n" self["HDDHeader"] = StaticText(_("Detected HDD:")) AboutText += "\n" + _("Detected HDD:") + "\n" hddlist = harddiskmanager.HDDList() hddinfo = "" if hddlist: formatstring = hddsplit and "%s:%s, %.1f %sB %s" or "%s\n(%s, %.1f %sB %s)" for count in range(len(hddlist)): if hddinfo: hddinfo += "\n" hdd = hddlist[count][1] if int(hdd.free()) > 1024: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free() / 1024.0, "G", _("free")) else: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free(), "M", _("free")) else: hddinfo = _("none") self["hddA"] = StaticText(hddinfo) AboutText += hddinfo + "\n\n" + _("Network Info:") for x in about.GetIPsFromNetworkInterfaces(): AboutText += "\n" + x[0] + ": " + x[1] self["AboutScrollLabel"] = ScrollLabel(AboutText) self["key_green"] = Button(_("Translations")) self["key_red"] = Button(_("Latest Commits")) self["key_yellow"] = Button(_("Troubleshoot")) self["key_blue"] = Button(_("Memory Info")) self["actions"] = ActionMap( ["ColorActions", "SetupActions", "DirectionActions"], { "cancel": self.close, "ok": self.close, "red": self.showCommits, "green": self.showTranslationInfo, "blue": self.showMemoryInfo, "yellow": self.showTroubleshoot, "up": self["AboutScrollLabel"].pageUp, "down": self["AboutScrollLabel"].pageDown })
def __init__(self, session, feid): self.session = session Screen.__init__(self, session) self.feid = feid self.oldref = None log.open(self.LOG_SIZE) if config.Nims[self.feid].configMode.value == 'advanced': self.advanced = True self.advancedconfig = config.Nims[self.feid].advanced self.advancedsats = self.advancedconfig.sat self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid)) else: self.advanced = False cur = { } if not self.openFrontend(): self.oldref = session.nav.getCurrentlyPlayingServiceReference() service = session.nav.getCurrentService() feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData(True) del feInfo del service session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if session.pipshown: # try to disable pip service = self.session.pip.pipservice feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData() del feInfo del service session.pipshown = False del session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen del self.raw_channel self.frontendStatus = { } self.diseqc = Diseqc(self.frontend) # True means we dont like that the normal sec stuff sends commands to the rotor! self.tuner = Tuner(self.frontend, ignore_rotor = True) tp = ( cur.get("frequency", 0) / 1000, cur.get("symbol_rate", 0) / 1000, cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal), cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto), cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown), cur.get("orbital_position", 0), cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S), cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK), cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)) self.tuner.tune(tp) self.isMoving = False self.stopOnLock = False self.red = Button("") self["key_red"] = self.red self.green = Button("") self["key_green"] = self.green self.yellow = Button("") self["key_yellow"] = self.yellow self.blue = Button("") self["key_blue"] = self.blue self.list = [] self["list"] = ConfigList(self.list) self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus) self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus) self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus) self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus) self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus) self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus) self["frequency_value"] = Label("") self["symbolrate_value"] = Label("") self["fec_value"] = Label("") self["polarisation"] = Label("") self["status_bar"] = Label("") self.statusMsgTimeoutTicks = 0 self.statusMsgBlinking = False self.statusMsgBlinkCount = 0 self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL # milliseconds self.tuningChangedTo(tp) self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"], { "ok": self.keyOK, "cancel": self.keyCancel, "up": self.keyUp, "down": self.keyDown, "left": self.keyLeft, "right": self.keyRight, "red": self.redKey, "green": self.greenKey, "yellow": self.yellowKey, "blue": self.blueKey, "log": self.showLog, "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.updateColors("tune") self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) self.collectingStatistics = False self.statusTimer.start(self.UPDATE_INTERVAL, True) self.dataAvailable = Event() self.onClose.append(self.__onClose) self.createConfig() self.createSetup()
def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("About")) hddsplit = parameters.get("AboutHddSplit", 0) #AboutHddSplit = 0 #try: # hddsplit = skin.parameters.get("AboutHddSplit",(0))[0] #except: # hddsplit = AboutHddSplit if boxtype == 'gb800solo': BoxName = "GigaBlue HD 800SOLO" elif boxtype == 'gb800se': BoxName = "GigaBlue HD 800SE" elif boxtype == 'gb800ue': BoxName = "GigaBlue HD 800UE" elif boxtype == 'gbquad': BoxName = "GigaBlue Quad" elif boxtype == 'gbquad4k': BoxName = "GigaBlue Quad 4k" elif boxtype == 'gbue4k': BoxName = "GigaBlue UE 4k" elif boxtype == 'gbx34k': BoxName = "GigaBlue X3 4k" elif boxtype == 'gbtrio4k': BoxName = "GigaBlue TRIO 4k" elif boxtype == 'gbip4k': BoxName = "GigaBlue IP 4k" elif boxtype == 'gbquadplus': BoxName = "GigaBlue HD Quadplus" elif boxtype == 'gb800seplus': BoxName = "GigaBlue HD 800SEplus" elif boxtype == 'gb800ueplus': BoxName = "GigaBlue HD 800UEplus" elif boxtype == 'gbipbox': BoxName = "GigaBlue IP Box" elif boxtype == 'gbultra': BoxName = "GigaBlue HD Ultra" elif boxtype == 'gbultraue': BoxName = "GigaBlue HD Ultra UE" elif boxtype == 'gbultraueh': BoxName = "GigaBlue HD Ultra UEh" elif boxtype == 'gbultrase': BoxName = "GigaBlue HD Ultra SE" elif boxtype == 'gbx1': BoxName = "GigaBlue X1" elif boxtype == 'gbx2': BoxName = "GigaBlue X2" elif boxtype == 'gbx3': BoxName = "GigaBlue X3" elif boxtype == 'gbx3h': BoxName = "GigaBlue X3h" elif boxtype == 'spycat': BoxName = "XCORE Spycat" elif boxtype == 'quadbox2400': BoxName = "AX Quadbox HD2400" else: BoxName = about.getHardwareTypeString() self.setTitle(_("About") + " " + BoxName) ImageType = about.getImageTypeString() self["ImageType"] = StaticText(ImageType) Boxserial = popen('cat /proc/stb/info/sn').read().strip() serial = "" if Boxserial != "": serial = ":Serial : " + Boxserial AboutHeader = _("About") + " " + BoxName self["AboutHeader"] = StaticText(AboutHeader) AboutText = BoxName + " - " + ImageType + serial + "\n" #AboutText += _("Hardware: ") + about.getHardwareTypeString() + "\n" #AboutText += _("CPU: ") + about.getCPUInfoString() + "\n" #AboutText += _("Installed: ") + about.getFlashDateString() + "\n" #AboutText += _("Image: ") + about.getImageTypeString() + "\n" cpu = about.getCPUInfoString() CPUinfo = _("CPU: ") + cpu self["CPUinfo"] = StaticText(CPUinfo) AboutText += CPUinfo + "\n" CPUspeed = _("Speed: ") + about.getCPUSpeedString() self["CPUspeed"] = StaticText(CPUspeed) #AboutText += "(" + about.getCPUSpeedString() + ")\n" ChipsetInfo = _("Chipset: ") + about.getChipSetString() self["ChipsetInfo"] = StaticText(ChipsetInfo) AboutText += ChipsetInfo + "\n" if boxtype == 'gbquad4k' or boxtype == 'gbue4k' or boxtype == 'gbx34k': def strip_non_ascii(boltversion): ''' Returns the string without non ASCII characters''' stripped = (c for c in boltversion if 0 < ord(c) < 127) return ''.join(stripped) boltversion = str( popen('cat /sys/firmware/devicetree/base/bolt/tag').read(). strip()) boltversion = strip_non_ascii(boltversion) AboutText += _("Bolt") + ":" + boltversion + "\n" self["BoltVersion"] = StaticText(boltversion) AboutText += _( "Enigma (re)starts: %d\n") % config.misc.startCounter.value fp_version = getFPVersion() if fp_version is None: fp_version = "" else: fp_version = _("Frontprocessor version: %s") % fp_version #AboutText += fp_version +"\n" self["FPVersion"] = StaticText(fp_version) AboutText += "\n" KernelVersion = _("Kernel version: ") + about.getKernelVersionString() self["KernelVersion"] = StaticText(KernelVersion) AboutText += KernelVersion + "\n" if getMachineBuild() in ('gb7252', 'gb72604'): b = popen('cat /proc/stb/info/version').read().strip() driverdate = str(b[0:4] + '-' + b[4:6] + '-' + b[6:8] + ' ' + b[8:10] + ':' + b[10:12] + ':' + b[12:14]) AboutText += _("DVB drivers: ") + driverdate + "\n" else: AboutText += _("DVB drivers: ") + self.realDriverDate() + "\n" #AboutText += _("DVB drivers: ") + about.getDriverInstalledDate() + "\n" ImageVersion = _("Last upgrade: ") + about.getImageVersionString() self["ImageVersion"] = StaticText(ImageVersion) AboutText += ImageVersion + "\n" EnigmaVersion = _( "GUI Build: ") + about.getEnigmaVersionString() + "\n" self["EnigmaVersion"] = StaticText(EnigmaVersion) #AboutText += EnigmaVersion #AboutText += _("Enigma (re)starts: %d\n") % config.misc.startCounter.value FlashDate = _("Flashed: ") + about.getFlashDateString() self["FlashDate"] = StaticText(FlashDate) AboutText += FlashDate + "\n" EnigmaSkin = _('Skin & Resolution: %s (%sx%s)') % ( config.skin.primary_skin.value.split('/')[0], getDesktop(0).size().width(), getDesktop(0).size().height()) self["EnigmaSkin"] = StaticText(EnigmaSkin) AboutText += EnigmaSkin + "\n" AboutText += _( "Python version: ") + about.getPythonVersionString() + "\n" AboutText += _( "Enigma2 debug level:\t%d") % eGetEnigmaDebugLvl() + "\n" GStreamerVersion = _("GStreamer: ") + about.getGStreamerVersionString( cpu).replace("GStreamer", "") self["GStreamerVersion"] = StaticText(GStreamerVersion) AboutText += GStreamerVersion + "\n" twisted = popen('opkg list-installed |grep -i python-twisted-core' ).read().strip().split(' - ')[1] AboutText += "Python-Twisted: " + str(twisted) + "\n" AboutText += "\n" self["TunerHeader"] = StaticText(_("Detected NIMs:")) #AboutText += _("Detected NIMs:") + "\n" nims = nimmanager.nimList() for count in range(len(nims)): if count < 4: self["Tuner" + str(count)] = StaticText(nims[count]) else: self["Tuner" + str(count)] = StaticText("") AboutText += nims[count] + "\n" self["HDDHeader"] = StaticText(_("Detected storage devices:")) AboutText += "\n" + _("Detected storage devices:") + "\n" hddlist = harddiskmanager.HDDList() hddinfo = "" if hddlist: formatstring = hddsplit and "%s:%s, %.1f %s %s" or "%s\n(%s, %.1f %s %s)" for count in range(len(hddlist)): if hddinfo: hddinfo += "\n" hdd = hddlist[count][1] if int(hdd.free()) > 1024: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free() / 1024.0, _("GB"), _("free")) else: hddinfo += formatstring % (hdd.model(), hdd.capacity(), hdd.free(), _("MB"), _("free")) else: hddinfo = _("none") self["hddA"] = StaticText(hddinfo) AboutText += hddinfo #AboutText += "\n\n" + _("Network Info") #for x in about.GetIPsFromNetworkInterfaces(): # AboutText += "\n" + iNetwork.getFriendlyAdapterDescription(x[0]) + " :" + "/dev/" + x[0] + " " + x[1] AboutText += '\n\n' + _("Uptime") + ": " + about.getBoxUptime() if SystemInfo["HasHDMI-CEC"] and config.hdmicec.enabled.value: address = config.hdmicec.fixed_physical_address.value if config.hdmicec.fixed_physical_address.value != "0.0.0.0" else _( "not set") AboutText += "\n\n" + _("HDMI-CEC address") + ": " + address self["AboutScrollLabel"] = ScrollLabel(AboutText) self["key_green"] = Button(_("Translations")) self["key_red"] = Button(_("Latest Commits")) self["key_yellow"] = Button(_("Troubleshoot")) self["key_blue"] = Button(_("Memory Info")) self["key_info"] = StaticText(_("Contact Info")) self["actions"] = ActionMap( ["ColorActions", "SetupActions", "DirectionActions"], { "cancel": self.close, "ok": self.close, "red": self.showCommits, "green": self.showTranslationInfo, "blue": self.showMemoryInfo, "info": self.showContactInfo, "yellow": self.showTroubleshoot, "up": self["AboutScrollLabel"].pageUp, "down": self["AboutScrollLabel"].pageDown })
def __init__(self, session, service, zapFunc=None, eventid=None, bouquetChangeCB=None, serviceChangeCB=None, parent=None): Screen.__init__(self, session) self.bouquetChangeCB = bouquetChangeCB self.serviceChangeCB = serviceChangeCB self.ask_time = -1 #now self["key_red"] = Button("") self.closeRecursive = False self.saved_title = None self["Service"] = ServiceEvent() self["Event"] = Event() self.session = session if isinstance(service, str) and eventid != None: self.type = EPG_TYPE_SIMILAR self.setTitle(_("Similar EPG")) self["key_yellow"] = Button() self["key_blue"] = Button() self["key_red"] = Button() self.currentService = service self.eventid = eventid self.zapFunc = None elif isinstance(service, eServiceReference) or isinstance( service, str): self.setTitle(_("Single EPG")) self.type = EPG_TYPE_SINGLE self["key_yellow"] = Button() self["key_blue"] = Button(_("Select Channel")) self.currentService = ServiceReference(service) self.zapFunc = zapFunc self.sort_type = 0 self.setSortDescription() else: self.setTitle(_("Multi EPG")) self.skinName = "EPGSelectionMulti" self.type = EPG_TYPE_MULTI self["key_yellow"] = Button( pgettext("button label, 'previous screen'", "Prev")) self["key_blue"] = Button( pgettext("button label, 'next screen'", "Next")) self["now_button"] = Pixmap() self["next_button"] = Pixmap() self["more_button"] = Pixmap() self["now_button_sel"] = Pixmap() self["next_button_sel"] = Pixmap() self["more_button_sel"] = Pixmap() self["now_text"] = Label() self["next_text"] = Label() self["more_text"] = Label() self["date"] = Label() self.services = service self.zapFunc = zapFunc self.parent = parent self["key_green"] = Button(_("Add timer")) self.key_green_choice = self.ADD_TIMER self.key_red_choice = self.EMPTY self["list"] = EPGList(type=self.type, selChangedCB=self.onSelectionChanged, timer=session.nav.RecordTimer) self["actions"] = ActionMap( ["EPGSelectActions", "OkCancelActions"], { "cancel": self.closeScreen, "ok": self.eventSelected, "timerAdd": self.timerAdd, "yellow": self.yellowButtonPressed, "blue": self.blueButtonPressed, "info": self.infoKeyPressed, "red": self.zapTo, "menu": self.furtherOptions, "nextBouquet": self.nextBouquet, # just used in multi epg yet "prevBouquet": self.prevBouquet, # just used in multi epg yet "nextService": self.nextService, # just used in single epg yet "prevService": self.prevService, # just used in single epg yet "preview": self.eventPreview, }) self["actions"].csel = self self.onLayoutFinish.append(self.onCreate)
def __init__(self, session, service, zapFunc=None, eventid=None, bouquetChangeCB=None, serviceChangeCB=None, parent=None): Screen.__init__(self, session) self.bouquetChangeCB = bouquetChangeCB self.serviceChangeCB = serviceChangeCB self.ask_time = -1 #now self["key_red"] = StaticText("") self.closeRecursive = False self.saved_title = None self["Service"] = ServiceEvent() self["Event"] = Event() self.session = session self.Console = Console() if isinstance(service, str) and eventid is not None: self.type = EPG_TYPE_SIMILAR self.setTitle(_("Similar EPG")) self["key_yellow"] = StaticText() self["key_blue"] = StaticText() self["key_red"] = StaticText() self.currentService = service self.eventid = eventid self.zapFunc = None elif isinstance(service, eServiceReference) or isinstance( service, str): self.setTitle(_("Single EPG")) self.type = EPG_TYPE_SINGLE self["key_yellow"] = StaticText() self["key_blue"] = StaticText(_("Select Channel")) self.currentService = ServiceReference(service) self.zapFunc = zapFunc self.sort_type = 0 self.setSortDescription() else: self.setTitle(_("Multi EPG")) self.skinName = "EPGSelectionMulti" self.type = EPG_TYPE_MULTI if self.bouquetChangeCB == StaticText: self["key_yellow"] = StaticText( pgettext("button label, 'previous screen'", "Prev")) self["key_blue"] = StaticText( pgettext("button label, 'next screen'", "Next")) else: self["key_yellow"] = Button( pgettext("button label, 'previous screen'", "Prev")) self["key_blue"] = Button( pgettext("button label, 'next screen'", "Next")) self["now_button"] = Pixmap() self["next_button"] = Pixmap() self["more_button"] = Pixmap() self["now_button_sel"] = Pixmap() self["next_button_sel"] = Pixmap() self["more_button_sel"] = Pixmap() self["now_text"] = Label() self["next_text"] = Label() self["more_text"] = Label() self["date"] = Label() self.services = service self.zapFunc = zapFunc self.parent = parent if self.bouquetChangeCB == StaticText: self["key_green"] = StaticText(_("Add timer")) else: self["key_green"] = Button(_("Add timer")) self.key_green_choice = self.ADD_TIMER self.key_red_choice = self.EMPTY self["list"] = EPGList(type=self.type, selChangedCB=self.onSelectionChanged, timer=session.nav.RecordTimer) self["actions"] = ActionMap( ["EPGSelectActions", "OkCancelActions"], { "cancel": self.closeScreen, "ok": self.eventSelected, "timerAdd": self.timerAdd, "yellow": self.yellowButtonPressed, "blue": self.blueButtonPressed, "info": self.infoKeyPressed, "menu": self.furtherOptions, "nextBouquet": self.nextBouquet, # just used in multi epg yet "prevBouquet": self.prevBouquet, # just used in multi epg yet "nextService": self.nextService, # just used in single epg yet "prevService": self.prevService, # just used in single epg yet "preview": self.eventPreview, }) self['colouractions'] = HelpableActionMap( self, 'ColorActions', {"red": (self.GoToTmbd, _("Search event in TMBD"))}) self.isTMBD = fileExists( resolveFilename(SCOPE_PLUGINS, "Extensions/TMBD/plugin.pyo")) if self.isTMBD: self["key_red"] = Button(_("Search TMBD")) self.select = True if not self.isTMBD: self["key_red"] = Button(_("TMBD Not Installed")) self.select = False try: from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__ description = _("Search yt-trailer for event") except ImportError as ie: pass else: if baseEPGSelection__init__ is not None: self["trailerActions"] = ActionMap( ["InfobarActions", "InfobarTeletextActions"], { "showTv": self.showTrailer, "showRadio": self.showTrailerList, "startTeletext": self.showConfig }) self["actions"].csel = self if parent and hasattr(parent, "fallbackTimer"): self.fallbackTimer = parent.fallbackTimer self.onLayoutFinish.append(self.onCreate) else: self.fallbackTimer = FallbackTimerList(self, self.onCreate)
def __init__(self, session, menu_path=""): Screen.__init__(self, session) screentitle = _("Timer List") self.menu_path = menu_path if config.usage.show_menupath.value == 'large': self.menu_path += screentitle title = self.menu_path self["menu_path_compressed"] = StaticText("") self.menu_path += ' / ' elif config.usage.show_menupath.value == 'small': title = screentitle condtext = "" if self.menu_path and not self.menu_path.endswith(' / '): condtext = self.menu_path + " >" elif self.menu_path: condtext = self.menu_path[:-3] + " >" self["menu_path_compressed"] = StaticText(condtext) self.menu_path += screentitle + ' / ' else: title = screentitle self["menu_path_compressed"] = StaticText("") Screen.setTitle(self, title) self.onChangedEntry = [] list = [] self.list = list self.fillTimerList() self["timerlist"] = TimerList(list) self.key_red_choice = self.EMPTY self.key_yellow_choice = self.EMPTY self.key_blue_choice = self.EMPTY self["key_red"] = Button(" ") self["key_green"] = Button(_("Add")) self["key_yellow"] = Button(" ") self["key_blue"] = Button(" ") self["description"] = Label() self["actions"] = ActionMap( [ "OkCancelActions", "DirectionActions", "ShortcutActions", "TimerEditActions" ], { "ok": self.openEdit, "cancel": self.leave, "green": self.addCurrentTimer, "log": self.showLog, "left": self.left, "right": self.right, "up": self.up, "down": self.down }, -1) self.session.nav.RecordTimer.on_state_change.append(self.onStateChange) self.onShown.append(self.updateState) if self.isProtected() and config.ParentalControl.servicepin[0].value: self.onFirstExecBegin.append( boundFunction( self.session.openWithCallback, self.pinEntered, PinInput, pinList=[ x.value for x in config.ParentalControl.servicepin ], triesEntry=config.ParentalControl.retries.servicepin, title=_("Please enter the correct pin code"), windowTitle=_("Enter pin code")))
def __init__(self, session, *args, **kwargs): Screen.__init__(self, session) self.skinName = [self.skinName, "EPGSelection"] if isinstance(self, HelpableScreen): HelpableScreen.__init__(self) self.searchargs = args self.currSearch = "" self.longbuttonpressed = False # XXX: we lose sort begin/end here self["key_yellow"] = Button(_("New Search")) self["key_blue"] = Button(_("Add AutoTimer")) # begin stripped copy of EPGSelection.__init__ self.ChoiceBoxDialog = None self.bouquetChangeCB = None self.serviceChangeCB = None self.ask_time = -1 # now self.closeRecursive = False self.saved_title = None self.lastAsk = None self["Service"] = ServiceEvent() self["Event"] = Event() self["number"] = Label() self["number"].hide() self.type = EPG_TYPE_SINGLE self.currentService = None self.zapFunc = None self.currch = None self.sort_type = 0 self.eventviewDialog = None self["key_red"] = Button(_("IMDb Search")) self["key_green"] = Button(_("Add Timer")) self.key_green_choice = self.ADD_TIMER self.key_red_choice = self.EMPTY self["list"] = EPGSearchList(type=self.type, selChangedCB=self.onSelectionChanged, timer=session.nav.RecordTimer) self["dialogactions"] = HelpableActionMap(self, "WizardActions", { "back": (self.closeChoiceBoxDialog, _("Close dialog")), }, -1) self["dialogactions"].csel = self self["dialogactions"].setEnabled(False) self["okactions"] = HelpableActionMap( self, "OkCancelActions", { "cancel": (self.closeScreen, _("Exit EPG Search")), "OK": (self.epgsearchOK, _("Zap to channel")), "OKLong": (self.epgsearchOKLong, _("Show detailed event information")) }, -1) self["okactions"].csel = self self["colouractions"] = HelpableActionMap( self, "ColorActions", { "red": (self.redButtonPressed, _("IMDB search for highlighted event")), "green": (self.timerAdd, _("Add/remove/edit timer for highlighted event")), "yellow": (self.yellowButtonPressed, _("Enter new search")), "yellowlong": (self.showHistory, _("Show search history")), "blue": (self.exportAutoTimer, _("Add an AutoTimer for highlighted event")), "bluelong": (self.blueButtonPressedLong, _("Show AutoTimer list")) }, -1) self["colouractions"].csel = self self["recordingactions"] = HelpableActionMap( self, "InfobarInstantRecord", { "ShortRecord": (self.doRecordTimer, _("Add a record timer for highlighted event")), "LongRecord": (self.doZapTimer, _("Add a zap timer for highlighted event")) }, -1) self["recordingactions"].csel = self self["epgactions"] = HelpableActionMap( self, "EPGSelectActions", { "nextBouquet": (self.nextPage, _("Move down a page")), "prevBouquet": (self.prevPage, _("Move up a page")), "nextService": (self.prevPage, _("Move up a page")), "prevService": (self.nextPage, _("Move down a page")), "epg": (self.Info, _("Show detailed event information")), "info": (self.Info, _("Show detailed event information")), "infolong": (self.infoKeyPressed, _("Show detailed event information")), "menu": (self.menu, _("Setup menu")) }, -1) self["epgactions"].csel = self self["epgcursoractions"] = HelpableActionMap( self, "DirectionActions", { "left": (self.prevPage, _("Move up a page")), "right": (self.nextPage, _("Move down a page")), "up": (self.moveUp, _("Move up")), "down": (self.moveDown, _("Move down")) }, -1) self["epgcursoractions"].csel = self self.openHistory = kwargs.get("openHistory", False) self.onLayoutFinish.append(self.onCreate) # end stripped copy of EPGSelection.__init__ # Partnerbox if PartnerBoxIconsEnabled: EPGSelection.PartnerboxInit(self, False) self.refreshTimer = eTimer() self.refreshTimer.callback.append(self.refreshlist) self.startTimer = eTimer() self.startTimer.callback.append(self.startUp) self.startTimer.start(10, 1) self.searchStartTimer = eTimer() # Hook up actions for yttrailer if installed try: from Plugins.Extensions.YTTrailer.plugin import baseEPGSelection__init__ except ImportError as ie: pass else: if baseEPGSelection__init__ is not None: self["trailerActions"] = ActionMap( ["InfobarActions", "InfobarTeletextActions"], { "showTv": self.showTrailer, "showRadio": self.showTrailerList, "startTeletext": self.showConfig })
def __init__(self, session, menu_path=""): Screen.__init__(self, session) self.menu_path = menu_path screentitle = _("Plugin Browser") if config.usage.show_menupath.value == 'large': self.menu_path += screentitle title = self.menu_path self["menu_path_compressed"] = StaticText("") self.menu_path += ' / ' elif config.usage.show_menupath.value == 'small': title = screentitle condtext = "" if self.menu_path and not self.menu_path.endswith(' / '): condtext = self.menu_path + " >" elif self.menu_path: condtext = self.menu_path[:-3] + " >" self["menu_path_compressed"] = StaticText(condtext) self.menu_path += screentitle + ' / ' else: title = screentitle self["menu_path_compressed"] = StaticText("") Screen.setTitle(self, title) ProtectedScreen.__init__(self) self.firsttime = True self["key_red"] = Button(_("Remove plugins")) self["key_green"] = Button(_("Download plugins")) self.list = [] self["list"] = PluginList(self.list) if config.usage.sort_pluginlist.value: self["list"].list.sort() self["actions"] = ActionMap(["WizardActions", "MenuActions"], { "ok": self.save, "back": self.close, "menu": self.openSetup, }) self["PluginDownloadActions"] = ActionMap(["ColorActions"], { "red": self.delete, "green": self.download }) self["DirectionActions"] = ActionMap(["DirectionActions"], { "shiftUp": self.moveUp, "shiftDown": self.moveDown }) self["NumberActions"] = NumberActionMap( ["NumberActions"], { "1": self.keyNumberGlobal, "2": self.keyNumberGlobal, "3": self.keyNumberGlobal, "4": self.keyNumberGlobal, "5": self.keyNumberGlobal, "6": self.keyNumberGlobal, "7": self.keyNumberGlobal, "8": self.keyNumberGlobal, "9": self.keyNumberGlobal, "0": self.keyNumberGlobal }) self.number = 0 self.nextNumberTimer = eTimer() self.nextNumberTimer.callback.append(self.okbuttonClick) self.onFirstExecBegin.append(self.checkWarnings) self.onShown.append(self.updateList) self.onChangedEntry = [] self["list"].onSelectionChanged.append(self.selectionChanged) self.onLayoutFinish.append(self.saveListsize)
def __init__(self, session, args = 0): skin = """<screen position="93,70" size="550,450" title="Webcams provided by webcams.travel"> <widget source="list" render="Listbox" position="0,0" size="550,350" zPosition="1" scrollbarMode="showOnDemand" transparent="1" > <convert type="TemplatedMultiContent"> {"templates": {"default": (77,[ MultiContentEntryPixmapAlphaTest(pos = (0, 0), size = (100, 75), png = 4), # index 4 is the thumbnail MultiContentEntryText(pos = (100, 1), size = (500, 22), font=0, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 1), # index 1 is the Title MultiContentEntryText(pos = (100, 24), size = (300, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 5), # index 5 is the Published Date MultiContentEntryText(pos = (100, 43), size = (300, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 6), # index 6 is the Views Count MultiContentEntryText(pos = (400, 24), size = (200, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 7), # index 7 is the duration MultiContentEntryText(pos = (400, 43), size = (200, 18), font=1, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 8), # index 8 is the ratingcount ]), "status": (77,[ MultiContentEntryText(pos = (10, 1), size = (500, 28), font=2, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 0), # index 0 is the name MultiContentEntryText(pos = (10, 22), size = (500, 46), font=3, flags = RT_HALIGN_LEFT | RT_VALIGN_TOP| RT_WRAP, text = 1), # index 2 is the description ]) }, "fonts": [gFont("Regular", 22),gFont("Regular", 18),gFont("Regular", 26),gFont("Regular", 20)], "itemHeight": 77 } </convert> </widget> <widget name="thumbnail" position="0,0" size="100,75" alphatest="on"/> # fake entry for dynamic thumbnail resizing, currently there is no other way doing this. <widget name="count" position="5,360" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" /> <widget name="page" position="150,360" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" /> <widget name="currentnumbers" position="295,360" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" /> <ePixmap position="5,410" zPosition="0" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" /> <ePixmap position="150,410" zPosition="1" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" /> <ePixmap position="295,410" zPosition="2" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" /> <!-- #not used now# ePixmap position="445,410" zPosition="3" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" //--> <widget name="key_red" position="5,410" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" /> <widget name="key_green" position="150,410" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" /> <widget name="key_yellow" position="295,410" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" /> <widget name="key_blue" position="445,410" zPosition="5" size="140,40" valign="center" halign="center" font="Regular;21" transparent="1" foregroundColor="white" shadowColor="black" shadowOffset="-1,-1" /> </screen>""" self.skin = skin Screen.__init__(self, session) self.picloads = {} self.thumbnails = {} self["list"] = List([]) self["thumbnail"] = Pixmap() self["thumbnail"].hide() self["count"] = Label(_("Cams: ")) self["page"] = Label(_("Page: ")) self["currentnumbers"] = Label(_("current: ")) self["key_red"] = Button(_("prev")) self["key_red"].hide() self["key_green"] = Button(_("next")) self["key_green"].hide() self["key_yellow"] = Button(_("search")) self["key_blue"] = Button(_("hdkfjhg")) self["key_blue"].hide() #not used at the moment self["actions"] = ActionMap(["WizardActions", "MenuActions", "DirectionActions", "ShortcutActions"], { "ok": self.onOK, "red": self.onRed, "green": self.onGreen, "yellow": self.onYellow, "back": self.close }, -1) self.finish_loading = True self.timer_default = eTimer() self.timer_default.timeout.callback.append(self.buildCamList) self.timer_status = eTimer() self.timer_status.timeout.callback.append(self.buildStatusList) self.timer_labels = eTimer() self.timer_labels.timeout.callback.append(self.refreshLabels) self.onLayoutFinish.append(self.loadData)
def __init__(self, session, feid): self.session = session Screen.__init__(self, session) self.feid = feid self.oldref = None log.open(self.LOG_SIZE) if config.Nims[self.feid].configMode.value == 'advanced': self.advanced = True self.advancedconfig = config.Nims[self.feid].advanced self.advancedsats = self.advancedconfig.sat self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid)) else: self.advanced = False cur = { } if not self.openFrontend(): self.oldref = session.nav.getCurrentlyPlayingServiceReference() service = session.nav.getCurrentService() feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData(True) del feInfo del service session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if session.pipshown: # try to disable pip service = self.session.pip.pipservice feInfo = service and service.frontendInfo() if feInfo: cur = feInfo.getTransponderData(True) del feInfo del service from Screens.InfoBar import InfoBar InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP() if not self.openFrontend(): self.frontend = None # in normal case this should not happen if hasattr(self, 'raw_channel'): del self.raw_channel self.frontendStatus = { } self.diseqc = Diseqc(self.frontend) # True means we dont like that the normal sec stuff sends commands to the rotor! self.tuner = Tuner(self.frontend, ignore_rotor = True) tp = ( cur.get("frequency", 0) / 1000, cur.get("symbol_rate", 0) / 1000, cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal), cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto), cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown), cur.get("orbital_position", 0), cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S), cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK), cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)) self.tuner.tune(tp) self.isMoving = False self.stopOnLock = False self.red = Button("") self["key_red"] = self.red self.green = Button("") self["key_green"] = self.green self.yellow = Button("") self["key_yellow"] = self.yellow self.blue = Button("") self["key_blue"] = self.blue self.list = [] self["list"] = ConfigList(self.list) self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus) self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus) self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus) self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus) self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus) self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus) self["frequency_value"] = Label("") self["symbolrate_value"] = Label("") self["fec_value"] = Label("") self["polarisation"] = Label("") self["status_bar"] = Label("") self.statusMsgTimeoutTicks = 0 self.statusMsgBlinking = False self.statusMsgBlinkCount = 0 self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL # milliseconds self.tuningChangedTo(tp) self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"], { "ok": self.keyOK, "cancel": self.keyCancel, "up": self.keyUp, "down": self.keyDown, "left": self.keyLeft, "right": self.keyRight, "red": self.redKey, "green": self.greenKey, "yellow": self.yellowKey, "blue": self.blueKey, "log": self.showLog, "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.updateColors("tune") self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) self.collectingStatistics = False self.statusTimer.start(self.UPDATE_INTERVAL, True) self.dataAvailable = Event() self.onClose.append(self.__onClose) self.createConfig() self.createSetup()
def __init__(self, session): self.session = session Screen.__init__(self, session) self.skinName = "XBMCAddonsdownloadsscreen" #self["list"] = RSList([]) self['info'] = Label() self['key_red'] = Button(_('Exit')) self["key_green"] = Label(_("Play")) self['key_yellow'] = Button(_("Rename ")) self['key_blue'] = Button(_("Delete")) downloadlocation = config.plugins.kodiplug.cachefold.value self["info"] = Label(_("Download Path: ") + downloadlocation) self.streamMenuList = MenuList([], enableWrapAround=True, content=eListboxPythonMultiContent) self.streamMenuList.l.setFont(0, gFont('Regular', 20)) self.streamMenuList.l.setFont(1, gFont('Regular', 18)) self.streamMenuList.l.setFont(2, gFont('Regular', 12)) self.streamMenuList.l.setFont(3, gFont('Regular', 10)) self.streamMenuList.l.setItemHeight(37) self["list"] = self.streamMenuList ############ self.movie_list = [] self.searchstr = None self.searchagain = "titanic" self.filmliste = [] #self.mlist.setList(map(channelEntryIPTVplaylist, self.channel_list)) self.page = 1 #self.glist.onSelectionChanged.append(self.groupselectionchanged) self.streamMenuList.onSelectionChanged.append( self.moviesselectionchanged) self.onShown.append(self.getlocalmedia) self["actions"] = ActionMap( [ "ColorActions", "SetupActions", "DirectionActions", "PiPSetupActions", "WizardActions", "NumberActions", "EPGSelectActions" ], { "red": self.deletefile, "green": self.keyOK, "blue": self.deletefile, "yellow": self.renamefile, #self.addfavorite, "ok": self.keyOK, #"info" : self.viewdownloads, "cancel": self.exit, "up": self["list"].up, "down": self["list"].down, "left": self["list"].pageUp, "right": self["list"].pageDown, }, -1) self.pages = [] cat_movies = [] self.movies = [] self.pagemovies = [] self.desc = "" self.keyLocked = False self.page = 1 self.download = False #self.onLayoutFinish.append(self.loadPage) self.searchstr = None self.page = 1