class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): skin = """<screen position="80,95" size="560,412" title="DiSEqC Tester Test Settings"> <widget name="config" position="10,10" size="540,402" scrollbarMode="showOnDemand" /> </screen> """ def __init__(self, session, feid): Screen.__init__(self, session) self.feid = feid self.list = [] ConfigListScreen.__init__(self, self.list) self["actions"] = ActionMap(["SetupActions"], { "cancel": self.keyCancel }, -2) self.createSetup() def createSetup(self): self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random"), "complete": _("Complete")}, default = "quick") self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype) self.list.append(self.testtypeEntry) self.loopsfailed = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "3") self.loopsfailedEntry = getConfigListEntry(_("Stop testing plane after # failed transponders"), self.loopsfailed) self.list.append(self.loopsfailedEntry) self.loopssuccessful = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "1") self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful) self.list.append(self.loopssuccessfulEntry) self.log = ConfigYesNo(False) if harddiskmanager.HDDCount() > 0: self.logEntry = getConfigListEntry(_("Log results to harddisk"), self.log) self.list.append(self.logEntry) self["config"].list = self.list self["config"].l.setList(self.list) def keyOK(self): print self.testtype.getValue() testtype = DiseqcTester.TEST_TYPE_QUICK if self.testtype.getValue() == "quick": testtype = DiseqcTester.TEST_TYPE_QUICK elif self.testtype.getValue() == "random": testtype = DiseqcTester.TEST_TYPE_RANDOM elif self.testtype.getValue() == "complete": testtype = DiseqcTester.TEST_TYPE_COMPLETE self.session.open(DiseqcTester, feid = self.feid, test_type = testtype, loopsfailed = int(self.loopsfailed.value), loopssuccessful = int(self.loopssuccessful.value), log = self.log.value) def keyCancel(self): self.close()
class DiseqcTesterTestTypeSelection(ConfigListScreen, Screen): def __init__(self, session, feid): Screen.__init__(self, session) # for the skin: first try 'DiseqcTesterTestTypeSelection', then 'Setup', this allows individual skinning self.skinName = ["DiseqcTesterTestTypeSelection", "Setup"] self.setTitle(_("DiSEqC-tester settings")) self.feid = feid self["actions"] = ActionMap(["SetupActions", "MenuActions"], { "cancel": self.keyCancel, "save": self.keyOK, "ok": self.keyOK, "menu": self.closeRecursive, }, -2) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("OK")) self.list = [] self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random"), "complete": _("Complete")}, default="quick") self.testtypeEntry = getConfigListEntry(_("Test type"), self.testtype) self.list.append(self.testtypeEntry) self.loopsfailed = ConfigSelection(choices={"-1": _("Every known"), "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default="3") self.loopsfailedEntry = getConfigListEntry(_("Stop testing plane after # failed transponders"), self.loopsfailed) self.list.append(self.loopsfailedEntry) self.loopssuccessful = ConfigSelection(choices={"-1": _("Every known"), "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default="1") self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful) self.list.append(self.loopssuccessfulEntry) self.log = ConfigYesNo(False) self.logEntry = getConfigListEntry(_("Log results to /tmp"), self.log) self.list.append(self.logEntry) ConfigListScreen.__init__(self, self.list, session) def keyOK(self): print self.testtype.getValue() testtype = DiseqcTester.TEST_TYPE_QUICK if self.testtype.getValue() == "quick": testtype = DiseqcTester.TEST_TYPE_QUICK elif self.testtype.getValue() == "random": testtype = DiseqcTester.TEST_TYPE_RANDOM elif self.testtype.getValue() == "complete": testtype = DiseqcTester.TEST_TYPE_COMPLETE self.session.open(DiseqcTester, feid=self.feid, test_type=testtype, loopsfailed=int(self.loopsfailed.value), loopssuccessful=int(self.loopssuccessful.value), log=self.log.value) def keyCancel(self): self.close()
class CableScanScreen(ConfigListScreen, Screen): skin = """ <screen position="100,115" size="520,290" title="Cable Scan"> <widget name="config" position="10,10" size="500,250" scrollbarMode="showOnDemand" /> <widget name="introduction" position="10,265" size="500,25" font="Regular;20" halign="center" /> </screen>""" def __init__(self, session): Screen.__init__(self, session) self["actions"] = ActionMap(["SetupActions", "MenuActions"], { "ok": self.keyGo, "cancel": self.keyCancel, "menu": self.closeRecursive, }, -2) nimlist = nimmanager.getNimListOfType("DVB-C") nim_list = [] for x in nimlist: nim_list.append((nimmanager.nim_slots[x].slot, nimmanager.nim_slots[x].friendly_full_description)) self.scan_nims = ConfigSelection(choices = nim_list) self.list = [] self.list.append(getConfigListEntry(_("Tuner"), self.scan_nims)) self.list.append(getConfigListEntry(_('Frequency'), config.plugins.CableScan.frequency)) self.list.append(getConfigListEntry(_('Symbol rate'), config.plugins.CableScan.symbolrate)) self.list.append(getConfigListEntry(_('Modulation'), config.plugins.CableScan.modulation)) self.list.append(getConfigListEntry(_('Network ID'), config.plugins.CableScan.networkid)) self.list.append(getConfigListEntry(_("Use official channel numbering"), config.plugins.CableScan.keepnumbering)) self.list.append(getConfigListEntry(_("HD list"), config.plugins.CableScan.hdlist)) ConfigListScreen.__init__(self, self.list) self["config"].list = self.list self["config"].l.setList(self.list) self.finished_cb = None self["introduction"] = Label(_("Configure your network settings, and press OK to start the scan")) def keyGo(self): config.plugins.CableScan.save() self.startScan() def startScan(self): self.session.open(CableScanStatus, scanTuner = int(self.scan_nims.getValue()), scanNetwork = config.plugins.CableScan.networkid.getValue(), scanFrequency = config.plugins.CableScan.frequency.getValue() * 1000, scanSymbolRate = config.plugins.CableScan.symbolrate.getValue() * 1000, scanModulation = int(config.plugins.CableScan.modulation.getValue()), keepNumbers = config.plugins.CableScan.keepnumbering.getValue(), hdList = config.plugins.CableScan.hdlist.getValue()) def keyCancel(self): self.close()
class RemoteControlType(Screen, ConfigListScreen): rcList = [ ("0", _("Default")), ("3", _("OdinM9")), ("4", _("DMM normal")), ("6", _("DMM advanced")), ("7", _("et5000/6000")), ("8", _("VU+")), ("11", _("et9x00/6500")), ("13", _("et4000")), ("14", _("XP1000")), ] defaultRcList = [ ("et4000", 13), ("et5000", 7), ("et6000", 7), ("et6500", 11), ("et9000", 11), ("et9200", 11), ("et9500", 11), ("xp1000", 14), ] def __init__(self, session): Screen.__init__(self, session) self.skinName = ["RemoteControlType", "Setup" ] self["actions"] = ActionMap(["SetupActions"], { "cancel": self.keyCancel, "save": self.keySave, }, -1) self["key_green"] = StaticText(_("Save")) self["key_red"] = StaticText(_("Cancel")) self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session) rctype = config.plugins.remotecontroltype.rctype.getValue() self.rctype = ConfigSelection(choices = self.rcList, default = str(rctype)) self.list.append(getConfigListEntry(_("Remote control type"), self.rctype)) self["config"].list = self.list self.defaultRcType = None self.getDefaultRcType() def getDefaultRcType(self): data = iRcTypeControl.getBoxType() for x in self.defaultRcList: if x[0] in data: self.defaultRcType = x[1] break def setDefaultRcType(self): iRcTypeControl.writeRcType(self.defaultRcType) def keySave(self): if config.plugins.remotecontroltype.rctype.getValue() == int(self.rctype.getValue()): self.close() else: self.setNewSetting() self.session.openWithCallback(self.keySaveCallback, MessageBox, _("Is this setting ok?"), MessageBox.TYPE_YESNO, timeout = 20, default = False) def keySaveCallback(self, answer): if answer is False: self.restoreOldSetting() else: config.plugins.remotecontroltype.rctype.value = int(self.rctype.getValue()) config.plugins.remotecontroltype.save() self.close() def restoreOldSetting(self): if config.plugins.remotecontroltype.rctype.getValue() == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(config.plugins.remotecontroltype.rctype.getValue()) def setNewSetting(self): if int(self.rctype.getValue()) == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(int(self.rctype.getValue())) def keyCancel(self): self.restoreOldSetting() self.close()
class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): def __init__(self, session, feid): Screen.__init__(self, session) # for the skin: first try MediaPlayerSettings, then Setup, this allows individual skinning self.skinName = ["DiseqcTesterTestTypeSelection", "Setup"] self.setup_title = _("DiSEqC-tester settings") self.onChangedEntry = [] self.feid = feid self.list = [] ConfigListScreen.__init__(self, self.list, session=self.session, on_change=self.changedEntry) self["actions"] = ActionMap( ["SetupActions", "MenuActions"], { "cancel": self.keyCancel, "save": self.keyOK, "ok": self.keyOK, "menu": self.closeRecursive, }, -2) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("OK")) self.createSetup() self.onLayoutFinish.append(self.layoutFinished) def layoutFinished(self): self.setTitle(self.setup_title) def createSetup(self): self.testtype = ConfigSelection(choices={ "quick": _("Quick"), "random": _("Random"), "complete": _("Complete") }, default="quick") self.testtypeEntry = getConfigListEntry(_("Test type"), self.testtype) self.list.append(self.testtypeEntry) self.loopsfailed = ConfigSelection(choices={ "-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8" }, default="3") self.loopsfailedEntry = getConfigListEntry( _("Stop testing plane after # failed transponders"), self.loopsfailed) self.list.append(self.loopsfailedEntry) self.loopssuccessful = ConfigSelection(choices={ "-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8" }, default="1") self.loopssuccessfulEntry = getConfigListEntry( _("Stop testing plane after # successful transponders"), self.loopssuccessful) self.list.append(self.loopssuccessfulEntry) self.log = ConfigYesNo(False) if harddiskmanager.HDDCount() > 0: self.logEntry = getConfigListEntry(_("Log results to harddisk"), self.log) self.list.append(self.logEntry) self["config"].list = self.list self["config"].l.setList(self.list) def keyOK(self): print self.testtype.getValue() testtype = DiseqcTester.TEST_TYPE_QUICK if self.testtype.getValue() == "quick": testtype = DiseqcTester.TEST_TYPE_QUICK elif self.testtype.getValue() == "random": testtype = DiseqcTester.TEST_TYPE_RANDOM elif self.testtype.getValue() == "complete": testtype = DiseqcTester.TEST_TYPE_COMPLETE self.session.open(DiseqcTester, feid=self.feid, test_type=testtype, loopsfailed=int(self.loopsfailed.value), loopssuccessful=int(self.loopssuccessful.value), log=self.log.value) def keyCancel(self): self.close() # for summary: def changedEntry(self): for x in self.onChangedEntry: x() def getCurrentEntry(self): return self["config"].getCurrent()[0] def getCurrentValue(self): return str(self["config"].getCurrent()[1].getText()) def createSummary(self): from Screens.Setup import SetupSummary return SetupSummary
class FastScanScreen(ConfigListScreen, Screen): skin = """ <screen position="100,115" size="520,290" title="Fast Scan"> <widget name="config" position="10,10" size="500,250" scrollbarMode="showOnDemand" /> <widget name="introduction" position="10,265" size="500,25" font="Regular;20" halign="center" /> </screen>""" def __init__(self, session, nimList): Screen.__init__(self, session) self.setTitle(_("Fast Scan")) self.providers = {} self.providers['Canal Digitaal'] = (1, 900, True) self.providers['TV Vlaanderen'] = (1, 910, True) self.providers['TéléSAT'] = (0, 920, True) self.providers['AustriaSat'] = (0, 950, False) self.providers['Skylink Czech Republic'] = (1, 30, False) self.providers['Skylink Slovak Republic'] = (1, 31, False) self.providers['TéléSAT Astra3'] = (1, 920, True) self.providers['AustriaSat Astra3'] = (1, 950, False) self.providers['Canal Digitaal Astra 1'] = (0, 900, True) self.providers['TV Vlaanderen Astra 1'] = (0, 910, True) self.transponders = ((12515000, 22000000, eDVBFrontendParametersSatellite.FEC_5_6, 192, eDVBFrontendParametersSatellite.Polarisation_Horizontal, eDVBFrontendParametersSatellite.Inversion_Unknown, eDVBFrontendParametersSatellite.System_DVB_S, eDVBFrontendParametersSatellite.Modulation_QPSK, eDVBFrontendParametersSatellite.RollOff_alpha_0_35, eDVBFrontendParametersSatellite.Pilot_Off), (12070000, 27500000, eDVBFrontendParametersSatellite.FEC_3_4, 235, eDVBFrontendParametersSatellite.Polarisation_Horizontal, eDVBFrontendParametersSatellite.Inversion_Unknown, eDVBFrontendParametersSatellite.System_DVB_S, eDVBFrontendParametersSatellite.Modulation_QPSK, eDVBFrontendParametersSatellite.RollOff_alpha_0_35, eDVBFrontendParametersSatellite.Pilot_Off)) self["actions"] = ActionMap(["SetupActions", "MenuActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "menu": self.closeRecursive, }, -2) providerList = list(x[0] for x in sorted(self.providers.iteritems(), key = operator.itemgetter(1))) lastConfiguration = eval(config.misc.fastscan.last_configuration.value) if not lastConfiguration: lastConfiguration = (nimList[0][0], providerList[0], True, True, False) self.scan_nims = ConfigSelection(default = lastConfiguration[0], choices = nimList) self.scan_provider = ConfigSelection(default = lastConfiguration[1], choices = providerList) self.scan_hd = ConfigYesNo(default = lastConfiguration[2]) self.scan_keepnumbering = ConfigYesNo(default = lastConfiguration[3]) self.scan_keepsettings = ConfigYesNo(default = lastConfiguration[4]) self.list = [] self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) self.scanProvider = getConfigListEntry(_("Provider"), self.scan_provider) self.list.append(self.scanProvider) self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd) self.list.append(self.scanHD) self.list.append(getConfigListEntry(_("Use fastscan channel numbering"), self.scan_keepnumbering)) self.list.append(getConfigListEntry(_("Use fastscan channel names"), self.scan_keepsettings)) ConfigListScreen.__init__(self, self.list) self["config"].list = self.list self["config"].l.setList(self.list) self.finished_cb = None self["introduction"] = Label(_("Select your provider, and press OK to start the scan")) def keyGo(self): config.misc.fastscan.last_configuration.value = `(self.scan_nims.value, self.scan_provider.value, self.scan_hd.value, self.scan_keepnumbering.value, self.scan_keepsettings.value)` config.misc.fastscan.save() self.startScan() def getTransponderParameters(self, number): transponderParameters = eDVBFrontendParametersSatellite() transponderParameters.frequency = self.transponders[number][0] transponderParameters.symbol_rate = self.transponders[number][1] transponderParameters.fec = self.transponders[number][2] transponderParameters.orbital_position = self.transponders[number][3] transponderParameters.polarisation = self.transponders[number][4] transponderParameters.inversion = self.transponders[number][5] transponderParameters.system = self.transponders[number][6] transponderParameters.modulation = self.transponders[number][7] transponderParameters.rolloff = self.transponders[number][8] transponderParameters.pilot = self.transponders[number][9] return transponderParameters def startScan(self): pid = self.providers[self.scan_provider.getValue()][1] if self.scan_hd.getValue() and self.providers[self.scan_provider.value][2]: pid += 1 if self.scan_nims.value: self.session.open(FastScanStatus, scanTuner = int(self.scan_nims.getValue()), transponderParameters = self.getTransponderParameters(self.providers[self.scan_provider.getValue()][0]), scanPid = pid, keepNumbers = self.scan_keepnumbering.getValue(), keepSettings = self.scan_keepsettings.getValue(), providerName = self.scan_provider.getText()) def keyCancel(self): self.close()
class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): skin = """<screen position="80,95" size="560,412" title="DiSEqC Tester Test Settings"> <widget name="config" position="10,10" size="540,402" scrollbarMode="showOnDemand" /> </screen> """ def __init__(self, session, feid): Screen.__init__(self, session) self.feid = feid self.list = [] ConfigListScreen.__init__(self, self.list) self["actions"] = ActionMap(["SetupActions"], {"cancel": self.keyCancel}, -2) self.createSetup() def createSetup(self): self.testtype = ConfigSelection(choices={ "quick": _("Quick"), "random": _("Random"), "complete": _("Complete") }, default="quick") self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype) self.list.append(self.testtypeEntry) self.loopsfailed = ConfigSelection(choices={ "-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8" }, default="3") self.loopsfailedEntry = getConfigListEntry( _("Stop testing plane after # failed transponders"), self.loopsfailed) self.list.append(self.loopsfailedEntry) self.loopssuccessful = ConfigSelection(choices={ "-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8" }, default="1") self.loopssuccessfulEntry = getConfigListEntry( _("Stop testing plane after # successful transponders"), self.loopssuccessful) self.list.append(self.loopssuccessfulEntry) self.log = ConfigYesNo(False) if harddiskmanager.HDDCount() > 0: self.logEntry = getConfigListEntry(_("Log results to harddisk"), self.log) self.list.append(self.logEntry) self["config"].list = self.list self["config"].l.setList(self.list) def keyOK(self): print self.testtype.getValue() testtype = DiseqcTester.TEST_TYPE_QUICK if self.testtype.getValue() == "quick": testtype = DiseqcTester.TEST_TYPE_QUICK elif self.testtype.getValue() == "random": testtype = DiseqcTester.TEST_TYPE_RANDOM elif self.testtype.getValue() == "complete": testtype = DiseqcTester.TEST_TYPE_COMPLETE self.session.open(DiseqcTester, feid=self.feid, test_type=testtype, loopsfailed=int(self.loopsfailed.value), loopssuccessful=int(self.loopssuccessful.value), log=self.log.value) def keyCancel(self): self.close()
class KeymapSel(ConfigListScreen, Screen): def __init__(self, session): Screen.__init__(self, session) self.session = session self.skinName = ["SetupInfo", "Setup"] Screen.setTitle(self, _("Keymap Selection") + "...") self.setup_title = _("Keymap Selection") + "..." self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["status"] = StaticText() self['footnote'] = Label("") self["description"] = Label("") self["labelInfo"] = Label( _("Copy your keymap to\n/usr/share/enigma2/keymap.usr")) usrkey = eEnv.resolve("${datadir}/enigma2/keymap.usr") ntrkey = eEnv.resolve("${datadir}/enigma2/keymap.ntr") u80key = eEnv.resolve("${datadir}/enigma2/keymap.u80") self.actkeymap = self.getKeymap(config.usage.keymap.getValue()) keySel = [('keymap.xml', _("Default (keymap.xml)"))] if os.path.isfile(usrkey): keySel.append(('keymap.usr', _("User (keymap.usr)"))) if os.path.isfile(ntrkey): keySel.append(('keymap.ntr', _("Neut (keymap.ntr)"))) if os.path.isfile(u80key): keySel.append(('keymap.u80', _("UP80 (keymap.u80)"))) if self.actkeymap == usrkey and not os.path.isfile(usrkey): setDefaultKeymap() if self.actkeymap == ntrkey and not os.path.isfile(ntrkey): setDefaultKeymap() if self.actkeymap == u80key and not os.path.isfile(u80key): setDefaultKeymap() self.keyshow = ConfigSelection(keySel) self.keyshow.setValue(self.actkeymap) self.onChangedEntry = [] self.list = [] ConfigListScreen.__init__(self, self.list, session=self.session, on_change=self.changedEntry) self.createSetup() self["actions"] = ActionMap( ["SetupActions", 'ColorActions'], { "ok": self.keySave, "cancel": self.keyCancel, "red": self.keyCancel, "green": self.keySave, "menu": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("OK")) if not self.selectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.selectionChanged) self.selectionChanged() def createSetup(self): self.editListEntry = None self.list = [] self.list.append(getConfigListEntry(_("Use Keymap"), self.keyshow)) self["config"].list = self.list self["config"].setList(self.list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def selectionChanged(self): self["status"].setText(self["config"].getCurrent()[0]) def changedEntry(self): for x in self.onChangedEntry: x() self.selectionChanged() def getCurrentEntry(self): return self["config"].getCurrent()[0] def getCurrentValue(self): return str(self["config"].getCurrent()[1].getText()) def getCurrentDescription(self): return self["config"].getCurrent() and len(self["config"].getCurrent( )) > 2 and self["config"].getCurrent()[2] or "" def createSummary(self): from Screens.Setup import SetupSummary return SetupSummary def saveAll(self): config.usage.keymap.setValue( eEnv.resolve("${datadir}/enigma2/" + self.keyshow.getValue())) config.usage.keymap.save() configfile.save() if self.actkeymap != self.keyshow.getValue(): self.changedFinished() def keySave(self): self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback( self.cancelConfirm, MessageBox, _("Really close without saving settings?")) else: self.close() def getKeymap(self, file): return file[file.rfind('/') + 1:] def changedFinished(self): self.session.openWithCallback( self.ExecuteRestart, MessageBox, _("Keymap changed, you need to restart the GUI") + "\n" + _("Do you want to restart now?"), MessageBox.TYPE_YESNO) self.close() def ExecuteRestart(self, result): if result: quitMainloop(3) else: self.close()
class RemoteControlType(Screen, ConfigListScreen): rcList = [ ("0", _("Default")), ("3", _("MaraM9")), ("4", _("DMM normal")), ("5", _("et9000/et9100")), ("6", _("DMM advanced")), ("7", _("et5000/6000")), ("8", _("VU+")), ("9", _("et8000/et10000")), ("11", _("et9200/9500/6500")), ("13", _("et4000")), ("14", _("XP1000")), ("16", _("HD1100/HD1200/HD1265/HD500C/et7x00/et8500")), ("17", _("XP3000")), ("18", _("F1/F3/TRIPLEX")), ("19", _("HD2400")), ("20", _("Zgemma Star S/2S/H1/H2")), ("21", _("Zgemma H.S/H.2S/H.2H/H5")) ] defaultRcList = [ ("et4000", 13), ("et5000", 7), ("et6000", 7), ("et6500", 11), ("et7x00",16), ("et8000", 9), ("et8500",16), ("et9000", 5), ("et9100", 5), ("et9200", 11), ("et9500", 11), ("et10000", 9), ("hd1100",16), ("hd1200",16), ("hd1265",16), ("hd500c",16), ("hd2400",19), ("formuler1",18), ("formuler3",18), ("triplex",18), ("xp1000", 14), ("xp3000", 17), ("sh1", 20), ("h3", 21), ("h5", 21) ] def __init__(self, session): Screen.__init__(self, session) self.skinName = ["RemoteControlType", "Setup" ] self["actions"] = ActionMap(["SetupActions"], { "cancel": self.keyCancel, "save": self.keySave, }, -1) self["key_green"] = StaticText(_("Save")) self["key_red"] = StaticText(_("Cancel")) self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session) rctype = config.plugins.remotecontroltype.rctype.getValue() self.rctype = ConfigSelection(choices = self.rcList, default = str(rctype)) self.list.append(getConfigListEntry(_("Remote control type"), self.rctype)) self["config"].list = self.list self.defaultRcType = None self.getDefaultRcType() def getDefaultRcType(self): data = iRcTypeControl.getBoxType() for x in self.defaultRcList: if x[0] in data: self.defaultRcType = x[1] break def setDefaultRcType(self): iRcTypeControl.writeRcType(self.defaultRcType) def keySave(self): if config.plugins.remotecontroltype.rctype.getValue() == int(self.rctype.getValue()): self.close() else: self.setNewSetting() self.session.openWithCallback(self.keySaveCallback, MessageBox, _("Is this setting ok?"), MessageBox.TYPE_YESNO, timeout=20, default=True, timeout_default=False) def keySaveCallback(self, answer): if answer is False: self.restoreOldSetting() else: config.plugins.remotecontroltype.rctype.value = int(self.rctype.getValue()) config.plugins.remotecontroltype.save() self.close() def restoreOldSetting(self): if config.plugins.remotecontroltype.rctype.getValue() == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(config.plugins.remotecontroltype.rctype.getValue()) def setNewSetting(self): if int(self.rctype.value) == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(int(self.rctype.value)) def keyCancel(self): self.restoreOldSetting() self.close()
class TimeshiftSettings(Screen,ConfigListScreen): def removeNotifier(self): if config.usage.setup_level.notifiers: config.usage.setup_level.notifiers.remove(self.levelChanged) def levelChanged(self, configElement): list = [] self.refill(list) self["config"].setList(list) def refill(self, list): xmldata = setupdom().getroot() for x in xmldata.findall("setup"): if x.get("key") != self.setup: continue self.addItems(list, x) self.setup_title = x.get("title", "").encode("UTF-8") self.seperation = int(x.get('separation', '0')) def __init__(self, session): Screen.__init__(self, session) self.skinName = "Setup" self['footnote'] = Label() self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self["description"] = Label(_("")) self.onChangedEntry = [ ] self.setup = "timeshift" list = [] ConfigListScreen.__init__(self, list, session = session, on_change = self.changedEntry) self.createSetup() self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "green": self.keySave, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, "menu": self.closeRecursive, }, -2) self.onLayoutFinish.append(self.layoutFinished) # for summary: def changedEntry(self): self.item = self["config"].getCurrent() if self["config"].getCurrent()[0] == _("Timeshift location"): self.checkReadWriteDir(self["config"].getCurrent()[1]) if self["config"].getCurrent()[0] == _("Autorecord location"): self.checkReadWriteDir(self["config"].getCurrent()[1]) for x in self.onChangedEntry: x() try: if isinstance(self["config"].getCurrent()[1], ConfigYesNo) or isinstance(self["config"].getCurrent()[1], ConfigSelection): self.createSetup() except: pass def getCurrentEntry(self): return self["config"].getCurrent() and self["config"].getCurrent()[0] or "" def getCurrentValue(self): return self["config"].getCurrent() and str(self["config"].getCurrent()[1].getText()) or "" def getCurrentDescription(self): return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or "" def checkReadWriteDir(self, configele): import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions(False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append((partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint(os.path.realpath(configele.getValue()))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(configele.getValue())) in locations: if fileExists(configele.value, "w"): configele.last_value = configele.getValue() return True else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead.")%dir, type = MessageBox.TYPE_ERROR ) return False else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%dir, type = MessageBox.TYPE_ERROR ) return False else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%dir, type = MessageBox.TYPE_ERROR ) return False def createSetup(self): default = config.usage.timeshift_path.getValue() cooldefault = config.usage.autorecord_path.getValue() tmp = config.usage.allowed_timeshift_paths.getValue() cooltmp = config.usage.allowed_autorecord_paths.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) if cooldefault not in cooltmp: cooltmp = cooltmp[:] cooltmp.append(cooldefault) # print "TimeshiftPath: ", default, tmp self.timeshift_dirname = ConfigSelection(default = default, choices = tmp) self.autorecord_dirname = ConfigSelection(default = cooldefault, choices = cooltmp) self.timeshift_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.autorecord_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) list = [] self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname, _("Set the default location for your timeshift-files. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.timeshift_entry) self.autorecord_entry = getConfigListEntry(_("Autorecord location"), self.autorecord_dirname, _("Set the default location for your autorecord-files. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.autorecord_entry) self.refill(list) self["config"].setList(list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.getValue() self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.getValue() self.lastautorecorddirs = config.usage.allowed_autorecord_paths.getValue() if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.getValue() self.session.openWithCallback( self.dirnameSelected, TimeshiftLocationBox ) if currentry == self.autorecord_entry: self.entrydirname = self.autorecord_dirname config.usage.autorecord_path.value = self.autorecord_dirname.getValue() self.session.openWithCallback( self.dirnameSelected, AutorecordLocationBox ) def dirnameSelected(self, res): if res is not None: import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions(False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append((partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint(os.path.realpath(res))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(res)) in locations: self.entrydirname.value = res if config.usage.allowed_timeshift_paths.getValue() != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.getValue() default = self.timeshift_dirname.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if config.usage.allowed_autorecord_paths.getValue() != self.lastautorecorddirs: tmp = config.usage.allowed_autorecord_paths.getValue() default = self.autorecord_dirname.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) self.autorecord_dirname.setChoices(tmp, default=default) self.entrydirname.value = res else: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%res, type = MessageBox.TYPE_ERROR ) else: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%res, type = MessageBox.TYPE_ERROR ) def saveAll(self): for x in self["config"].list: x[1].save() configfile.save() # keySave and keyCancel are just provided in case you need them. # you have to call them by yourself. def keySave(self): import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions(False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append((partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint(os.path.realpath(config.usage.timeshift_path.getValue()))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(config.usage.timeshift_path.getValue())) in locations: config.usage.timeshift_path.value = self.timeshift_dirname.getValue() config.usage.timeshift_path.save() self.saveAll() self.close() else: if int(config.timeshift.startdelay.getValue()) > 0: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%config.usage.timeshift_path.getValue(), type = MessageBox.TYPE_ERROR ) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() else: if int(config.timeshift.startdelay.getValue()) > 0: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%config.usage.timeshift_path.getValue(), type = MessageBox.TYPE_ERROR ) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"), default = False) else: self.close() def createSummary(self): return SetupSummary def addItems(self, list, parentNode): for x in parentNode: if not x.tag: continue if x.tag == 'item': item_level = int(x.get("level", 0)) if not self.levelChanged in config.usage.setup_level.notifiers: config.usage.setup_level.notifiers.append(self.levelChanged) self.onClose.append(self.removeNotifier) if item_level > config.usage.setup_level.index: continue requires = x.get("requires") if requires and requires.startswith('config.'): item = eval(requires or "") if item.getValue() and not item.getValue() == "0": SystemInfo[requires] = True else: SystemInfo[requires] = False if requires and not SystemInfo.get(requires, False): continue item_text = _(x.get("text", "??").encode("UTF-8")) item_description = _(x.get("description", " ").encode("UTF-8")) b = eval(x.text or "") if b == "": continue #add to configlist item = b # the first b is the item itself, ignored by the configList. # the second one is converted to string. if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class KeymapSel(ConfigListScreen, Screen): def __init__(self, session): Screen.__init__(self, session) self.session = session self.skinName = ['SetupInfo', 'Setup'] Screen.setTitle(self, _('Keymap Selection') + '...') self.setup_title = _('Keymap Selection') + '...' self['HelpWindow'] = Pixmap() self['HelpWindow'].hide() self['status'] = StaticText() self['footnote'] = Label('') self['description'] = Label('') self['labelInfo'] = Label(_('Copy your keymap to\n/usr/share/enigma2/keymap.usr')) mqbkey = eEnv.resolve('${datadir}/enigma2/keymap.mqb') usrkey = eEnv.resolve('${datadir}/enigma2/keymap.usr') ntrkey = eEnv.resolve('${datadir}/enigma2/keymap.ntr') u80key = eEnv.resolve('${datadir}/enigma2/keymap.u80') self.actkeymap = self.getKeymap(config.usage.keymap.getValue()) keySel = [('keymap.xml', _('Default (keymap.xml)'))] if os.path.isfile(mqbkey): keySel.append(('keymap.mqb', _('ET-MultiQuickButton (keymap.mqb)'))) if os.path.isfile(usrkey): keySel.append(('keymap.usr', _('User (keymap.usr)'))) if os.path.isfile(ntrkey): keySel.append(('keymap.ntr', _('Neutrino (keymap.ntr)'))) if os.path.isfile(u80key): keySel.append(('keymap.u80', _('UP80 (keymap.u80)'))) if self.actkeymap == usrkey and not os.path.isfile(usrkey): setDefaultKeymap() if self.actkeymap == ntrkey and not os.path.isfile(ntrkey): setDefaultKeymap() if self.actkeymap == u80key and not os.path.isfile(u80key): setDefaultKeymap() self.keyshow = ConfigSelection(keySel) self.keyshow.setValue(self.actkeymap) self.onChangedEntry = [] self.list = [] ConfigListScreen.__init__(self, self.list, session=self.session, on_change=self.changedEntry) self.createSetup() self['actions'] = ActionMap(['SetupActions', 'ColorActions'], {'ok': self.keySave, 'cancel': self.keyCancel, 'red': self.keyCancel, 'green': self.keySave, 'menu': self.keyCancel}, -2) self['key_red'] = StaticText(_('Cancel')) self['key_green'] = StaticText(_('OK')) if self.selectionChanged not in self['config'].onSelectionChanged: self['config'].onSelectionChanged.append(self.selectionChanged) self.selectionChanged() def createSetup(self): self.editListEntry = None self.list = [] self.list.append(getConfigListEntry(_('Use Keymap'), self.keyshow)) self['config'].list = self.list self['config'].setList(self.list) return def selectionChanged(self): self['status'].setText(self['config'].getCurrent()[0]) def changedEntry(self): for x in self.onChangedEntry: x() self.selectionChanged() def getCurrentEntry(self): return self['config'].getCurrent()[0] def getCurrentValue(self): return str(self['config'].getCurrent()[1].getText()) def getCurrentDescription(self): return self['config'].getCurrent() and len(self['config'].getCurrent()) > 2 and self['config'].getCurrent()[2] or '' def createSummary(self): from Screens.Setup import SetupSummary return SetupSummary def saveAll(self): config.usage.keymap.setValue(eEnv.resolve('${datadir}/enigma2/' + self.keyshow.getValue())) config.usage.keymap.save() configfile.save() if self.actkeymap != self.keyshow.getValue(): self.changedFinished() def keySave(self): self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self['config'].list: x[1].cancel() self.close() def keyCancel(self): if self['config'].isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _('Really close without saving settings?')) else: self.close() def getKeymap(self, file): return file[file.rfind('/') + 1:] def changedFinished(self): self.session.openWithCallback(self.ExecuteRestart, MessageBox, _('Keymap changed, you need to restart the GUI') + '\n' + _('Do you want to restart now?'), MessageBox.TYPE_YESNO) self.close() def ExecuteRestart(self, result): if result: quitMainloop(3) else: self.close()
class PositionerSetup(Screen): skin = """ <screen position="100,100" size="560,400" title="Positioner setup..." > <widget name="list" position="100,0" size="350,155" /> <widget name="red" position="0,155" size="140,80" backgroundColor="red" halign="center" valign="center" font="Regular;21" /> <widget name="green" position="140,155" size="140,80" backgroundColor="green" halign="center" valign="center" font="Regular;21" /> <widget name="yellow" position="280,155" size="140,80" backgroundColor="yellow" halign="center" valign="center" font="Regular;21" /> <widget name="blue" position="420,155" size="140,80" backgroundColor="blue" halign="center" valign="center" font="Regular;21" /> <widget name="snr_db" position="60,245" size="150,22" halign="center" valign="center" font="Regular;21" /> <eLabel text="SNR:" position="0,270" size="60,22" font="Regular;21" /> <eLabel text="BER:" position="0,295" size="60,22" font="Regular;21" /> <eLabel text="Lock:" position="0,320" size="60,22" font="Regular;21" /> <widget name="snr_percentage" position="220,270" size="60,22" font="Regular;21" /> <widget name="ber_value" position="220,295" size="60,22" font="Regular;21" /> <widget name="lock_state" position="60,320" size="150,22" font="Regular;21" /> <widget name="snr_bar" position="60,270" size="150,22" /> <widget name="ber_bar" position="60,295" size="150,22" /> <eLabel text="Frequency:" position="300,245" size="120,22" font="Regular;21" /> <eLabel text="Symbolrate:" position="300,270" size="120,22" font="Regular;21" /> <eLabel text="FEC:" position="300,295" size="120,22" font="Regular;21" /> <widget name="frequency_value" position="420,245" size="120,22" font="Regular;21" /> <widget name="symbolrate_value" position="420,270" size="120,22" font="Regular;21" /> <widget name="fec_value" position="420,295" size="120,22" font="Regular;21" /> </screen>""" def __init__(self, session, feid): self.skin = PositionerSetup.skin Screen.__init__(self, session) Screen.setTitle(self, _("Positioner Setup")) self.feid = feid self.oldref = None 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 self.frontendStatus = {} self.diseqc = Diseqc(self.frontend) self.tuner = Tuner( self.frontend, True ) #True means we dont like that the normal sec stuff sends commands to the rotor! 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.createConfig() self.isMoving = False self.stopOnLock = False self.red = Label("") self["red"] = self.red self.green = Label("") self["green"] = self.green self.yellow = Label("") self["yellow"] = self.yellow self.blue = Label("") self["blue"] = self.blue self.list = [] self["list"] = ConfigList(self.list) self.createSetup() 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["actions"] = ActionMap( ["DirectionActions", "OkCancelActions", "ColorActions"], { "ok": self.go, "cancel": self.keyCancel, "up": self.up, "down": self.down, "left": self.left, "right": self.right, "red": self.redKey, "green": self.greenKey, "yellow": self.yellowKey, "blue": self.blueKey, }, -1) self.updateColors("tune") self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) self.statusTimer.start(50, True) self.onClose.append(self.__onClose) def __onClose(self): 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 createConfig(self): self.positioner_tune = ConfigNothing() self.positioner_move = ConfigNothing() self.positioner_finemove = ConfigNothing() self.positioner_limits = ConfigNothing() self.positioner_goto0 = ConfigNothing() storepos = [] for x in range(1, 255): storepos.append(str(x)) self.positioner_storage = ConfigSelection(choices=storepos) def createSetup(self): self.list.append((_("Tune"), self.positioner_tune, "tune")) self.list.append( (_("Positioner movement"), self.positioner_move, "move")) self.list.append((_("Positioner fine movement"), self.positioner_finemove, "finemove")) self.list.append((_("Set limits"), self.positioner_limits, "limits")) self.list.append( (_("Positioner storage"), self.positioner_storage, "storage")) self.list.append((_("Goto 0"), self.positioner_goto0, "goto0")) self["list"].l.setList(self.list) def go(self): pass def getCurrentConfigPath(self): return self["list"].getCurrent()[2] def up(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveUp) self.updateColors(self.getCurrentConfigPath()) def down(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveDown) self.updateColors(self.getCurrentConfigPath()) def left(self): self["list"].handleKey(KEY_LEFT) def right(self): self["list"].handleKey(KEY_RIGHT) def updateColors(self, entry): if entry == "tune": self.red.setText(_("Tune")) self.green.setText("") self.yellow.setText("") self.blue.setText("") 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")) self.blue.setText("") elif entry == "goto0": self.red.setText(_("Goto 0")) self.green.setText("") self.yellow.setText("") self.blue.setText("") else: self.red.setText("") self.green.setText("") self.yellow.setText("") self.blue.setText("") def redKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.diseqccommand("moveWest", 0) self.isMoving = True self.updateColors("move") elif entry == "limits": self.diseqccommand("limitOff") 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.session.openWithCallback(self.tune, TunerScreen, self.feid, fe_data) elif entry == "goto0": print "move to position 0" self.diseqccommand("moveTo", 0) def greenKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.isMoving = True self.stopOnLock = True self.diseqccommand("moveWest", 0) self.updateColors("move") elif entry == "finemove": print "stepping west" self.diseqccommand("moveWest", 0xFF) # one step elif entry == "storage": print "store at position", int(self.positioner_storage.getValue()) self.diseqccommand("store", int(self.positioner_storage.getValue())) elif entry == "limits": self.diseqccommand("limitWest") def yellowKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.isMoving = True self.stopOnLock = True self.diseqccommand("moveEast", 0) self.updateColors("move") elif entry == "finemove": print "stepping east" self.diseqccommand("moveEast", 0xFF) # one step elif entry == "storage": print "move to position", int(self.positioner_storage.getValue()) self.diseqccommand("moveTo", int(self.positioner_storage.getValue())) elif entry == "limits": self.diseqccommand("limitEast") def blueKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.diseqccommand("moveEast", 0) self.isMoving = True self.updateColors("move") print "moving east" elif entry == "limits": self.diseqccommand("limitOn") def diseqccommand(self, cmd, param=0): self.diseqc.command(cmd, param) self.tuner.retune() def updateStatus(self): 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() 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"))) if self.frontendStatus.get( "tuner_locked", 0) == 1 and self.isMoving and self.stopOnLock: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False self.updateColors(self.getCurrentConfigPath()) self.statusTimer.start(50, True) def tune(self, transponder): if transponder is not None: self.tuner.tune(transponder)
class RemoteControlType(Screen, ConfigListScreen): if getBrandOEM() in ('broadmedia','octagon','odin','protek','ultramini','ultramini') or getBoxType() in ('et7x00','et8500'): rcList = [ ("0", _("Default")), ("3", _("MaraM9")), ("4", _("DMM normal")), ("5", _("et9000/et9100")), ("6", _("DMM advanced")), ("7", _("et5000/6000")), ("8", _("VU+")), ("9", _("et8000/et10000")), ("11", _("et9200/9500/6500")), ("13", _("et4000")), ("14", _("XP1000")), ("16", _("HD11/HD51/HD1100/HD1200/HD1265/HD1500/HD500C/HD530C/et7x00/et8500")), ("17", _("XP3000")), ("18", _("F1/F3/F4/F4-TURBO/TRIPLEX")), ("19", _("HD2400")), ("20", _("Zgemma Star S/2S/H1/H2")), ("21", _("Zgemma H.S/H.2S/H.2H/H5")), ("500", _("WWIO_BRE2ZE_TC")), ("501", _("OCTAGON_SFXXX8")), ("502", _("GIGABLUE Black")), ("503", _("MIRACLEBOX_TWINPLUS")), ("504", _("E3HD/XPEEDLX ")), ("505", _("ODIN_M7")) ] defaultRcList = [ ("et4000", 13), ("et5000", 7), ("et6000", 7), ("et6500", 11), ("et7x00",16), ("et7000mini",16), ("et8000", 9), ("et8500",16), ("et9000", 5), ("et9100", 5), ("et9200", 11), ("et9500", 11), ("et10000", 9), ("formuler1",18), ("formuler3",18), ("formuler4",18), ("formuler4turbo",18), ("hd11",16), ("hd51",16), ("hd1100",16), ("hd1200",16), ("hd1265",16), ("hd500c",16), ("hd530c",16), ("hd2400",19), ("triplex",18), ("xp1000", 14), ("xp3000", 17), ("sh1", 20), ("h3", 21), ("h5", 21), ("bre2ze_tc", 500), ("sf4008", 501), ("g100", 501), ("sf4018", 501), ("gbquadplus", 502), ("g300", 503), ("e3hd", 504), ("et7000mini", 504), ("xpeedc.", 504), ("odinm7", 505) ] else: rcList = [ ("0", _("Default")), ("3", _("MaraM9")), ("4", _("DMM normal")), ("5", _("et9000/et9100")), ("6", _("DMM advanced")), ("7", _("et5000/6000")), ("8", _("VU+")), ("9", _("et8000/et10000")), ("11", _("et9200/9500/6500")), ("13", _("et4000")), ("14", _("XP1000")), ("16", _("HD11/HD51/HD1100/HD1200/HD1265/HD1500/HD500C/HD530C")), ("17", _("XP3000")), ("18", _("F1/F3/F4/F4-TURBO/TRIPLEX")), ("19", _("HD2400")), ("20", _("Zgemma Star S/2S/H1/H2")), ("21", _("Zgemma H.S/H.2S/H.2H/H5")) ] defaultRcList = [ ("et4000", 13), ("et5000", 7), ("et6000", 7), ("et6500", 11), ("et8000", 9), ("et9000", 5), ("et9100", 5), ("et9200", 11), ("et9500", 11), ("et10000", 9), ("formuler1",18), ("formuler3",18), ("formuler4",18), ("formuler4turbo",18), ("hd11",16), ("hd51",16), ("hd1100",16), ("hd1200",16), ("hd1265",16), ("hd500c",16), ("hd530c",16), ("hd2400",19), ("triplex",18), ("xp1000", 14), ("xp3000", 17), ("sh1", 20), ("h3", 21), ("h5", 21) ] def __init__(self, session): Screen.__init__(self, session) self.skinName = ["RemoteControlType", "Setup" ] self["actions"] = ActionMap(["SetupActions"], { "cancel": self.keyCancel, "save": self.keySave, }, -1) self["key_green"] = StaticText(_("Save")) self["key_red"] = StaticText(_("Cancel")) self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session) rctype = config.plugins.remotecontroltype.rctype.getValue() self.rctype = ConfigSelection(choices = self.rcList, default = str(rctype)) self.list.append(getConfigListEntry(_("Remote control type"), self.rctype)) self["config"].list = self.list self.defaultRcType = None self.getDefaultRcType() def getDefaultRcType(self): data = iRcTypeControl.getBoxType() for x in self.defaultRcList: if x[0] in data: self.defaultRcType = x[1] break def setDefaultRcType(self): iRcTypeControl.writeRcType(self.defaultRcType) def keySave(self): if config.plugins.remotecontroltype.rctype.getValue() == int(self.rctype.getValue()): self.close() else: self.setNewSetting() self.session.openWithCallback(self.keySaveCallback, MessageBox, _("Is this setting ok?"), MessageBox.TYPE_YESNO, timeout=20, default=True, timeout_default=False) def keySaveCallback(self, answer): if answer is False: self.restoreOldSetting() else: config.plugins.remotecontroltype.rctype.value = int(self.rctype.getValue()) config.plugins.remotecontroltype.save() self.close() def restoreOldSetting(self): if config.plugins.remotecontroltype.rctype.getValue() == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(config.plugins.remotecontroltype.rctype.getValue()) def setNewSetting(self): if int(self.rctype.value) == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(int(self.rctype.value)) def keyCancel(self): self.restoreOldSetting() self.close()
class FastScanScreen(ConfigListScreen, Screen): skin = """ <screen position="100,115" size="520,290" title="Fast Scan"> <widget name="config" position="10,10" size="500,250" scrollbarMode="showOnDemand" /> <widget name="introduction" position="10,265" size="500,25" font="Regular;20" halign="center" /> </screen>""" def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("Fast Scan")) self["actions"] = ActionMap( ["SetupActions", "MenuActions"], {"ok": self.keyGo, "cancel": self.keyCancel, "menu": self.closeRecursive}, -2, ) nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: if not n.isCompatible("DVB-S"): continue if n.config_mode == "nothing": continue if n.config_mode in ("loopthrough", "satposdepends"): root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.getValue())) if ( n.type == nimmanager.nim_slots[root_id].type ): # check if connected from a DVB-S to DVB-S2 Nim or vice versa continue nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices=nim_list) provider_list = [] provider_list.append((str(900), "Canal Digitaal")) provider_list.append((str(910), "TV Vlaanderen")) provider_list.append((str(920), "TéléSAT")) provider_list.append((str(930), "Mobistar NL")) provider_list.append((str(940), "Mobistar FR")) provider_list.append((str(950), "AustriaSat")) provider_list.append((str(30), "Czech Republic")) provider_list.append((str(31), "Slovak Republic")) self.scan_provider = ConfigSelection(choices=provider_list) self.scan_hd = ConfigYesNo(default=True) self.scan_keepnumbering = ConfigYesNo(default=False) self.scan_keepsettings = ConfigYesNo(default=False) self.list = [] self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) self.scanProvider = getConfigListEntry(_("Provider"), self.scan_provider) self.list.append(self.scanProvider) self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd) self.list.append(self.scanHD) self.list.append(getConfigListEntry(_("Use fastscan channel numbering"), self.scan_keepnumbering)) self.list.append(getConfigListEntry(_("Use fastscan channel names"), self.scan_keepsettings)) ConfigListScreen.__init__(self, self.list) self["config"].list = self.list self["config"].l.setList(self.list) self.finished_cb = None self["introduction"] = Label(_("Select your provider, and press OK to start the scan")) def keyGo(self): self.startScan() def startScan(self): pid = int(self.scan_provider.getValue()) if self.scan_hd.getValue() and pid >= 900 and pid < 930: pid += 1 if self.scan_nims.getValue(): self.session.open( FastScanStatus, scanTuner=int(self.scan_nims.getValue()), scanPid=pid, keepNumbers=self.scan_keepnumbering.getValue(), keepSettings=self.scan_keepsettings.getValue(), providerName=self.scan_provider.getText(), ) def keyCancel(self): self.close()
class UI3DSetupScreen(Screen, ConfigListScreen): skin = """ <screen position="center,center" size="440,300" title="UI 3D setup" > <ePixmap pixmap="skin_default/buttons/red.png" position="10,10" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/green.png" position="290,10" size="140,40" alphatest="on" /> <widget source="key_red" render="Label" position="10,10" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" transparent="1" /> <widget source="key_green" render="Label" position="290,10" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" transparent="1" /> <widget name="config" zPosition="2" position="10,70" size="410,200" scrollbarMode="showOnDemand" transparent="1" /> </screen>""" def __init__(self, session): self.skin = UI3DSetupScreen.skin Screen.__init__(self, session) from Components.ActionMap import ActionMap from Components.Button import Button self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self["actions"] = ActionMap(["SetupActions", "ColorActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "green": self.keyGo, "red": self.keyCancel, }, -2) self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session) mode = config.plugins.UI3DSetup.mode.getValue() znorm = config.plugins.UI3DSetup.znorm.getValue() setmode = config.plugins.UI3DSetup.setmode.getValue() self.mode = ConfigSelection(choices = modelist, default = mode) self.znorm = ConfigSlider(default = znorm + 50, increment = 1, limits = (0, 100)) self.setmode = ConfigSelection(choices = setmodelist, default = setmode) self.list.append(getConfigListEntry(_("Setup mode"), self.setmode)) self.list.append(getConfigListEntry(_("3d mode"), self.mode)) self.list.append(getConfigListEntry(_("Depth"), self.znorm)) self["config"].list = self.list self["config"].l.setList(self.list) def keyLeft(self): ConfigListScreen.keyLeft(self) self.setPreviewSettings() def keyRight(self): ConfigListScreen.keyRight(self) self.setPreviewSettings() def setPreviewSettings(self): applySettings(self.mode.getValue(), self.znorm.getValue() - 50, self.setmode.getValue()) def keyGo(self): config.plugins.UI3DSetup.mode.setValue(self.mode.getValue()) config.plugins.UI3DSetup.znorm.setValue(self.znorm.getValue() - 50) config.plugins.UI3DSetup.setmode.setValue(self.setmode.getValue()) config.plugins.UI3DSetup.save() self.close() def keyCancel(self): setConfiguredSettings() self.close()
class TranscodingSetup(ConfigListScreen, Screen): skin = """ <screen position="center,center" size="500,114" title="TranscodingSetup"> <eLabel position="0,0" size="500,22" font="Regular;20" text="Default values for trancoding" /> <widget name="config" position="4,26" font="Regular;20" size="492,60" /> <ePixmap pixmap="skin_default/buttons/red.png" position="0,76" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/green.png" position="150,76" size="140,40" alphatest="on" /> <widget source="key_red" render="Label" position="0,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" foregroundColor="#ffffff" transparent="1"/> <widget source="key_green" render="Label" position="150,76" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" foregroundColor="#ffffff" transparent="1"/> </screen> """ def KeyNone(self): None def callbackNone(self, *retval): None def __init__(self, session): bitrate_choices = [( 50, "50 kbps" ), ( 100, "100 kbps" ), ( 200, "200 kbps" ), ( 500, "500 kbps" ), ( 1000, "1 Mbps" ), ( 2000, "2 Mbps" )] size_choices = [ "480p", "576p", "720p" ] current_bitrate_value = "" current_size = "" Screen.__init__(self, session) config_list = [] ConfigListScreen.__init__(self, config_list) self.bitrate = ConfigSelection(choices = bitrate_choices) self.size = ConfigSelection(choices = size_choices) config_list.append(getConfigListEntry(_("Bitrate"), self.bitrate)); config_list.append(getConfigListEntry(_("Video size"), self.size)); self["config"].list = config_list rawcontent = [] with open("/etc/enigma2/streamproxy.conf", "r") as f: rawcontent = f.readlines() rawcontent = [x.translate(None, ' \n\r')for x in rawcontent] f.close() self.content = [] for line in rawcontent: if not line.startswith('#') and not line.startswith(';'): tokens = line.split('=') if(tokens[0] == "bitrate"): for tuple in bitrate_choices: if int(tokens[1]) <= int(tuple[0]): self.bitrate.setValue(tuple[0]) break if(tokens[0] == "size"): self.size.setValue(tokens[1]) self.content += [ tokens ] self["actions"] = ActionMap(["OkCancelActions", "ShortcutActions", "ColorActions" ], { "red": self.keyCancel, "green": self.keyGo, "ok": self.keyGo, "cancel": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Quit")) self["key_green"] = StaticText(_("Set")) def keyLeft(self): ConfigListScreen.keyLeft(self) def keyRight(self): ConfigListScreen.keyRight(self) def keyCancel(self): self.close() def keyGo(self): for token in self.content: if(token[0] == "bitrate"): token[1] = self.bitrate.getValue() if(token[0] == "size"): token[1] = self.size.getValue() with open("/etc/enigma2/streamproxy.conf", "w") as f: for token in self.content: f.write("%s = %s\n" % (token[0], token[1])) f.close() self.close()
class RecordingSettings(Screen,ConfigListScreen): skin = """ <screen name="RecordPathsSettings" position="160,150" size="450,200" title="Recording paths"> <ePixmap pixmap="skin_default/buttons/red.png" position="10,0" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/green.png" position="300,0" size="140,40" alphatest="on" /> <widget source="key_red" render="Label" position="10,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" /> <widget source="key_green" render="Label" position="300,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" /> <widget name="config" position="10,44" size="430,146" /> </screen>""" def removeNotifier(self): config.usage.setup_level.notifiers.remove(self.levelChanged) def levelChanged(self, configElement): list = [] self.refill(list) self["config"].setList(list) def refill(self, list): xmldata = self.setupdom.getroot() for x in xmldata.findall("setup"): if x.get("key") != self.setup: continue self.addItems(list, x); self.setup_title = x.get("title", "").encode("UTF-8") self.seperation = int(x.get('separation', '0')) def __init__(self, session): from Components.Sources.StaticText import StaticText Screen.__init__(self, session) setupfile = file(eEnv.resolve('${datadir}/enigma2/setup.xml'), 'r') self.setupdom = xml.etree.cElementTree.parse(setupfile) setupfile.close() self.skinName = "Setup" self['footnote'] = Label() self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self["description"] = Label(_("")) self.onChangedEntry = [ ] self.setup = "recording" list = [] ConfigListScreen.__init__(self, list, session = session, on_change = self.changedEntry) self.createSetup() self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "green": self.keySave, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, "menu": self.closeRecursive, }, -2) self.onLayoutFinish.append(self.layoutFinished) def checkReadWriteDir(self, configele): # print "checkReadWrite: ", configele.getValue() if configele.getValue() in [x[0] for x in self.styles] or fileExists(configele.value, "w"): configele.last_value = configele.getValue() return True else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead.")%dir, type = MessageBox.TYPE_ERROR ) return False def createSetup(self): self.styles = [ ("<default>", _("<Default movie location>")), ("<current>", _("<Current movielist location>")), ("<timer>", _("<Last timer location>")) ] styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.getValue() default = config.usage.default_path.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) # print "DefaultPath: ", default, tmp self.default_dirname = ConfigSelection(default = default, choices = tmp) tmp = config.movielist.videodirs.getValue() default = config.usage.timer_path.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) # print "TimerPath: ", default, tmp self.timer_dirname = ConfigSelection(default = default, choices = self.styles+tmp) tmp = config.movielist.videodirs.getValue() default = config.usage.instantrec_path.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) # print "InstantrecPath: ", default, tmp self.instantrec_dirname = ConfigSelection(default = default, choices = self.styles+tmp) self.default_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.timer_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.instantrec_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) list = [] if config.usage.setup_level.index >= 2: self.default_entry = getConfigListEntry(_("Default movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer record location"), self.timer_dirname, _("Set the default location for your timers. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry(_("Instant record location"), self.instantrec_dirname, _("Set the default location for your instant recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.default_entry) self.refill(list) self["config"].setList(list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) # for summary: def changedEntry(self): self.item = self["config"].getCurrent() if self["config"].getCurrent()[0] == _("Default movie location") or self["config"].getCurrent()[0] == _("Timer record location") or self["config"].getCurrent()[0] == _("Instant record location") or self["config"].getCurrent()[0] == _("Movie location"): self.checkReadWriteDir(self["config"].getCurrent()[1]) for x in self.onChangedEntry: x() try: if isinstance(self["config"].getCurrent()[1], ConfigYesNo) or isinstance(self["config"].getCurrent()[1], ConfigSelection): self.createSetup() except: pass def getCurrentEntry(self): return self["config"].getCurrent() and self["config"].getCurrent()[0] or "" def getCurrentValue(self): return self["config"].getCurrent() and str(self["config"].getCurrent()[1].getText()) or "" def getCurrentDescription(self): return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or "" def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.getValue() self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.getValue() if config.usage.setup_level.index >= 2: txt = _("Default movie location") else: txt = _("Movie location") if currentry == self.default_entry: self.entrydirname = self.default_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, txt, preferredPath(self.default_dirname.getValue()) ) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("New timers location"), preferredPath(self.timer_dirname.getValue()) ) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Instant recordings location"), preferredPath(self.instantrec_dirname.getValue()) ) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.getValue() != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.getValue() default = self.default_dirname.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.getValue() default = self.timer_dirname.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.timer_dirname.setChoices(self.styles+tmp, default=default) tmp = config.movielist.videodirs.getValue() default = self.instantrec_dirname.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.instantrec_dirname.setChoices(self.styles+tmp, default=default) self.entrydirname.value = res if self.entrydirname.last_value != res: self.checkReadWriteDir(self.entrydirname) def saveAll(self): currentry = self["config"].getCurrent() config.usage.default_path.value = self.default_dirname.getValue() config.usage.timer_path.value = self.timer_dirname.getValue() config.usage.instantrec_path.value = self.instantrec_dirname.getValue() config.usage.default_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() for x in self["config"].list: x[1].save() configfile.save() # keySave and keyCancel are just provided in case you need them. # you have to call them by yourself. def keySave(self): self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?")) else: self.close() def createSummary(self): return SetupSummary def addItems(self, list, parentNode): for x in parentNode: if not x.tag: continue if x.tag == 'item': item_level = int(x.get("level", 0)) if not self.levelChanged in config.usage.setup_level.notifiers: config.usage.setup_level.notifiers.append(self.levelChanged) self.onClose.append(self.removeNotifier) if item_level > config.usage.setup_level.index: continue requires = x.get("requires") if requires and requires.startswith('config.'): item = eval(requires or ""); if item.getValue() and not item.getValue() == "0": SystemInfo[requires] = True else: SystemInfo[requires] = False if requires and not SystemInfo.get(requires, False): continue; item_text = _(x.get("text", "??").encode("UTF-8")) item_description = _(x.get("description", " ").encode("UTF-8")) b = eval(x.text or ""); if b == "": continue #add to configlist item = b # the first b is the item itself, ignored by the configList. # the second one is converted to string. if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class RemoteControlType(Screen, ConfigListScreen): if getBrandOEM() in ('broadmedia', 'octagon', 'odin', 'protek', 'ultramini', 'ultramini') or getBoxType() in ('et7x00', 'et8500'): rcList = [ ("0", _("Default")), ("3", _("MaraM9")), ("4", _("DMM normal")), ("5", _("et9000/et9100")), ("6", _("DMM advanced")), ("7", _("et5000/6000")), ("8", _("VU+")), ("9", _("et8000/et10000")), ("11", _("et9200/9500/6500")), ("13", _("et4000")), ("14", _("XP1000")), ("16", _("HD11/HD51/HD1100/HD1200/HD1265/HD1500/HD500C/HD530C/et7x00/et8500" )), ("17", _("XP3000")), ("18", _("F1/F3/F4/F4-TURBO/TRIPLEX")), ("19", _("HD2400")), ("20", _("Zgemma Star S/2S/H1/H2")), ("21", _("Zgemma H.S/H.2S/H.2H/H5")), ("500", _("WWIO_BRE2ZE_TC")), ("501", _("OCTAGON_SFXXX8")), ("502", _("GIGABLUE Black")), ("503", _("MIRACLEBOX_TWINPLUS")), ("504", _("E3HD/XPEEDLX ")), ("505", _("ODIN_M7")) ] defaultRcList = [("et4000", 13), ("et5000", 7), ("et6000", 7), ("et6500", 11), ("et7x00", 16), ("et7000mini", 16), ("et8000", 9), ("et8500", 16), ("et9000", 5), ("et9100", 5), ("et9200", 11), ("et9500", 11), ("et10000", 9), ("formuler1", 18), ("formuler3", 18), ("formuler4", 18), ("formuler4turbo", 18), ("hd11", 16), ("hd51", 16), ("hd1100", 16), ("hd1200", 16), ("hd1265", 16), ("hd500c", 16), ("hd530c", 16), ("hd2400", 19), ("triplex", 18), ("xp1000", 14), ("xp3000", 17), ("sh1", 20), ("h3", 21), ("h5", 21), ("bre2ze_tc", 500), ("sf4008", 501), ("g100", 501), ("sf4018", 501), ("gbquadplus", 502), ("g300", 503), ("e3hd", 504), ("et7000mini", 504), ("xpeedc.", 504), ("odinm7", 505)] else: rcList = [("0", _("Default")), ("3", _("MaraM9")), ("4", _("DMM normal")), ("5", _("et9000/et9100")), ("6", _("DMM advanced")), ("7", _("et5000/6000")), ("8", _("VU+")), ("9", _("et8000/et10000")), ("11", _("et9200/9500/6500")), ("13", _("et4000")), ("14", _("XP1000")), ("16", _("HD11/HD51/HD1100/HD1200/HD1265/HD1500/HD500C/HD530C")), ("17", _("XP3000")), ("18", _("F1/F3/F4/F4-TURBO/TRIPLEX")), ("19", _("HD2400")), ("20", _("Zgemma Star S/2S/H1/H2")), ("21", _("Zgemma H.S/H.2S/H.2H/H5"))] defaultRcList = [("et4000", 13), ("et5000", 7), ("et6000", 7), ("et6500", 11), ("et8000", 9), ("et9000", 5), ("et9100", 5), ("et9200", 11), ("et9500", 11), ("et10000", 9), ("formuler1", 18), ("formuler3", 18), ("formuler4", 18), ("formuler4turbo", 18), ("hd11", 16), ("hd51", 16), ("hd1100", 16), ("hd1200", 16), ("hd1265", 16), ("hd500c", 16), ("hd530c", 16), ("hd2400", 19), ("triplex", 18), ("xp1000", 14), ("xp3000", 17), ("sh1", 20), ("h3", 21), ("h5", 21)] def __init__(self, session): Screen.__init__(self, session) self.skinName = ["RemoteControlType", "Setup"] self["actions"] = ActionMap(["SetupActions"], { "cancel": self.keyCancel, "save": self.keySave, }, -1) self["key_green"] = StaticText(_("Save")) self["key_red"] = StaticText(_("Cancel")) self.list = [] ConfigListScreen.__init__(self, self.list, session=self.session) rctype = config.plugins.remotecontroltype.rctype.getValue() self.rctype = ConfigSelection(choices=self.rcList, default=str(rctype)) self.list.append( getConfigListEntry(_("Remote control type"), self.rctype)) self["config"].list = self.list self.defaultRcType = None self.getDefaultRcType() def getDefaultRcType(self): data = iRcTypeControl.getBoxType() for x in self.defaultRcList: if x[0] in data: self.defaultRcType = x[1] break def setDefaultRcType(self): iRcTypeControl.writeRcType(self.defaultRcType) def keySave(self): if config.plugins.remotecontroltype.rctype.getValue() == int( self.rctype.getValue()): self.close() else: self.setNewSetting() self.session.openWithCallback(self.keySaveCallback, MessageBox, _("Is this setting ok?"), MessageBox.TYPE_YESNO, timeout=20, default=True, timeout_default=False) def keySaveCallback(self, answer): if answer is False: self.restoreOldSetting() else: config.plugins.remotecontroltype.rctype.value = int( self.rctype.getValue()) config.plugins.remotecontroltype.save() self.close() def restoreOldSetting(self): if config.plugins.remotecontroltype.rctype.getValue() == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType( config.plugins.remotecontroltype.rctype.getValue()) def setNewSetting(self): if int(self.rctype.value) == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(int(self.rctype.value)) def keyCancel(self): self.restoreOldSetting() self.close()
class PositionerSetup(Screen): skin = """ <screen position="100,100" size="560,400" title="Positioner setup..." > <widget name="list" position="100,0" size="350,155" /> <widget name="red" position="0,155" size="140,80" backgroundColor="red" halign="center" valign="center" font="Regular;21" /> <widget name="green" position="140,155" size="140,80" backgroundColor="green" halign="center" valign="center" font="Regular;21" /> <widget name="yellow" position="280,155" size="140,80" backgroundColor="yellow" halign="center" valign="center" font="Regular;21" /> <widget name="blue" position="420,155" size="140,80" backgroundColor="blue" halign="center" valign="center" font="Regular;21" /> <widget name="snr_db" position="60,245" size="150,22" halign="center" valign="center" font="Regular;21" /> <eLabel text="SNR:" position="0,270" size="60,22" font="Regular;21" /> <eLabel text="BER:" position="0,295" size="60,22" font="Regular;21" /> <eLabel text="Lock:" position="0,320" size="60,22" font="Regular;21" /> <widget name="snr_percentage" position="220,270" size="60,22" font="Regular;21" /> <widget name="ber_value" position="220,295" size="60,22" font="Regular;21" /> <widget name="lock_state" position="60,320" size="150,22" font="Regular;21" /> <widget name="snr_bar" position="60,270" size="150,22" /> <widget name="ber_bar" position="60,295" size="150,22" /> <eLabel text="Frequency:" position="300,245" size="120,22" font="Regular;21" /> <eLabel text="Symbolrate:" position="300,270" size="120,22" font="Regular;21" /> <eLabel text="FEC:" position="300,295" size="120,22" font="Regular;21" /> <widget name="frequency_value" position="420,245" size="120,22" font="Regular;21" /> <widget name="symbolrate_value" position="420,270" size="120,22" font="Regular;21" /> <widget name="fec_value" position="420,295" size="120,22" font="Regular;21" /> </screen>""" def __init__(self, session, feid): self.skin = PositionerSetup.skin Screen.__init__(self, session) Screen.setTitle(self, _("Positioner Setup")) self.feid = feid self.oldref = None 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 self.frontendStatus = { } self.diseqc = Diseqc(self.frontend) self.tuner = Tuner(self.frontend, True) #True means we dont like that the normal sec stuff sends commands to the rotor! 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.createConfig() self.isMoving = False self.stopOnLock = False self.red = Label("") self["red"] = self.red self.green = Label("") self["green"] = self.green self.yellow = Label("") self["yellow"] = self.yellow self.blue = Label("") self["blue"] = self.blue self.list = [] self["list"] = ConfigList(self.list) self.createSetup() 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["actions"] = ActionMap(["DirectionActions", "OkCancelActions", "ColorActions"], { "ok": self.go, "cancel": self.keyCancel, "up": self.up, "down": self.down, "left": self.left, "right": self.right, "red": self.redKey, "green": self.greenKey, "yellow": self.yellowKey, "blue": self.blueKey, }, -1) self.updateColors("tune") self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) self.statusTimer.start(50, True) self.onClose.append(self.__onClose) def __onClose(self): 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 createConfig(self): self.positioner_tune = ConfigNothing() self.positioner_move = ConfigNothing() self.positioner_finemove = ConfigNothing() self.positioner_limits = ConfigNothing() self.positioner_goto0 = ConfigNothing() storepos = [] for x in range(1,255): storepos.append(str(x)) self.positioner_storage = ConfigSelection(choices = storepos) def createSetup(self): self.list.append((_("Tune"), self.positioner_tune, "tune")) self.list.append((_("Positioner movement"), self.positioner_move, "move")) self.list.append((_("Positioner fine movement"), self.positioner_finemove, "finemove")) self.list.append((_("Set limits"), self.positioner_limits, "limits")) self.list.append((_("Positioner storage"), self.positioner_storage, "storage")) self.list.append((_("Goto 0"), self.positioner_goto0, "goto0")) self["list"].l.setList(self.list) def go(self): pass def getCurrentConfigPath(self): return self["list"].getCurrent()[2] def up(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveUp) self.updateColors(self.getCurrentConfigPath()) def down(self): if not self.isMoving: self["list"].instance.moveSelection(self["list"].instance.moveDown) self.updateColors(self.getCurrentConfigPath()) def left(self): self["list"].handleKey(KEY_LEFT) def right(self): self["list"].handleKey(KEY_RIGHT) def updateColors(self, entry): if entry == "tune": self.red.setText(_("Tune")) self.green.setText("") self.yellow.setText("") self.blue.setText("") 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")) self.blue.setText("") elif entry == "goto0": self.red.setText(_("Goto 0")) self.green.setText("") self.yellow.setText("") self.blue.setText("") else: self.red.setText("") self.green.setText("") self.yellow.setText("") self.blue.setText("") def redKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.diseqccommand("moveWest", 0) self.isMoving = True self.updateColors("move") elif entry == "limits": self.diseqccommand("limitOff") 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.session.openWithCallback(self.tune, TunerScreen, self.feid, fe_data) elif entry == "goto0": print "move to position 0" self.diseqccommand("moveTo", 0) def greenKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.isMoving = True self.stopOnLock = True self.diseqccommand("moveWest", 0) self.updateColors("move") elif entry == "finemove": print "stepping west" self.diseqccommand("moveWest", 0xFF) # one step elif entry == "storage": print "store at position", int(self.positioner_storage.getValue()) self.diseqccommand("store", int(self.positioner_storage.getValue())) elif entry == "limits": self.diseqccommand("limitWest") def yellowKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.isMoving = True self.stopOnLock = True self.diseqccommand("moveEast", 0) self.updateColors("move") elif entry == "finemove": print "stepping east" self.diseqccommand("moveEast", 0xFF) # one step elif entry == "storage": print "move to position", int(self.positioner_storage.getValue()) self.diseqccommand("moveTo", int(self.positioner_storage.getValue())) elif entry == "limits": self.diseqccommand("limitEast") def blueKey(self): entry = self.getCurrentConfigPath() if entry == "move": if self.isMoving: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False else: self.diseqccommand("moveEast", 0) self.isMoving = True self.updateColors("move") print "moving east" elif entry == "limits": self.diseqccommand("limitOn") def diseqccommand(self, cmd, param = 0): self.diseqc.command(cmd, param) self.tuner.retune() def updateStatus(self): 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() 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"))) if self.frontendStatus.get("tuner_locked", 0) == 1 and self.isMoving and self.stopOnLock: self.diseqccommand("stop") self.isMoving = False self.stopOnLock = False self.updateColors(self.getCurrentConfigPath()) self.statusTimer.start(50, True) def tune(self, transponder): if transponder is not None: self.tuner.tune(transponder)
class KeymapSel(ConfigListScreen, Screen): def __init__(self, session): Screen.__init__(self, session) self.session = session self.skinName = ["SetupInfo", "Setup" ] Screen.setTitle(self, _("Keymap Selection") + "...") self.setup_title = _("Keymap Selection") + "..." self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["status"] = StaticText() self['footnote'] = Label("") self["description"] = Label("") self["labelInfo"] = Label(_("Copy your keymap to\n/usr/share/enigma2/keymap.usr")) usrkey = eEnv.resolve("${datadir}/enigma2/keymap.usr") ntrkey = eEnv.resolve("${datadir}/enigma2/keymap.ntr") u80key = eEnv.resolve("${datadir}/enigma2/keymap.u80") self.actkeymap = self.getKeymap(config.usage.keymap.getValue()) keySel = [ ('keymap.xml',_("Default (keymap.xml)"))] if os.path.isfile(usrkey): keySel.append(('keymap.usr',_("User (keymap.usr)"))) if os.path.isfile(ntrkey): keySel.append(('keymap.ntr',_("Neutrino (keymap.ntr)"))) if os.path.isfile(u80key): keySel.append(('keymap.u80',_("UP80 (keymap.u80)"))) if self.actkeymap == usrkey and not os.path.isfile(usrkey): setDefaultKeymap() if self.actkeymap == ntrkey and not os.path.isfile(ntrkey): setDefaultKeymap() if self.actkeymap == u80key and not os.path.isfile(u80key): setDefaultKeymap() self.keyshow = ConfigSelection(keySel) self.keyshow.setValue(self.actkeymap) self.onChangedEntry = [ ] self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry) self.createSetup() self["actions"] = ActionMap(["SetupActions", 'ColorActions'], { "ok": self.keySave, "cancel": self.keyCancel, "red": self.keyCancel, "green": self.keySave, "menu": self.keyCancel, }, -2) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("OK")) if not self.selectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.selectionChanged) self.selectionChanged() def createSetup(self): self.editListEntry = None self.list = [] self.list.append(getConfigListEntry(_("Use Keymap"), self.keyshow)) self["config"].list = self.list self["config"].setList(self.list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def selectionChanged(self): self["status"].setText(self["config"].getCurrent()[0]) def changedEntry(self): for x in self.onChangedEntry: x() self.selectionChanged() def getCurrentEntry(self): return self["config"].getCurrent()[0] def getCurrentValue(self): return str(self["config"].getCurrent()[1].getText()) def getCurrentDescription(self): return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or "" def createSummary(self): from Screens.Setup import SetupSummary return SetupSummary def saveAll(self): config.usage.keymap.setValue(eEnv.resolve("${datadir}/enigma2/" + self.keyshow.getValue())) config.usage.keymap.save() configfile.save() if self.actkeymap != self.keyshow.getValue(): self.changedFinished() def keySave(self): self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?")) else: self.close() def getKeymap(self, file): return file[file.rfind('/') +1:] def changedFinished(self): self.session.openWithCallback(self.ExecuteRestart, MessageBox, _("Keymap changed, you need to restart the GUI") +"\n"+_("Do you want to restart now?"), MessageBox.TYPE_YESNO) self.close() def ExecuteRestart(self, result): if result: quitMainloop(3) else: self.close()
class TimerEntry(Screen, ConfigListScreen): def __init__(self, session, timer): Screen.__init__(self, session) self.setup_title = _("Timer entry") self.timer = timer self.entryDate = None self.entryService = None self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["description"] = Label("") self["oktext"] = Label(_("OK")) self["canceltext"] = Label(_("Cancel")) self["ok"] = Pixmap() self["cancel"] = Pixmap() self["key_yellow"] = Label(_("Timer type")) self.createConfig() self["actions"] = NumberActionMap(["SetupActions", "GlobalActions", "PiPSetupActions", "ColorActions"], { "ok": self.keySelect, "save": self.keyGo, "cancel": self.keyCancel, "volumeUp": self.incrementStart, "volumeDown": self.decrementStart, "size+": self.incrementEnd, "size-": self.decrementEnd, "yellow": self.changeTimerType }, -2) self.onChangedEntry = [ ] self.list = [] ConfigListScreen.__init__(self, self.list, session = session) self.createSetup("config") self.onLayoutFinish.append(self.layoutFinished) if not self.selectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.selectionChanged) self.selectionChanged() def createConfig(self): justplay = self.timer.justplay always_zap = self.timer.always_zap afterevent = { AFTEREVENT.NONE: "nothing", AFTEREVENT.DEEPSTANDBY: "deepstandby", AFTEREVENT.STANDBY: "standby", AFTEREVENT.AUTO: "auto" }[self.timer.afterEvent] if self.timer.record_ecm and self.timer.descramble: recordingtype = "descrambled+ecm" elif self.timer.record_ecm: recordingtype = "scrambled+ecm" elif self.timer.descramble: recordingtype = "normal" weekday_table = ("mon", "tue", "wed", "thu", "fri", "sat", "sun") # calculate default values day = [] weekday = 0 for x in (0, 1, 2, 3, 4, 5, 6): day.append(0) if self.timer.repeated: # repeated type = "repeated" if self.timer.repeated == 31: # Mon-Fri repeated = "weekdays" elif self.timer.repeated == 127: # daily repeated = "daily" else: flags = self.timer.repeated repeated = "user" count = 0 for x in (0, 1, 2, 3, 4, 5, 6): if flags == 1: # weekly # print "Set to weekday " + str(x) weekday = x if flags & 1 == 1: # set user defined flags day[x] = 1 count += 1 else: day[x] = 0 flags >>= 1 if count == 1: repeated = "weekly" else: # once type = "once" repeated = None weekday = int(strftime("%u", localtime(self.timer.begin))) - 1 day[weekday] = 1 self.timerentry_justplay = ConfigSelection(choices = [ ("zap", _("zap")), ("record", _("record")), ("zap+record", _("zap and record"))], default = {0: "record", 1: "zap", 2: "zap+record"}[justplay + 2*always_zap]) if SystemInfo["DeepstandbySupport"]: shutdownString = _("go to deep standby") else: shutdownString = _("shut down") self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")), ("standby", _("go to standby")), ("deepstandby", shutdownString), ("auto", _("auto"))], default = afterevent) self.timerentry_recordingtype = ConfigSelection(choices = [("normal", _("normal")), ("descrambled+ecm", _("descramble and record ecm")), ("scrambled+ecm", _("don't descramble, record ecm"))], default = recordingtype) self.timerentry_type = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = type) self.timerentry_name = ConfigText(default = self.timer.name.replace('\xc2\x86', '').replace('\xc2\x87', '').encode("utf-8"), visible_width = 50, fixed_size = False) self.timerentry_description = ConfigText(default = self.timer.description, visible_width = 50, fixed_size = False) self.timerentry_tags = self.timer.tags[:] self.timerentry_tagsset = ConfigSelection(choices = [not self.timerentry_tags and "None" or " ".join(self.timerentry_tags)]) self.timerentry_repeated = ConfigSelection(default = repeated, choices = [("weekly", _("weekly")), ("daily", _("daily")), ("weekdays", _("Mon-Fri")), ("user", _("user defined"))]) self.timerentry_date = ConfigDateTime(default = self.timer.begin, formatstring = _("%d.%B %Y"), increment = 86400) self.timerentry_starttime = ConfigClock(default = self.timer.begin) self.timerentry_endtime = ConfigClock(default = self.timer.end) self.timerentry_showendtime = ConfigSelection(default = ((self.timer.end - self.timer.begin) > 4), choices = [(True, _("yes")), (False, _("no"))]) default = self.timer.dirname or defaultMoviePath() tmp = config.movielist.videodirs.getValue() if default not in tmp: tmp.append(default) self.timerentry_dirname = ConfigSelection(default = default, choices = tmp) self.timerentry_repeatedbegindate = ConfigDateTime(default = self.timer.repeatedbegindate, formatstring = _("%d.%B %Y"), increment = 86400) self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))]) self.timerentry_day = ConfigSubList() for x in (0, 1, 2, 3, 4, 5, 6): self.timerentry_day.append(ConfigYesNo(default = day[x])) # FIXME some service-chooser needed here servicename = "N/A" try: # no current service available? servicename = str(self.timer.service_ref.getServiceName()) except: pass self.timerentry_service_ref = self.timer.service_ref self.timerentry_service = ConfigSelection([servicename]) def createSetup(self, widget): self.list = [] self.list.append(getConfigListEntry(_("Name"), self.timerentry_name, _("Set the name the recording will get."))) self.list.append(getConfigListEntry(_("Description"), self.timerentry_description, _("Set the description of the recording."))) self.timerJustplayEntry = getConfigListEntry(_("Timer type"), self.timerentry_justplay, _("Chose between record and ZAP.")) self.list.append(self.timerJustplayEntry) self.timerTypeEntry = getConfigListEntry(_("Repeat type"), self.timerentry_type, _("A repeating timer or just once?")) self.list.append(self.timerTypeEntry) if self.timerentry_type.getValue() == "once": self.frequencyEntry = None else: # repeated self.frequencyEntry = getConfigListEntry(_("Repeats"), self.timerentry_repeated, _("Choose between Daily, Weekly, Weekdays or user defined.")) self.list.append(self.frequencyEntry) self.repeatedbegindateEntry = getConfigListEntry(_("Starting on"), self.timerentry_repeatedbegindate, _("Set the date the timer must start.")) self.list.append(self.repeatedbegindateEntry) if self.timerentry_repeated.getValue() == "daily": pass if self.timerentry_repeated.getValue() == "weekdays": pass if self.timerentry_repeated.getValue() == "weekly": self.list.append(getConfigListEntry(_("Weekday"), self.timerentry_weekday)) if self.timerentry_repeated.getValue() == "user": self.list.append(getConfigListEntry(_("Monday"), self.timerentry_day[0])) self.list.append(getConfigListEntry(_("Tuesday"), self.timerentry_day[1])) self.list.append(getConfigListEntry(_("Wednesday"), self.timerentry_day[2])) self.list.append(getConfigListEntry(_("Thursday"), self.timerentry_day[3])) self.list.append(getConfigListEntry(_("Friday"), self.timerentry_day[4])) self.list.append(getConfigListEntry(_("Saturday"), self.timerentry_day[5])) self.list.append(getConfigListEntry(_("Sunday"), self.timerentry_day[6])) self.entryDate = getConfigListEntry(_("Date"), self.timerentry_date, _("Set the date the timer must start.")) if self.timerentry_type.getValue() == "once": self.list.append(self.entryDate) self.entryStartTime = getConfigListEntry(_("Start time"), self.timerentry_starttime, _("Set the time the timer must start.")) self.list.append(self.entryStartTime) self.entryShowEndTime = getConfigListEntry(_("Set end time"), self.timerentry_showendtime, _("Set the time the timer must stop.")) if self.timerentry_justplay.getValue() == "zap": self.list.append(self.entryShowEndTime) self.entryEndTime = getConfigListEntry(_("End time"), self.timerentry_endtime, _("Set the time the timer must stop.")) if self.timerentry_justplay.getValue() != "zap" or self.timerentry_showendtime.getValue(): self.list.append(self.entryEndTime) self.channelEntry = getConfigListEntry(_("Channel"), self.timerentry_service, _("Set the channel for this timer.")) self.list.append(self.channelEntry) self.dirname = getConfigListEntry(_("Location"), self.timerentry_dirname, _("Where should the recording be saved?")) self.tagsSet = getConfigListEntry(_("Tags"), self.timerentry_tagsset, _("Choose a tag for easy finding a recording.")) if self.timerentry_justplay.getValue() != "zap": if config.usage.setup_level.index >= 2: # expert+ self.list.append(self.dirname) if getPreferredTagEditor(): self.list.append(self.tagsSet) self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent, _("What action is required on complettion of the timer? 'Auto' lets the box return to the state it had when the timer started. 'Do nothing', 'Go to standby' and 'Go to deep standby' do ecaxtly that."))) self.list.append(getConfigListEntry(_("Recording type"), self.timerentry_recordingtype, _("Descramble & record ECM' gives the option to descramble afterwards if descrambling on recording failed. 'Don't descramble, record ECM' save a scramble recording that can be descrambled on playback. 'Normal' means descramble the recording and don't record ECM."))) self[widget].list = self.list self[widget].l.setList(self.list) def selectionChanged(self): if self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2]: self["description"].setText(self["config"].getCurrent()[2]) def layoutFinished(self): self.setTitle(_(self.setup_title)) def createSummary(self): return SetupSummary # for summary: def changedEntry(self): for x in self.onChangedEntry: x() def getCurrentEntry(self): return self["config"].getCurrent() and self["config"].getCurrent()[0] or "" def getCurrentValue(self): return self["config"].getCurrent() and str(self["config"].getCurrent()[1].getText()) or "" def newConfig(self): if self["config"].getCurrent() in (self.timerTypeEntry, self.timerJustplayEntry, self.frequencyEntry, self.entryShowEndTime): self.createSetup("config") def keyLeft(self): if self["config"].getCurrent() in (self.channelEntry, self.tagsSet): self.keySelect() else: ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): if self["config"].getCurrent() in (self.channelEntry, self.tagsSet): self.keySelect() else: ConfigListScreen.keyRight(self) self.newConfig() def keySelect(self): cur = self["config"].getCurrent() if cur == self.channelEntry: self.session.openWithCallback( self.finishedChannelSelection, ChannelSelection.SimpleChannelSelection, _("Select channel to record from") ) elif config.usage.setup_level.index >= 2 and cur == self.dirname: self.session.openWithCallback( self.pathSelected, MovieLocationBox, _("Select target folder"), self.timerentry_dirname.getValue(), minFree = 100 # We require at least 100MB free space ) elif getPreferredTagEditor() and cur == self.tagsSet: self.session.openWithCallback( self.tagEditFinished, getPreferredTagEditor(), self.timerentry_tags ) else: self.keyGo() def finishedChannelSelection(self, *args): if args: self.timerentry_service_ref = ServiceReference(args[0]) self.timerentry_service.setCurrentText(self.timerentry_service_ref.getServiceName()) self["config"].invalidate(self.channelEntry) def getTimestamp(self, date, mytime): d = localtime(date) dt = datetime(d.tm_year, d.tm_mon, d.tm_mday, mytime[0], mytime[1]) return int(mktime(dt.timetuple())) def getBeginEnd(self): date = self.timerentry_date.getValue() endtime = self.timerentry_endtime.getValue() starttime = self.timerentry_starttime.getValue() begin = self.getTimestamp(date, starttime) end = self.getTimestamp(date, endtime) # if the endtime is less than the starttime, add 1 day. if end < begin: end += 86400 # if the timer type is a Zap and no end is set, set duration to 1 second so time is shown in EPG's. if self.timerentry_justplay.getValue() == "zap": if not self.timerentry_showendtime.getValue(): end = begin + (config.recording.margin_before.getValue()*60) + 1 return begin, end def selectChannelSelector(self, *args): self.session.openWithCallback( self.finishedChannelSelectionCorrection, ChannelSelection.SimpleChannelSelection, _("Select channel to record from") ) def finishedChannelSelectionCorrection(self, *args): if args: self.finishedChannelSelection(*args) self.keyGo() def keyGo(self, result = None): if not self.timerentry_service_ref.isRecordable(): self.session.openWithCallback(self.selectChannelSelector, MessageBox, _("You didn't select a channel to record from."), MessageBox.TYPE_ERROR) return self.timer.name = self.timerentry_name.getValue() self.timer.description = self.timerentry_description.getValue() self.timer.justplay = self.timerentry_justplay.getValue() == "zap" self.timer.always_zap = self.timerentry_justplay.value == "zap+record" if self.timerentry_justplay.getValue() == "zap": if not self.timerentry_showendtime.getValue(): self.timerentry_endtime.value = self.timerentry_starttime.getValue() self.timer.resetRepeated() self.timer.afterEvent = { "nothing": AFTEREVENT.NONE, "deepstandby": AFTEREVENT.DEEPSTANDBY, "standby": AFTEREVENT.STANDBY, "auto": AFTEREVENT.AUTO }[self.timerentry_afterevent.value] self.timer.descramble = { "normal": True, "descrambled+ecm": True, "scrambled+ecm": False, }[self.timerentry_recordingtype.value] self.timer.record_ecm = { "normal": False, "descrambled+ecm": True, "scrambled+ecm": True, }[self.timerentry_recordingtype.value] self.timer.service_ref = self.timerentry_service_ref self.timer.tags = self.timerentry_tags if self.timer.dirname or self.timerentry_dirname.getValue() != defaultMoviePath(): self.timer.dirname = self.timerentry_dirname.getValue() config.movielist.last_timer_videodir.value = self.timer.dirname config.movielist.last_timer_videodir.save() if self.timerentry_type.getValue() == "once": self.timer.begin, self.timer.end = self.getBeginEnd() if self.timerentry_type.getValue() == "repeated": if self.timerentry_repeated.getValue() == "daily": for x in (0, 1, 2, 3, 4, 5, 6): self.timer.setRepeated(x) if self.timerentry_repeated.getValue() == "weekly": self.timer.setRepeated(self.timerentry_weekday.index) if self.timerentry_repeated.getValue() == "weekdays": for x in (0, 1, 2, 3, 4): self.timer.setRepeated(x) if self.timerentry_repeated.getValue() == "user": for x in (0, 1, 2, 3, 4, 5, 6): if self.timerentry_day[x].getValue(): self.timer.setRepeated(x) self.timer.repeatedbegindate = self.getTimestamp(self.timerentry_repeatedbegindate.getValue(), self.timerentry_starttime.getValue()) if self.timer.repeated: self.timer.begin = self.getTimestamp(self.timerentry_repeatedbegindate.getValue(), self.timerentry_starttime.getValue()) self.timer.end = self.getTimestamp(self.timerentry_repeatedbegindate.getValue(), self.timerentry_endtime.getValue()) else: self.timer.begin = self.getTimestamp(time.time(), self.timerentry_starttime.getValue()) self.timer.end = self.getTimestamp(time.time(), self.timerentry_endtime.getValue()) # when a timer end is set before the start, add 1 day if self.timer.end < self.timer.begin: self.timer.end += 86400 if self.timer.eit is not None: event = eEPGCache.getInstance().lookupEventId(self.timer.service_ref.ref, self.timer.eit) if event: n = event.getNumOfLinkageServices() if n > 1: tlist = [] ref = self.session.nav.getCurrentlyPlayingServiceOrGroup() parent = self.timer.service_ref.ref selection = 0 for x in range(n): i = event.getLinkageService(parent, x) if i.toString() == ref.toString(): selection = x tlist.append((i.getName(), i)) self.session.openWithCallback(self.subserviceSelected, ChoiceBox, title=_("Please select a subservice to record..."), list = tlist, selection = selection) return elif n > 0: parent = self.timer.service_ref.ref self.timer.service_ref = ServiceReference(event.getLinkageService(parent, 0)) self.saveTimer() self.close((True, self.timer)) def changeTimerType(self): self.timerentry_justplay.selectNext() self.timerJustplayEntry = getConfigListEntry(_("Timer type"), self.timerentry_justplay) self["config"].invalidate(self.timerJustplayEntry) def incrementStart(self): self.timerentry_starttime.increment() self["config"].invalidate(self.entryStartTime) if self.timerentry_type.value == "once" and self.timerentry_starttime.value == [0, 0]: self.timerentry_date.value += 86400 self["config"].invalidate(self.entryDate) def decrementStart(self): self.timerentry_starttime.decrement() self["config"].invalidate(self.entryStartTime) if self.timerentry_type.value == "once" and self.timerentry_starttime.value == [23, 59]: self.timerentry_date.value -= 86400 self["config"].invalidate(self.entryDate) def incrementEnd(self): if self.entryEndTime is not None: self.timerentry_endtime.increment() self["config"].invalidate(self.entryEndTime) def decrementEnd(self): if self.entryEndTime is not None: self.timerentry_endtime.decrement() self["config"].invalidate(self.entryEndTime) def subserviceSelected(self, service): if not service is None: self.timer.service_ref = ServiceReference(service[1]) self.saveTimer() self.close((True, self.timer)) def saveTimer(self): self.session.nav.RecordTimer.saveTimer() def keyCancel(self): self.close((False,)) def pathSelected(self, res): if res is not None: if config.movielist.videodirs.getValue() != self.timerentry_dirname.choices: self.timerentry_dirname.setChoices(config.movielist.videodirs.getValue(), default=res) self.timerentry_dirname.value = res def tagEditFinished(self, ret): if ret is not None: self.timerentry_tags = ret self.timerentry_tagsset.setChoices([not ret and "None" or " ".join(ret)]) self["config"].invalidate(self.tagsSet)
class RemoteControlType(Screen, ConfigListScreen): rcList = [ ("0", _("Default")), ("4", _("DMM normal")), ("6", _("DMM advanced")), ("11", "et9x00/6500"), ("7", "et5000/6000"), ("8", "VU+"), ] defaultRcList = [ ("et5000", 7), ("et6000", 7), ("et6500", 11), ("et9000", 11), ("et9200", 11), ("et9500", 11), ] def __init__(self, session): Screen.__init__(self, session) self.skinName = ["RemoteControlType", "Setup"] self["actions"] = ActionMap(["SetupActions"], { "cancel": self.keyCancel, "save": self.keySave, }, -1) self["key_green"] = StaticText(_("Save")) self["key_red"] = StaticText(_("Cancel")) self.list = [] ConfigListScreen.__init__(self, self.list, session=self.session) rctype = config.plugins.remotecontroltype.rctype.getValue() self.rctype = ConfigSelection(choices=self.rcList, default=str(rctype)) self.list.append( getConfigListEntry(_("Remote control type"), self.rctype)) self["config"].list = self.list self.defaultRcType = None self.getDefaultRcType() def getDefaultRcType(self): data = iRcTypeControl.getBoxType() for x in self.defaultRcList: if x[0] in data: self.defaultRcType = x[1] break def setDefaultRcType(self): iRcTypeControl.writeRcType(self.defaultRcType) def keySave(self): if config.plugins.remotecontroltype.rctype.getValue() == int( self.rctype.getValue()): self.close() else: self.setNewSetting() self.session.openWithCallback(self.keySaveCallback, MessageBox, _("Is this setting ok?"), MessageBox.TYPE_YESNO, timeout=20, default=False) def keySaveCallback(self, answer): if answer is False: self.restoreOldSetting() else: config.plugins.remotecontroltype.rctype.value = int( self.rctype.getValue()) config.plugins.remotecontroltype.save() self.close() def restoreOldSetting(self): if config.plugins.remotecontroltype.rctype.getValue() == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType( config.plugins.remotecontroltype.rctype.getValue()) def setNewSetting(self): if int(self.rctype.getValue()) == 0: self.setDefaultRcType() else: iRcTypeControl.writeRcType(int(self.rctype.getValue())) def keyCancel(self): self.restoreOldSetting() self.close()
class TimeshiftSettings(Screen, ConfigListScreen): def removeNotifier(self): config.usage.setup_level.notifiers.remove(self.levelChanged) def levelChanged(self, configElement): list = [] self.refill(list) self["config"].setList(list) def refill(self, list): xmldata = setupdom().getroot() for x in xmldata.findall("setup"): if x.get("key") != self.setup: continue self.addItems(list, x) self.setup_title = x.get("title", "").encode("UTF-8") self.seperation = int(x.get('separation', '0')) def __init__(self, session): Screen.__init__(self, session) self.skinName = "Setup" self['footnote'] = Label() self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self["description"] = Label(_("")) self.onChangedEntry = [] self.setup = "timeshift" list = [] ConfigListScreen.__init__(self, list, session=session, on_change=self.changedEntry) self.createSetup() self["setupActions"] = ActionMap( ["SetupActions", "ColorActions", "MenuActions"], { "green": self.keySave, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, "menu": self.closeRecursive, }, -2) self.onLayoutFinish.append(self.layoutFinished) # for summary: def changedEntry(self): self.item = self["config"].getCurrent() if self["config"].getCurrent()[0] == _("Timeshift location"): self.checkReadWriteDir(self["config"].getCurrent()[1]) for x in self.onChangedEntry: x() try: if isinstance(self["config"].getCurrent()[1], ConfigYesNo) or isinstance( self["config"].getCurrent()[1], ConfigSelection): self.createSetup() except: pass def getCurrentEntry(self): return self["config"].getCurrent() and self["config"].getCurrent( )[0] or "" def getCurrentValue(self): return self["config"].getCurrent() and str( self["config"].getCurrent()[1].getText()) or "" def getCurrentDescription(self): return self["config"].getCurrent() and len(self["config"].getCurrent( )) > 2 and self["config"].getCurrent()[2] or "" def checkReadWriteDir(self, configele): import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions( False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append( (partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint( os.path.realpath(configele.getValue()) ) + '/' in locations or Components.Harddisk.findMountPoint( os.path.realpath(configele.getValue())) in locations: if fileExists(configele.value, "w"): configele.last_value = configele.getValue() return True else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead." ) % dir, type=MessageBox.TYPE_ERROR) return False else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type." ) % dir, type=MessageBox.TYPE_ERROR) return False else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type." ) % dir, type=MessageBox.TYPE_ERROR) return False def createSetup(self): default = config.usage.timeshift_path.getValue() tmp = config.usage.allowed_timeshift_paths.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) # print "TimeshiftPath: ", default, tmp self.timeshift_dirname = ConfigSelection(default=default, choices=tmp) self.timeshift_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) list = [] self.timeshift_entry = getConfigListEntry( _("Timeshift location"), self.timeshift_dirname, _("Set the default location for your timeshift-files. Press 'OK' to add new locations, select left/right to select an existing location." )) list.append(self.timeshift_entry) self.refill(list) self["config"].setList(list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.getValue() self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.getValue( ) if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.getValue( ) self.session.openWithCallback(self.dirnameSelected, TimeshiftLocationBox) def dirnameSelected(self, res): if res is not None: import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions( False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append( (partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint( os.path.realpath(res) ) + '/' in locations or Components.Harddisk.findMountPoint( os.path.realpath(res)) in locations: self.entrydirname.value = res if config.usage.allowed_timeshift_paths.getValue( ) != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.getValue() default = self.timeshift_dirname.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.value = res else: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type." ) % res, type=MessageBox.TYPE_ERROR) else: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type." ) % res, type=MessageBox.TYPE_ERROR) def saveAll(self): for x in self["config"].list: x[1].save() configfile.save() # keySave and keyCancel are just provided in case you need them. # you have to call them by yourself. def keySave(self): import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions( False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append( (partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint( os.path.realpath(config.usage.timeshift_path.getValue()) ) + '/' in locations or Components.Harddisk.findMountPoint( os.path.realpath( config.usage.timeshift_path.getValue())) in locations: config.usage.timeshift_path.value = self.timeshift_dirname.getValue( ) config.usage.timeshift_path.save() self.saveAll() self.close() else: if int(config.timeshift.startdelay.getValue()) > 0: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type." ) % config.usage.timeshift_path.getValue(), type=MessageBox.TYPE_ERROR) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() else: if int(config.timeshift.startdelay.getValue()) > 0: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type." ) % config.usage.timeshift_path.getValue(), type=MessageBox.TYPE_ERROR) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback( self.cancelConfirm, MessageBox, _("Really close without saving settings?"), default=False) else: self.close() def createSummary(self): return SetupSummary def addItems(self, list, parentNode): for x in parentNode: if not x.tag: continue if x.tag == 'item': item_level = int(x.get("level", 0)) if not self.levelChanged in config.usage.setup_level.notifiers: config.usage.setup_level.notifiers.append( self.levelChanged) self.onClose.append(self.removeNotifier) if item_level > config.usage.setup_level.index: continue requires = x.get("requires") if requires and requires.startswith('config.'): item = eval(requires or "") if item.getValue() and not item.getValue() == "0": SystemInfo[requires] = True else: SystemInfo[requires] = False if requires and not SystemInfo.get(requires, False): continue item_text = _(x.get("text", "??").encode("UTF-8")) item_description = _(x.get("description", " ").encode("UTF-8")) b = eval(x.text or "") if b == "": continue #add to configlist item = b # the first b is the item itself, ignored by the configList. # the second one is converted to string. if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport): def getNetworksForNim(self, nim): if nim.isCompatible("DVB-S"): networks = nimmanager.getSatListForNim(nim.slot) elif not nim.empty: networks = [ nim.type ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that. else: # empty tuners provide no networks. networks = [ ] return networks def __init__(self, session): Screen.__init__(self, session) Screen.setTitle(self, _("Automatic Scan")) self["key_red"] = StaticText(_("Close")) self["key_green"] = StaticText(_("Scan")) self["actions"] = ActionMap(["SetupActions", "MenuActions", "ColorActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "menu": self.doCloseRecursive, "red": self.keyCancel, "green": self.keyGo, }, -2) self.session.postScanService = session.nav.getCurrentlyPlayingServiceOrGroup() self.list = [] tlist = [] known_networks = [ ] nims_to_scan = [ ] self.finished_cb = None for nim in nimmanager.nim_slots: # collect networks provided by this tuner need_scan = False networks = self.getNetworksForNim(nim) print "nim %d provides" % nim.slot, networks print "known:", known_networks # we only need to scan on the first tuner which provides a network. # this gives the first tuner for each network priority for scanning. for x in networks: if x not in known_networks: need_scan = True print x, "not in ", known_networks known_networks.append(x) # don't offer to scan nims if nothing is connected if not nimmanager.somethingConnected(nim.slot): need_scan = False if need_scan: nims_to_scan.append(nim) # we save the config elements to use them on keyGo self.nim_enable = [ ] if len(nims_to_scan): self.scan_clearallservices = ConfigSelection(default = "yes", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))]) self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) for nim in nims_to_scan: nimconfig = ConfigYesNo(default = True) nimconfig.nim_index = nim.slot self.nim_enable.append(nimconfig) self.list.append(getConfigListEntry(_("Scan ") + nim.slot_name + " (" + nim.friendly_type + ")", nimconfig)) ConfigListScreen.__init__(self, self.list) self["header"] = Label(_("Automatic scan")) self["footer"] = Label(_("Press OK to scan")) def runAsync(self, finished_cb): self.finished_cb = finished_cb self.keyGo() def keyGo(self): InfoBarInstance = InfoBar.instance if InfoBarInstance: InfoBarInstance.checkTimeshiftRunning(self.keyGoCheckTimeshiftCallback) else: self.keyGoCheckTimeshiftCallback(True) def keyGoCheckTimeshiftCallback(self, answer): if answer: self.scanList = [] self.known_networks = set() self.nim_iter=0 self.buildTransponderList() def buildTransponderList(self): # this method is called multiple times because of asynchronous stuff APPEND_NOW = 0 SEARCH_CABLE_TRANSPONDERS = 1 action = APPEND_NOW n = self.nim_iter < len(self.nim_enable) and self.nim_enable[self.nim_iter] or None self.nim_iter += 1 if n: if n.getValue(): # check if nim is enabled flags = 0 nim = nimmanager.nim_slots[n.nim_index] networks = set(self.getNetworksForNim(nim)) networkid = 0 # don't scan anything twice networks.discard(self.known_networks) tlist = [ ] if nim.isCompatible("DVB-S"): # get initial transponders for each satellite to be scanned for sat in networks: getInitialTransponderList(tlist, sat[0]) elif nim.isCompatible("DVB-C"): if config.Nims[nim.slot].cable.scan_type.getValue() == "provider": getInitialCableTransponderList(tlist, nim.slot) else: action = SEARCH_CABLE_TRANSPONDERS networkid = config.Nims[nim.slot].cable.scan_networkid.getValue() elif nim.isCompatible("DVB-T"): getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(nim.slot)) else: assert False flags |= eComponentScan.scanNetworkSearch #FIXMEEE.. use flags from cables / satellites / terrestrial.xml tmp = self.scan_clearallservices.getValue() if tmp == "yes": flags |= eComponentScan.scanRemoveServices elif tmp == "yes_hold_feeds": flags |= eComponentScan.scanRemoveServices flags |= eComponentScan.scanDontRemoveFeeds if action == APPEND_NOW: self.scanList.append({"transponders": tlist, "feid": nim.slot, "flags": flags}) elif action == SEARCH_CABLE_TRANSPONDERS: self.flags = flags self.feid = nim.slot self.networkid = networkid self.startCableTransponderSearch(nim.slot) return else: assert False self.buildTransponderList() # recursive call of this function !!! return # when we are here, then the recursion is finished and all enabled nims are checked # so we now start the real transponder scan self.startScan(self.scanList) def startScan(self, scanList): if len(scanList): if self.finished_cb: self.session.openWithCallback(self.finished_cb, ServiceScan, scanList = scanList) else: self.session.open(ServiceScan, scanList = scanList) else: if self.finished_cb: self.session.openWithCallback(self.finished_cb, MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) else: self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) def setCableTransponderSearchResult(self, tlist): if tlist is not None: self.scanList.append({"transponders": tlist, "feid": self.feid, "flags": self.flags}) def cableTransponderSearchFinished(self): self.buildTransponderList() def keyCancel(self): self.session.nav.playService(self.session.postScanService) self.close() def doCloseRecursive(self): self.session.nav.playService(self.session.postScanService) self.closeRecursive() def Satexists(self, tlist, pos): for x in tlist: if x == pos: return 1 return 0
class FastScanScreen(ConfigListScreen, Screen): skin = """ <screen position="100,115" size="520,290" title="Fast Scan"> <widget name="config" position="10,10" size="500,250" scrollbarMode="showOnDemand" /> <widget name="introduction" position="10,265" size="500,25" font="Regular;20" halign="center" /> </screen>""" def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("Fast Scan")) self["actions"] = ActionMap( ["SetupActions", "MenuActions"], { "ok": self.keyGo, "cancel": self.keyCancel, "menu": self.closeRecursive, }, -2) nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: if not n.isCompatible("DVB-S"): continue if n.config_mode == "nothing": continue if n.config_mode in ("loopthrough", "satposdepends"): root_id = nimmanager.sec.getRoot( n.slot_id, int(n.config.connectedTo.getValue())) if n.type == nimmanager.nim_slots[ root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa continue nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices=nim_list) provider_list = [] provider_list.append((str(900), 'Canal Digitaal')) provider_list.append((str(910), 'TV Vlaanderen')) provider_list.append((str(920), 'TéléSAT')) provider_list.append((str(930), 'Mobistar NL')) provider_list.append((str(940), 'Mobistar FR')) provider_list.append((str(950), 'AustriaSat')) provider_list.append((str(30), 'Czech Republic')) provider_list.append((str(31), 'Slovak Republic')) self.scan_provider = ConfigSelection(choices=provider_list) self.scan_hd = ConfigYesNo(default=True) self.scan_keepnumbering = ConfigYesNo(default=False) self.scan_keepsettings = ConfigYesNo(default=False) self.list = [] self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) self.scanProvider = getConfigListEntry(_("Provider"), self.scan_provider) self.list.append(self.scanProvider) self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd) self.list.append(self.scanHD) self.list.append( getConfigListEntry(_("Use fastscan channel numbering"), self.scan_keepnumbering)) self.list.append( getConfigListEntry(_("Use fastscan channel names"), self.scan_keepsettings)) ConfigListScreen.__init__(self, self.list) self["config"].list = self.list self["config"].l.setList(self.list) self.finished_cb = None self["introduction"] = Label( _("Select your provider, and press OK to start the scan")) def keyGo(self): self.startScan() def startScan(self): pid = int(self.scan_provider.getValue()) if self.scan_hd.getValue() and pid >= 900 and pid < 930: pid += 1 if self.scan_nims.getValue(): self.session.open(FastScanStatus, scanTuner=int(self.scan_nims.getValue()), scanPid=pid, keepNumbers=self.scan_keepnumbering.getValue(), keepSettings=self.scan_keepsettings.getValue(), providerName=self.scan_provider.getText()) def keyCancel(self): self.close()
class InstallWizard(Screen, ConfigListScreen): STATE_UPDATE = 0 STATE_CHOISE_CHANNELLIST = 1 # STATE_CHOISE_SOFTCAM = 2 def __init__(self, session, args=None): Screen.__init__(self, session) self.index = args self.list = [] ConfigListScreen.__init__(self, self.list) if self.index == self.STATE_UPDATE: config.misc.installwizard.hasnetwork.setValue(False) config.misc.installwizard.ipkgloaded.setValue(False) modes = {0: " "} self.enabled = ConfigSelection(choices=modes, default=0) self.adapters = [(iNetwork.getFriendlyAdapterName(x), x) for x in iNetwork.getAdapterList()] is_found = False for x in self.adapters: if x[1] == 'eth0': if iNetwork.getAdapterAttribute(x[1], 'up'): self.ipConfigEntry = ConfigIP( default=iNetwork.getAdapterAttribute(x[1], "ip")) iNetwork.checkNetworkState(self.checkNetworkCB) if_found = True else: iNetwork.restartNetwork(self.checkNetworkLinkCB) break if is_found is False: self.createMenu() elif self.index == self.STATE_CHOISE_CHANNELLIST: self.enabled = ConfigYesNo(default=True) modes = { "AAF": "AAF default(13e-19e)", "19e": "Astra 1", "23e": "Astra 3", "19e-23e": "Astra 1 Astra 3", "19e-23e-28e": "Astra 1 Astra 2 Astra 3", "13e-19e-23e-28e": "Astra 1 Astra 2 Astra 3 Hotbird" } self.channellist_type = ConfigSelection(choices=modes, default="AAF") self.createMenu() # elif self.index == self.STATE_CHOISE_SOFTCAM: # self.enabled = ConfigYesNo(default = True) # modes = {"cccam": _("default") + " (CCcam)", "scam": "scam"} # self.softcam_type = ConfigSelection(choices = modes, default = "cccam") # self.createMenu() def checkNetworkCB(self, data): if data < 3: config.misc.installwizard.hasnetwork.setValue(True) self.createMenu() def checkNetworkLinkCB(self, retval): if retval: iNetwork.checkNetworkState(self.checkNetworkCB) else: self.createMenu() def createMenu(self): try: test = self.index except: return self.list = [] if self.index == self.STATE_UPDATE: if config.misc.installwizard.hasnetwork.getValue(): self.list.append( getConfigListEntry( _("Your internet connection is working (ip: %s)") % (self.ipConfigEntry.getText()), self.enabled)) else: self.list.append( getConfigListEntry( _("Your receiver does not have an internet connection" ), self.enabled)) elif self.index == self.STATE_CHOISE_CHANNELLIST: self.list.append( getConfigListEntry(_("Install channel list"), self.enabled)) if self.enabled.getValue(): self.list.append( getConfigListEntry(_("Channel list type"), self.channellist_type)) # elif self.index == self.STATE_CHOISE_SOFTCAM: # self.list.append(getConfigListEntry(_("Install softcam"), self.enabled)) # if self.enabled.value: # self.list.append(getConfigListEntry(_("Softcam type"), self.softcam_type)) self["config"].list = self.list self["config"].l.setList(self.list) def keyLeft(self): if self.index == 0: return ConfigListScreen.keyLeft(self) self.createMenu() def keyRight(self): if self.index == 0: return ConfigListScreen.keyRight(self) self.createMenu() def run(self): if self.index == self.STATE_UPDATE: if config.misc.installwizard.hasnetwork.getValue(): self.session.open(InstallWizardIpkgUpdater, self.index, _('Please wait (updating packages)'), IpkgComponent.CMD_UPDATE) elif self.index == self.STATE_CHOISE_CHANNELLIST and self.enabled.getValue( ) and self.channellist_type.getValue() != "AAF": self.session.open( InstallWizardIpkgUpdater, self.index, _('Please wait (downloading channel list)'), IpkgComponent.CMD_REMOVE, { 'package': 'enigma2-plugin-settings-henksat-' + self.channellist_type.getValue() }) # elif self.index == self.STATE_CHOISE_SOFTCAM and self.enabled.value: # self.session.open(InstallWizardIpkgUpdater, self.index, _('Please wait (downloading softcam)'), IpkgComponent.CMD_INSTALL, {'package': 'enigma2-plugin-softcams-' + self.softcam_type.value}) return
class TimerEntry(Screen, ConfigListScreen): def __init__(self, session, timer): Screen.__init__(self, session) self.timer = timer self.entryDate = None self.entryService = None self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["oktext"] = Label(_("OK")) self["canceltext"] = Label(_("Cancel")) self["ok"] = Pixmap() self["cancel"] = Pixmap() self.createConfig() self["actions"] = NumberActionMap(["SetupActions", "GlobalActions", "PiPSetupActions"], { "ok": self.keySelect, "save": self.keyGo, "cancel": self.keyCancel, "volumeUp": self.incrementStart, "volumeDown": self.decrementStart, "size+": self.incrementEnd, "size-": self.decrementEnd }, -2) self.list = [] ConfigListScreen.__init__(self, self.list, session = session) self.setTitle(_("PowerManager entry")) self.createSetup("config") def createConfig(self): afterevent = { AFTEREVENT.NONE: "nothing", AFTEREVENT.WAKEUPTOSTANDBY: "wakeuptostandby", AFTEREVENT.STANDBY: "standby", AFTEREVENT.DEEPSTANDBY: "deepstandby" }[self.timer.afterEvent] timertype = { TIMERTYPE.WAKEUP: "wakeup", TIMERTYPE.WAKEUPTOSTANDBY: "wakeuptostandby", TIMERTYPE.AUTOSTANDBY: "autostandby", TIMERTYPE.AUTODEEPSTANDBY: "autodeepstandby", TIMERTYPE.STANDBY: "standby", TIMERTYPE.DEEPSTANDBY: "deepstandby", TIMERTYPE.REBOOT: "reboot", TIMERTYPE.RESTART: "restart" }[self.timer.timerType] weekday_table = ("mon", "tue", "wed", "thu", "fri", "sat", "sun") # calculate default values day = [] weekday = 0 for x in (0, 1, 2, 3, 4, 5, 6): day.append(0) if self.timer.repeated: # repeated type = "repeated" if self.timer.repeated == 31: # Mon-Fri repeated = "weekdays" elif self.timer.repeated == 127: # daily repeated = "daily" else: flags = self.timer.repeated repeated = "user" count = 0 for x in (0, 1, 2, 3, 4, 5, 6): if flags == 1: # weekly print "Set to weekday " + str(x) weekday = x if flags & 1 == 1: # set user defined flags day[x] = 1 count += 1 else: day[x] = 0 flags >>= 1 if count == 1: repeated = "weekly" else: # once type = "once" repeated = None weekday = int(strftime("%u", localtime(self.timer.begin))) - 1 day[weekday] = 1 autosleepinstandbyonly = self.timer.autosleepinstandbyonly autosleepdelay = self.timer.autosleepdelay autosleeprepeat = self.timer.autosleeprepeat if SystemInfo["DeepstandbySupport"]: shutdownString = _("go to deep standby") else: shutdownString = _("shut down") self.timerentry_timertype = ConfigSelection(choices = [("wakeup", _("wakeup")),("wakeuptostandby", _("wakeup to standby")), ("autostandby", _("auto standby")), ("autodeepstandby", _("auto deepstandby")), ("standby", _("go to standby")), ("deepstandby", shutdownString), ("reboot", _("reboot system")), ("restart", _("restart GUI"))], default = timertype) self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")), ("wakeuptostandby", _("wakeup to standby")), ("standby", _("go to standby")), ("deepstandby", shutdownString), ("nothing", _("do nothing"))], default = afterevent) self.timerentry_type = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = type) self.timerentry_repeated = ConfigSelection(default = repeated, choices = [("daily", _("daily")), ("weekly", _("weekly")), ("weekdays", _("Mon-Fri")), ("user", _("user defined"))]) self.timerrntry_autosleepdelay = ConfigInteger(default=autosleepdelay, limits = (10, 300)) self.timerentry_autosleeprepeat = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = autosleeprepeat) self.timerrntry_autosleepinstandbyonly = ConfigSelection(choices = [("yes",_("Yes")), ("no", _("No"))],default=autosleepinstandbyonly) self.timerentry_date = ConfigDateTime(default = self.timer.begin, formatstring = _("%d.%B %Y"), increment = 86400) self.timerentry_starttime = ConfigClock(default = self.timer.begin) self.timerentry_endtime = ConfigClock(default = self.timer.end) self.timerentry_showendtime = ConfigSelection(default = (((self.timer.end - self.timer.begin) /60 ) > 1), choices = [(True, _("yes")), (False, _("no"))]) self.timerentry_repeatedbegindate = ConfigDateTime(default = self.timer.repeatedbegindate, formatstring = _("%d.%B %Y"), increment = 86400) self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))]) self.timerentry_day = ConfigSubList() for x in (0, 1, 2, 3, 4, 5, 6): self.timerentry_day.append(ConfigYesNo(default = day[x])) def createSetup(self, widget): self.list = [] self.timerType = getConfigListEntry(_("Timer type"), self.timerentry_timertype) self.list.append(self.timerType) if self.timerentry_timertype.getValue() == "autostandby" or self.timerentry_timertype.getValue() == "autodeepstandby": if self.timerentry_timertype.getValue() == "autodeepstandby": self.list.append(getConfigListEntry(_("Only active when in standby"), self.timerrntry_autosleepinstandbyonly)) self.list.append(getConfigListEntry(_("Sleep delay"), self.timerrntry_autosleepdelay)) self.list.append(getConfigListEntry(_("Repeat type"), self.timerentry_autosleeprepeat)) self.timerTypeEntry = getConfigListEntry(_("Repeat type"), self.timerentry_type) self.entryShowEndTime = getConfigListEntry(_("Set end time"), self.timerentry_showendtime) self.frequencyEntry = getConfigListEntry(_("Repeats"), self.timerentry_repeated) else: self.timerTypeEntry = getConfigListEntry(_("Repeat type"), self.timerentry_type) self.list.append(self.timerTypeEntry) if self.timerentry_type.getValue() == "once": self.frequencyEntry = None else: # repeated self.frequencyEntry = getConfigListEntry(_("Repeats"), self.timerentry_repeated) self.list.append(self.frequencyEntry) self.repeatedbegindateEntry = getConfigListEntry(_("Starting on"), self.timerentry_repeatedbegindate) self.list.append(self.repeatedbegindateEntry) if self.timerentry_repeated.getValue() == "daily": pass if self.timerentry_repeated.getValue() == "weekdays": pass if self.timerentry_repeated.getValue() == "weekly": self.list.append(getConfigListEntry(_("Weekday"), self.timerentry_weekday)) if self.timerentry_repeated.getValue() == "user": self.list.append(getConfigListEntry(_("Monday"), self.timerentry_day[0])) self.list.append(getConfigListEntry(_("Tuesday"), self.timerentry_day[1])) self.list.append(getConfigListEntry(_("Wednesday"), self.timerentry_day[2])) self.list.append(getConfigListEntry(_("Thursday"), self.timerentry_day[3])) self.list.append(getConfigListEntry(_("Friday"), self.timerentry_day[4])) self.list.append(getConfigListEntry(_("Saturday"), self.timerentry_day[5])) self.list.append(getConfigListEntry(_("Sunday"), self.timerentry_day[6])) self.entryDate = getConfigListEntry(_("Date"), self.timerentry_date) if self.timerentry_type.getValue() == "once": self.list.append(self.entryDate) self.entryStartTime = getConfigListEntry(_("Start time"), self.timerentry_starttime) self.list.append(self.entryStartTime) self.entryShowEndTime = getConfigListEntry(_("Set end time"), self.timerentry_showendtime) self.list.append(self.entryShowEndTime) self.entryEndTime = getConfigListEntry(_("End time"), self.timerentry_endtime) if self.timerentry_showendtime.getValue(): self.list.append(self.entryEndTime) self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent)) self[widget].list = self.list self[widget].l.setList(self.list) def newConfig(self): if self["config"].getCurrent() in (self.timerType, self.timerTypeEntry, self.frequencyEntry, self.entryShowEndTime): self.createSetup("config") def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() def keySelect(self): cur = self["config"].getCurrent() self.keyGo() def getTimestamp(self, date, mytime): d = localtime(date) dt = datetime(d.tm_year, d.tm_mon, d.tm_mday, mytime[0], mytime[1]) return int(mktime(dt.timetuple())) def getBeginEnd(self): date = self.timerentry_date.getValue() endtime = self.timerentry_endtime.getValue() starttime = self.timerentry_starttime.getValue() begin = self.getTimestamp(date, starttime) end = self.getTimestamp(date, endtime) # if the endtime is less than the starttime, add 1 day. if end < begin: end += 86400 return begin, end def keyGo(self, result = None): if not self.timerentry_showendtime.getValue(): self.timerentry_endtime.value = self.timerentry_starttime.getValue() self.timer.resetRepeated() self.timer.timerType = { "wakeup": TIMERTYPE.WAKEUP, "wakeuptostandby": TIMERTYPE.WAKEUPTOSTANDBY, "autostandby": TIMERTYPE.AUTOSTANDBY, "autodeepstandby": TIMERTYPE.AUTODEEPSTANDBY, "standby": TIMERTYPE.STANDBY, "deepstandby": TIMERTYPE.DEEPSTANDBY, "reboot": TIMERTYPE.REBOOT, "restart": TIMERTYPE.RESTART }[self.timerentry_timertype.value] self.timer.afterEvent = { "nothing": AFTEREVENT.NONE, "wakeuptostandby": AFTEREVENT.WAKEUPTOSTANDBY, "standby": AFTEREVENT.STANDBY, "deepstandby": AFTEREVENT.DEEPSTANDBY }[self.timerentry_afterevent.value] if self.timerentry_type.getValue() == "once": self.timer.begin, self.timer.end = self.getBeginEnd() if self.timerentry_timertype.getValue() == "autostandby" or self.timerentry_timertype.getValue() == "autodeepstandby": self.timer.begin = int(time()) + 10 self.timer.end = self.timer.begin self.timer.autosleepinstandbyonly = self.timerrntry_autosleepinstandbyonly.getValue() self.timer.autosleepdelay = self.timerrntry_autosleepdelay.getValue() self.timer.autosleeprepeat = self.timerentry_autosleeprepeat.getValue() if self.timerentry_type.getValue() == "repeated": if self.timerentry_repeated.getValue() == "daily": for x in (0, 1, 2, 3, 4, 5, 6): self.timer.setRepeated(x) if self.timerentry_repeated.getValue() == "weekly": self.timer.setRepeated(self.timerentry_weekday.index) if self.timerentry_repeated.getValue() == "weekdays": for x in (0, 1, 2, 3, 4): self.timer.setRepeated(x) if self.timerentry_repeated.getValue() == "user": for x in (0, 1, 2, 3, 4, 5, 6): if self.timerentry_day[x].getValue(): self.timer.setRepeated(x) self.timer.repeatedbegindate = self.getTimestamp(self.timerentry_repeatedbegindate.getValue(), self.timerentry_starttime.getValue()) if self.timer.repeated: self.timer.begin = self.getTimestamp(self.timerentry_repeatedbegindate.getValue(), self.timerentry_starttime.getValue()) self.timer.end = self.getTimestamp(self.timerentry_repeatedbegindate.getValue(), self.timerentry_endtime.getValue()) else: self.timer.begin = self.getTimestamp(time.time(), self.timerentry_starttime.getValue()) self.timer.end = self.getTimestamp(time.time(), self.timerentry_endtime.getValue()) # when a timer end is set before the start, add 1 day if self.timer.end < self.timer.begin: self.timer.end += 86400 self.saveTimer() self.close((True, self.timer)) def incrementStart(self): self.timerentry_starttime.increment() self["config"].invalidate(self.entryStartTime) if self.timerentry_type.value == "once" and self.timerentry_starttime.value == [0, 0]: self.timerentry_date.value += 86400 self["config"].invalidate(self.entryDate) def decrementStart(self): self.timerentry_starttime.decrement() self["config"].invalidate(self.entryStartTime) if self.timerentry_type.value == "once" and self.timerentry_starttime.value == [23, 59]: self.timerentry_date.value -= 86400 self["config"].invalidate(self.entryDate) def incrementEnd(self): if self.entryEndTime is not None: self.timerentry_endtime.increment() self["config"].invalidate(self.entryEndTime) def decrementEnd(self): if self.entryEndTime is not None: self.timerentry_endtime.decrement() self["config"].invalidate(self.entryEndTime) def saveTimer(self): self.session.nav.PowerTimer.saveTimer() def keyCancel(self): self.close((False,))
class RecordingSettings(Screen,ConfigListScreen): skin = """ <screen name="RecordPathsSettings" position="160,150" size="450,200" title="Recording paths"> <ePixmap pixmap="skin_default/buttons/red.png" position="10,0" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/green.png" position="300,0" size="140,40" alphatest="on" /> <widget source="key_red" render="Label" position="10,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" /> <widget source="key_green" render="Label" position="300,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" /> <widget name="config" position="10,44" size="430,146" /> </screen>""" def __init__(self, session): from Components.Sources.StaticText import StaticText Screen.__init__(self, session) self.skinName = "Setup" self.setup_title = _("Recording settings") Screen.setTitle(self, _(self.setup_title)) self["status"] = StaticText() self['footnote'] = Label() self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self.onChangedEntry = [ ] self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry) self.createSetup() self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "green": self.keySave, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, "menu": self.closeRecursive, }, -2) if not self.SelectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.SelectionChanged) def checkReadWriteDir(self, configele): print "checkReadWrite: ", configele.getValue() if configele.getValue() in [x[0] for x in self.styles] or fileExists(configele.getValue(), "w"): configele.last_value = configele.getValue() return True else: dir = configele.getValue() configele.setValue(configele.last_value) self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead.")%dir, type = MessageBox.TYPE_ERROR ) return False def createSetup(self): self.styles = [ ("<default>", _("<Default movie location>")), ("<current>", _("<Current movielist location>")), ("<timer>", _("<Last timer location>")) ] styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.getValue() default = config.usage.default_path.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) print "DefaultPath: ", default, tmp self.default_dirname = ConfigSelection(default = default, choices = tmp) tmp = config.movielist.videodirs.getValue() default = config.usage.timer_path.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) print "TimerPath: ", default, tmp self.timer_dirname = ConfigSelection(default = default, choices = self.styles+tmp) tmp = config.movielist.videodirs.getValue() default = config.usage.instantrec_path.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) print "InstantrecPath: ", default, tmp self.instantrec_dirname = ConfigSelection(default = default, choices = self.styles+tmp) self.default_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.timer_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.instantrec_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.list = [] if config.usage.setup_level.index >= 2: self.default_entry = getConfigListEntry(_("Default movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) self.list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer record location"), self.timer_dirname, _("Set the default location for your timers. Press 'OK' to add new locations, select left/right to select an existing location.")) self.list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry(_("Instant record location"), self.instantrec_dirname, _("Set the default location for your instant recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) self.list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) self.list.append(self.default_entry) if config.usage.setup_level.index >= 1: self.list.append(getConfigListEntry(_("Recordings always have priority"), config.recording.asktozap, _("Select 'Yes' if you want recordings to have priority over live-TV."))) self.list.append(getConfigListEntry(_("Margin before record (minutes)"), config.recording.margin_before, _("Set the time you want recordings to start before the event start-time."))) self.list.append(getConfigListEntry(_("Margin after record"), config.recording.margin_after, _("Set the time you want recordings to stop after the event stop-time."))) if config.usage.setup_level.index >= 2: self.list.append(getConfigListEntry(_("Show Message when Recording starts"), config.usage.show_message_when_recording_starts, _("Do you want a pop-up message saying 'a recording has started'?"))) self.list.append(getConfigListEntry(_("Behavior when a movie is started"), config.usage.on_movie_start, _("On starting playback of a file, you can choose the box's behaviour."))) self.list.append(getConfigListEntry(_("Behavior when a movie is stopped"), config.usage.on_movie_stop, _("On stopping playback of a file, you can choose the box's behaviour."))) self.list.append(getConfigListEntry(_("Behavior when a movie reaches the end"), config.usage.on_movie_eof, _("On reaching the end of a file during playback, you can choose the box's behaviour."))) self.list.append(getConfigListEntry(_("Behavior of 'pause' when paused"), config.seek.on_pause, _("Here you can select the behaviour of the 'puase'-button when playback has been paused."))) self.list.append(getConfigListEntry(_("Custom skip time for '1'/'3'-keys"), config.seek.selfdefined_13, _("Set the skip-forward/backward time of the 1-3 number keys."))) self.list.append(getConfigListEntry(_("Custom skip time for '4'/'6'-keys"), config.seek.selfdefined_46, _("Set the skip-forward/backward time of the 4-6 number keys."))) self.list.append(getConfigListEntry(_("Custom skip time for '7'/'9'-keys"), config.seek.selfdefined_79, _("Set the skip-forward/backward time of the 7-9 number keys."))) self.list.append(getConfigListEntry(_("Display message before next played movie"), config.usage.next_movie_msg, _("Show a popup message after a recording has finished and before start next in queue."))) self.list.append(getConfigListEntry(_("Seekbar activation"), config.seek.baractivation, _("Select seekbar to be activated by arrow L/R (long) or << >> (long)."))) self.list.append(getConfigListEntry(_("Seekbar sensibility"), config.seek.sensibility, _("Set the jump-size of the seekbar."))) self.list.append(getConfigListEntry(_("Fast Forward speeds"), config.seek.speeds_forward, _("Set the values for fast-forward speeds."))) self.list.append(getConfigListEntry(_("Rewind speeds"), config.seek.speeds_backward, _("Set the values for fast-backward speeds."))) self.list.append(getConfigListEntry(_("Slow Motion speeds"), config.seek.speeds_slowmotion, _("Set the values for slow-motion speeds."))) self.list.append(getConfigListEntry(_("Initial Fast Forward speed"), config.seek.enter_forward, _("Set the value for the initial fast-forward speed."))) self.list.append(getConfigListEntry(_("Initial Rewind speed"), config.seek.enter_backward, _("Set the value for the initial fast-backward speed."))) self.list.append(getConfigListEntry(_("Limited character set for recording filenames"), config.recording.ascii_filenames, _("Select 'Yes' if you want only a small number of characters to be used for recording names."))) self.list.append(getConfigListEntry(_("Composition of the recording filenames"), config.recording.filename_composition, _("Select how you want recording names to be populated."))) self.list.append(getConfigListEntry(_("Keep old timers for how many days"), config.recording.keep_timers, _("Set the number of days you want old timers to be kept."))) if config.usage.setup_level.index >= 1: self.list.append(getConfigListEntry(_("Use trashcan in movielist"), config.usage.movielist_trashcan, _("If set to 'Yes' recordings will be deleted to a trashcan. That way thay can still be played."))) self.list.append(getConfigListEntry(_("Remove items from trash after (days)"), config.usage.movielist_trashcan_days, _("Select the number of days after which the box is allowed to permanently delete recordings (from the trashcan)."))) self.list.append(getConfigListEntry(_("Disk space to reserve for recordings (in GB)"), config.usage.movielist_trashcan_reserve, _("Items in trashcan will be deleted if less then the set space is available."))) if config.usage.setup_level.index >= 2: self.list.append(getConfigListEntry(_("Background delete option"), config.misc.erase_flags, _("Only change for debugging; default is 'Internal hdd only'."))) self.list.append(getConfigListEntry(_("Background delete speed"), config.misc.erase_speed, _("Only change for debugging; default is '20 MB/s'."))) self.list.append(getConfigListEntry(_("Offline decode delay (ms)"), config.recording.offline_decode_delay, _("Change this value if your smartcard can't doesn't handle off-line decoding well; default is '1000'."))) self["config"].setList(self.list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def SelectionChanged(self): self["status"].setText(self["config"].getCurrent()[2]) # for summary: def changedEntry(self): if self["config"].getCurrent()[0] == _("Default movie location") or self["config"].getCurrent()[0] == _("Timer record location") or self["config"].getCurrent()[0] == _("Instant record location") or self["config"].getCurrent()[0] == _("Movie location"): self.checkReadWriteDir(self["config"].getCurrent()[1]) for x in self.onChangedEntry: x() def getCurrentEntry(self): return self["config"].getCurrent()[0] def getCurrentValue(self): return str(self["config"].getCurrent()[1].getText()) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.getValue() self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.getValue() if config.usage.setup_level.index >= 2: txt = _("Default movie location") else: txt = _("Movie location") if currentry == self.default_entry: self.entrydirname = self.default_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, txt, preferredPath(self.default_dirname.getValue()) ) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("New timers location"), preferredPath(self.timer_dirname.getValue()) ) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Instant recordings location"), preferredPath(self.instantrec_dirname.getValue()) ) def dirnameSelected(self, res): if res is not None: self.entrydirname.setValue(res) if config.movielist.videodirs.getValue() != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.getValue() default = self.default_dirname.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.getValue() default = self.timer_dirname.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.timer_dirname.setChoices(self.styles+tmp, default=default) tmp = config.movielist.videodirs.getValue() default = self.instantrec_dirname.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.instantrec_dirname.setChoices(self.styles+tmp, default=default) self.entrydirname.setValue(res) if self.entrydirname.last_value != res: self.checkReadWriteDir(self.entrydirname) def saveAll(self): currentry = self["config"].getCurrent() config.usage.default_path.setValue(self.default_dirname.getValue()) config.usage.timer_path.setValue(self.timer_dirname.getValue()) config.usage.instantrec_path.setValue(self.instantrec_dirname.getValue()) config.usage.default_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() for x in self["config"].list: x[1].save() configfile.save() # keySave and keyCancel are just provided in case you need them. # you have to call them by yourself. def keySave(self): self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?")) else: self.close() def createSummary(self): from Screens.Setup import SetupSummary return SetupSummary
class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): def __init__(self, session): Screen.__init__(self, session) Screen.setTitle(self, _("Manual Scan")) self.finished_cb = None self.updateSatList() self.service = session.nav.getCurrentService() self.feinfo = None self.networkid = 0 frontendData = None if self.service is not None: self.feinfo = self.service.frontendInfo() frontendData = self.feinfo and self.feinfo.getAll(True) self.createConfig(frontendData) del self.feinfo del self.service self.session.postScanService = session.nav.getCurrentlyPlayingServiceOrGroup() self["key_red"] = StaticText(_("Close")) self["key_green"] = StaticText(_("Scan")) self["actions"] = NumberActionMap(["SetupActions", "MenuActions", "ColorActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "red": self.keyCancel, "green": self.keyGo, "menu": self.doCloseRecursive, }, -2) self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) #self.statusTimer.start(5000, True) self.list = [] ConfigListScreen.__init__(self, self.list) self["header"] = Label(_("Manual Scan")) if not self.scan_nims.getValue() == "": self.createSetup() self["introduction"] = Label(_("Press OK to start the scan")) else: self["introduction"] = Label(_("Nothing to scan!\nPlease setup your tuner settings before you start a service scan.")) def runAsync(self, finished_cb): self.finished_cb = finished_cb self.keyGo() def updateSatList(self): self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None) def createSetup(self): self.list = [] self.multiscanlist = [] index_to_scan = int(self.scan_nims.getValue()) print "ID: ", index_to_scan self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) if self.scan_nims == [ ]: return self.typeOfScanEntry = None self.systemEntry = None self.modulationEntry = None nim = nimmanager.nim_slots[index_to_scan] if nim.isCompatible("DVB-S"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-C"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typecable) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-T"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial) self.list.append(self.typeOfScanEntry) self.scan_networkScan.setValue(False) if nim.isCompatible("DVB-S"): if self.scan_type.getValue() == "single_transponder": self.updateSatList() if nim.isCompatible("DVB-S2"): self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system) self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active self.scan_sat.system.setValue(eDVBFrontendParametersSatellite.System_DVB_S) self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan])) self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency)) self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion)) self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate)) self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization)) if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) elif self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S2: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2)) self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation) self.list.append(self.modulationEntry) self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff)) self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) elif self.scan_type.getValue() == "single_satellite": self.updateSatList() print self.scan_satselection[index_to_scan] self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan])) self.scan_networkScan.setValue(True) elif self.scan_type.getValue().find("multisat") != -1: tlist = [] SatList = nimmanager.getSatListForNim(index_to_scan) for x in SatList: if self.Satexists(tlist, x[0]) == 0: tlist.append(x[0]) sat = ConfigEnableDisable(default = self.scan_type.getValue().find("_yes") != -1 and True or False) configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat) self.list.append(configEntry) self.multiscanlist.append((x[0], sat)) self.scan_networkScan.setValue(True) elif nim.isCompatible("DVB-C"): if self.scan_typecable.getValue() == "single_transponder": self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency)) self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion)) self.list.append(getConfigListEntry(_("Symbol rate"), self.scan_cab.symbolrate)) self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation)) self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec)) if config.Nims[index_to_scan].cable.scan_networkid.getValue(): self.networkid = config.Nims[index_to_scan].cable.scan_networkid.getValue() self.scan_networkScan.setValue(True) elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.getValue() == "single_transponder": if nim.isCompatible("DVB-T2"): self.systemEntry = getConfigListEntry(_('System'), self.scan_ter.system) self.list.append(self.systemEntry) else: self.scan_ter.system.value = eDVBFrontendParametersTerrestrial.System_DVB_T self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth)) self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh)) self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow)) self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation)) self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission)) self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard)) self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy)) if self.scan_ter.system.value == eDVBFrontendParametersTerrestrial.System_DVB_T2: self.list.append(getConfigListEntry(_('PLP ID'), self.scan_ter.plp_id)) self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan)) self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) self.list.append(getConfigListEntry(_("Only free scan"), self.scan_onlyfree)) self["config"].list = self.list self["config"].l.setList(self.list) def Satexists(self, tlist, pos): for x in tlist: if x == pos: return 1 return 0 def newConfig(self): cur = self["config"].getCurrent() print "cur is", cur if cur == self.typeOfScanEntry or \ cur == self.tunerEntry or \ cur == self.systemEntry or \ (self.modulationEntry and self.systemEntry[1].getValue() == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry): self.createSetup() def createConfig(self, frontendData): defaultSat = { "orbpos": 192, "system": eDVBFrontendParametersSatellite.System_DVB_S, "frequency": 11836, "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown, "symbolrate": 27500, "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal, "fec": eDVBFrontendParametersSatellite.FEC_Auto, "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10, "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK } defaultCab = { "frequency": 466, "inversion": eDVBFrontendParametersCable.Inversion_Unknown, "modulation": eDVBFrontendParametersCable.Modulation_QAM64, "fec": eDVBFrontendParametersCable.FEC_Auto, "symbolrate": 6900, "system": eDVBFrontendParametersCable.System_DVB_C_ANNEX_A } defaultTer = { "frequency" : 466000, "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown, "bandwidth" : 7000000, "fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto, "feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto, "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto, "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto, "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto, "system": eDVBFrontendParametersTerrestrial.System_DVB_T, "plp_id": 0 } if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S) defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000 defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown) defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal) if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2: defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35) defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown) else: defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) elif ttype == "DVB-C": defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000 defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown) defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto) defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16) defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersCable.System_DVB_C_ANNEX_A) elif ttype == "DVB-T": defaultTer["frequency"] = frontendData.get("frequency", 0) defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown) defaultTer["bandwidth"] = frontendData.get("bandwidth", 7000000) defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto) defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto) defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto) defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto) defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto) defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto) defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersTerrestrial.System_DVB_T) self.scan_sat = ConfigSubsection() self.scan_cab = ConfigSubsection() self.scan_ter = ConfigSubsection() self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat"))]) self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))]) self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))]) self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))]) self.scan_onlyfree = ConfigYesNo(default = False) self.scan_networkScan = ConfigYesNo(default = False) nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: if n.config_mode == "nothing": continue if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue if n.config_mode in ("loopthrough", "satposdepends"): root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.getValue())) if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa continue nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices = nim_list) # status self.scan_snr = ConfigSlider() self.scan_snr.enabled = False self.scan_agc = ConfigSlider() self.scan_agc.enabled = False self.scan_ber = ConfigSlider() self.scan_ber.enabled = False # sat self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [ (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")), (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]) self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999)) self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [ (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")), (eDVBFrontendParametersSatellite.Inversion_On, _("On")), (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))]) self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999)) self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [ (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")), (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")), (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")), (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))]) self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [ (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")), (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), (eDVBFrontendParametersSatellite.FEC_None, _("None"))]) self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [ (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"), (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"), (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"), (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")]) self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [ (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"), (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")]) self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [ (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"), (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"), (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20"), (eDVBFrontendParametersSatellite.RollOff_auto, _("Auto"))]) self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [ (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")), (eDVBFrontendParametersSatellite.Pilot_On, _("On")), (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))]) # cable self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999)) self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [ (eDVBFrontendParametersCable.Inversion_Off, _("Off")), (eDVBFrontendParametersCable.Inversion_On, _("On")), (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))]) self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [ (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"), (eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"), (eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"), (eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"), (eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")]) self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [ (eDVBFrontendParametersCable.FEC_Auto, _("Auto")), (eDVBFrontendParametersCable.FEC_1_2, "1/2"), (eDVBFrontendParametersCable.FEC_2_3, "2/3"), (eDVBFrontendParametersCable.FEC_3_4, "3/4"), (eDVBFrontendParametersCable.FEC_5_6, "5/6"), (eDVBFrontendParametersCable.FEC_6_7, "6/7"), (eDVBFrontendParametersCable.FEC_7_8, "7/8"), (eDVBFrontendParametersCable.FEC_8_9, "8/9"), (eDVBFrontendParametersCable.FEC_None, _("None"))]) self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999)) self.scan_cab.system = ConfigSelection(default = defaultCab["system"], choices = [ (eDVBFrontendParametersCable.System_DVB_C_ANNEX_A, _("DVB-C")), (eDVBFrontendParametersCable.System_DVB_C_ANNEX_C, _("DVB-C ANNEX C"))]) # terrestial self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000)) self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [ (eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")), (eDVBFrontendParametersTerrestrial.Inversion_On, _("On")), (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))]) # WORKAROUND: we can't use BW-auto self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [ (10000000, "10MHz"), (8000000, "8MHz"), (7000000, "7MHz"), (6000000, "6MHz"), (5000000, "5MHz"), (1712000, "1.712MHz") ]) #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto")))) self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [ (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [ (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [ (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"), (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"), (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"), (eDVBFrontendParametersTerrestrial.Modulation_QAM256, "QAM256"), (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_4k, "4K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))]) self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [ (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"), (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))]) self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [ (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")), (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"), (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"), (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"), (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))]) self.scan_ter.system = ConfigSelection(default = defaultTer["system"], choices = [ (eDVBFrontendParametersTerrestrial.System_DVB_T, _("DVB-T")), (eDVBFrontendParametersTerrestrial.System_DVB_T2, _("DVB-T2"))]) self.scan_ter.plp_id = ConfigInteger(default = defaultTer["plp_id"], limits = (0, 255)) self.scan_scansat = {} for sat in nimmanager.satList: #print sat[1] self.scan_scansat[sat[0]] = ConfigYesNo(default = False) self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot])) else: self.scan_satselection.append(None) return True def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() def updateStatus(self): print "updatestatus" def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot): print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) print "orbpos: " + str(orbital_position) parm = eDVBFrontendParametersSatellite() parm.modulation = modulation parm.system = system parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.polarisation = polarisation parm.fec = fec parm.inversion = inversion parm.orbital_position = orbital_position parm.rolloff = rolloff parm.pilot = pilot tlist.append(parm) def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion): print "Add Cab: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(modulation) + " fec: " + str(fec) + " inversion: " + str(inversion) parm = eDVBFrontendParametersCable() parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.modulation = modulation parm.fec = fec parm.inversion = inversion tlist.append(parm) def addTerTransponder(self, tlist, *args, **kwargs): tlist.append(buildTerTransponder(*args, **kwargs)) def keyGo(self): infoBarInstance = InfoBar.instance if infoBarInstance: infoBarInstance.checkTimeshiftRunning(self.keyGoCheckTimeshiftCallback) else: self.keyGoCheckTimeshiftCallback(True) def keyGoCheckTimeshiftCallback(self, answer): if not answer or self.scan_nims.value == "": return tlist = [] flags = None startScan = True removeAll = True index_to_scan = int(self.scan_nims.getValue()) if self.scan_nims == [ ]: self.session.open(MessageBox, _("No tuner is enabled!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) return nim = nimmanager.nim_slots[index_to_scan] print "nim", nim.slot if nim.isCompatible("DVB-S"): print "is compatible with DVB-S" if self.scan_type.getValue() == "single_transponder": # these lists are generated for each tuner, so this has work. assert len(self.satList) > index_to_scan assert len(self.scan_satselection) > index_to_scan nimsats = self.satList[index_to_scan] selsatidx = self.scan_satselection[index_to_scan].index # however, the satList itself could be empty. in that case, "index" is 0 (for "None"). if len(nimsats): orbpos = nimsats[selsatidx][0] if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.getValue() else: fec = self.scan_sat.fec_s2.getValue() print "add sat transponder" self.addSatTransponder(tlist, self.scan_sat.frequency.getValue(), self.scan_sat.symbolrate.getValue(), self.scan_sat.polarization.getValue(), fec, self.scan_sat.inversion.getValue(), orbpos, self.scan_sat.system.getValue(), self.scan_sat.modulation.getValue(), self.scan_sat.rolloff.getValue(), self.scan_sat.pilot.getValue()) removeAll = False elif self.scan_type.getValue() == "single_satellite": sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] getInitialTransponderList(tlist, sat[0]) elif self.scan_type.getValue().find("multisat") != -1: SatList = nimmanager.getSatListForNim(index_to_scan) for x in self.multiscanlist: if x[1].getValue(): print " " + str(x[0]) getInitialTransponderList(tlist, x[0]) elif nim.isCompatible("DVB-C"): if self.scan_typecable.getValue() == "single_transponder": self.addCabTransponder(tlist, self.scan_cab.frequency.getValue(), self.scan_cab.symbolrate.getValue(), self.scan_cab.modulation.getValue(), self.scan_cab.fec.getValue(), self.scan_cab.inversion.getValue()) removeAll = False elif self.scan_typecable.getValue() == "complete": if config.Nims[index_to_scan].cable.scan_type.getValue() == "provider": getInitialCableTransponderList(tlist, index_to_scan) else: startScan = False elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.getValue() == "single_transponder": self.addTerTransponder(tlist, self.scan_ter.frequency.getValue() * 1000, inversion = self.scan_ter.inversion.getValue(), bandwidth = self.scan_ter.bandwidth.getValue(), fechigh = self.scan_ter.fechigh.getValue(), feclow = self.scan_ter.feclow.getValue(), modulation = self.scan_ter.modulation.getValue(), transmission = self.scan_ter.transmission.getValue(), guard = self.scan_ter.guard.getValue(), hierarchy = self.scan_ter.hierarchy.getValue(), system = self.scan_ter.system.getValue(), plpid = self.scan_ter.plp_id.getValue()) removeAll = False elif self.scan_typeterrestrial.getValue() == "complete": getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan)) flags = self.scan_networkScan.getValue() and eComponentScan.scanNetworkSearch or 0 tmp = self.scan_clearallservices.getValue() if tmp == "yes": flags |= eComponentScan.scanRemoveServices elif tmp == "yes_hold_feeds": flags |= eComponentScan.scanRemoveServices flags |= eComponentScan.scanDontRemoveFeeds if tmp != "no" and not removeAll: flags |= eComponentScan.scanDontRemoveUnscanned if self.scan_onlyfree.getValue(): flags |= eComponentScan.scanOnlyFree for x in self["config"].list: x[1].save() if startScan: self.startScan(tlist, flags, index_to_scan, self.networkid) else: self.flags = flags self.feid = index_to_scan self.tlist = [] self.startCableTransponderSearch(self.feid) def setCableTransponderSearchResult(self, tlist): self.tlist = tlist def cableTransponderSearchFinished(self): if self.tlist is None: self.tlist = [] else: self.startScan(self.tlist, self.flags, self.feid) def startScan(self, tlist, flags, feid, networkid = 0): if len(tlist): # flags |= eComponentScan.scanSearchBAT if self.finished_cb: self.session.openWithCallback(self.finished_cb, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}]) else: self.session.open(ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}]) else: if self.finished_cb: self.session.openWithCallback(self.finished_cb, MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) else: self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) def keyCancel(self): self.session.nav.playService(self.session.postScanService) for x in self["config"].list: x[1].cancel() self.close() def doCloseRecursive(self): self.session.nav.playService(self.session.postScanService) self.closeRecursive()
class TimeshiftSettings(Screen,ConfigListScreen): skin = """ <screen name="RecordPathsSettings" position="160,150" size="450,200" title="Recording paths"> <ePixmap pixmap="skin_default/buttons/red.png" position="10,0" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/green.png" position="300,0" size="140,40" alphatest="on" /> <widget source="key_red" render="Label" position="10,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" /> <widget source="key_green" render="Label" position="300,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" /> <widget name="config" position="10,44" size="430,146" /> </screen>""" def __init__(self, session): from Components.Sources.StaticText import StaticText Screen.__init__(self, session) self.skinName = "Setup" self.setup_title = _("Timeshift settings") Screen.setTitle(self, _(self.setup_title)) self["status"] = StaticText() self['footnote'] = Label(_("* = Restart timeshift required")) self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self.onChangedEntry = [ ] self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry) self.createSetup() self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], { "green": self.keySave, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, }, -2) if not self.SelectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.SelectionChanged) # for summary: def changedEntry(self): if (self["config"].getCurrent()[0] == _("Permanent Timeshift Enable") or self["config"].getCurrent()[0] == _("Timeshift Enable")): self.createSetup() if self["config"].getCurrent()[0] == _("Timeshift location"): self.checkReadWriteDir(self["config"].getCurrent()[1]) for x in self.onChangedEntry: x() def getCurrentEntry(self): return self["config"].getCurrent()[0] def getCurrentValue(self): return str(self["config"].getCurrent()[1].getText()) def checkReadWriteDir(self, configele): import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions(False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append((partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint(os.path.realpath(configele.getValue()))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(configele.getValue())) in locations: if fileExists(configele.getValue(), "w"): configele.last_value = configele.getValue() return True else: dir = configele.getValue() configele.setValue(configele.last_value) self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead.")%dir, type = MessageBox.TYPE_ERROR ) return False else: dir = configele.getValue() configele.setValue(configele.last_value) self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%dir, type = MessageBox.TYPE_ERROR ) return False else: dir = configele.getValue() configele.setValue(configele.last_value) self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%dir, type = MessageBox.TYPE_ERROR ) return False def createSetup(self): default = config.usage.timeshift_path.getValue() tmp = config.usage.allowed_timeshift_paths.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) print "TimeshiftPath: ", default, tmp self.timeshift_dirname = ConfigSelection(default = default, choices = tmp) self.timeshift_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.list = [] self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname, _("Set the default location for your timeshift-files. Press 'OK' to add new locations, select left/right to select an existing location.")) self.list.append(self.timeshift_entry) self.list.append(getConfigListEntry(_("Timeshift Enable"), config.timeshift.pauzekeyenabled, _("Enable or disable Timeshift. When activated, you can wind back until the time you zapped to a channel, and you can make recordings in retrospect."))) self.list.append(getConfigListEntry(_("Permanent Timeshift Enable"), config.timeshift.enabled, _("Enable or disable Permanent Timeshift. When activated, you can wind back until the time you zapped to a channel, and you can make recordings in retrospect."))) if config.usage.setup_level.index >= 2 and config.timeshift.enabled.getValue(): self.list.append(getConfigListEntry(_("Permanent Timeshift Max Events"), config.timeshift.maxevents, _("Set the maximum number of events (programs) that timeshift may handle."))) self.list.append(getConfigListEntry(_("Permanent Timeshift Max Length"), config.timeshift.maxlength, _("Set the maximum length a timeshift file may be."))) self.list.append(getConfigListEntry(_("Permanent Timeshift Start Delay"), config.timeshift.startdelay, _("Timeshift will only start when the start delay time has passed. This prevents numurous very short files when zapping."))) self.list.append(getConfigListEntry(_("Stop timeshift while recording?"), config.timeshift.stopwhilerecording, _("Select if timeshift must continue when set to record."))) self.list.append(getConfigListEntry(_("Timeshift-Save Action on zap"), config.timeshift.favoriteSaveAction, _("Set what the required action must be when zapping while a timeshift has been set as recording."))) self.list.append(getConfigListEntry(_("Use PTS seekbar while timeshifting? *"), config.timeshift.showinfobar, _("If set to 'yes' a special seekbar is available during timeshift."))) self["config"].setList(self.list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def SelectionChanged(self): self["status"].setText(self["config"].getCurrent()[2]) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.getValue() self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.getValue() if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.setValue(self.timeshift_dirname.getValue()) self.session.openWithCallback( self.dirnameSelected, TimeshiftLocationBox ) def dirnameSelected(self, res): if res is not None: import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions(False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append((partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint(os.path.realpath(res))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(res)) in locations: self.entrydirname.setValue(res) if config.usage.allowed_timeshift_paths.getValue() != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.getValue() default = self.timeshift_dirname.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.setValue(res) else: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%res, type = MessageBox.TYPE_ERROR ) else: self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%res, type = MessageBox.TYPE_ERROR ) def saveAll(self): for x in self["config"].list: x[1].save() configfile.save() # keySave and keyCancel are just provided in case you need them. # you have to call them by yourself. def keySave(self): import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs')) candidates = [] mounts = Components.Harddisk.getProcMounts() for partition in Components.Harddisk.harddiskmanager.getMountedPartitions(False, mounts): if partition.filesystem(mounts) in supported_filesystems: candidates.append((partition.description, partition.mountpoint)) if candidates: locations = [] for validdevice in candidates: locations.append(validdevice[1]) if Components.Harddisk.findMountPoint(os.path.realpath(config.usage.timeshift_path.getValue()))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(config.usage.timeshift_path.getValue())) in locations: config.usage.timeshift_path.setValue(self.timeshift_dirname.getValue()) config.usage.timeshift_path.save() self.saveAll() self.close() else: if config.timeshift.enabled.getValue(): self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%config.usage.timeshift_path.getValue(), type = MessageBox.TYPE_ERROR ) else: config.timeshift.enabled.setValue(False) self.saveAll() self.close() else: if config.timeshift.enabled.getValue(): self.session.open( MessageBox, _("The directory %s is not a EXT2, EXT3, EXT4 or NFS partition.\nMake sure you select a valid partition type.")%config.usage.timeshift_path.getValue(), type = MessageBox.TYPE_ERROR ) else: config.timeshift.enabled.setValue(False) self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?")) else: self.close() def createSummary(self): from Screens.Setup import SetupSummary return SetupSummary
class InstallWizard(Screen, ConfigListScreen): STATE_UPDATE = 0 STATE_CHOISE_CHANNELLIST = 1 # STATE_CHOISE_SOFTCAM = 2 def __init__(self, session, args = None): Screen.__init__(self, session) self.index = args self.list = [] ConfigListScreen.__init__(self, self.list) if self.index == self.STATE_UPDATE: config.misc.installwizard.hasnetwork.setValue(False) config.misc.installwizard.ipkgloaded.setValue(False) modes = {0: " "} self.enabled = ConfigSelection(choices = modes, default = 0) self.adapters = [(iNetwork.getFriendlyAdapterName(x),x) for x in iNetwork.getAdapterList()] is_found = False for x in self.adapters: if x[1] == 'eth0': if iNetwork.getAdapterAttribute(x[1], 'up'): self.ipConfigEntry = ConfigIP(default = iNetwork.getAdapterAttribute(x[1], "ip")) iNetwork.checkNetworkState(self.checkNetworkCB) if_found = True else: iNetwork.restartNetwork(self.checkNetworkLinkCB) break if is_found is False: self.createMenu() elif self.index == self.STATE_CHOISE_CHANNELLIST: self.enabled = ConfigYesNo(default = True) modes = {"AAF": "AAF default(13e-19e)", "19e": "Astra 1", "23e": "Astra 3", "19e-23e": "Astra 1 Astra 3", "19e-23e-28e": "Astra 1 Astra 2 Astra 3", "13e-19e-23e-28e": "Astra 1 Astra 2 Astra 3 Hotbird"} self.channellist_type = ConfigSelection(choices = modes, default = "AAF") self.createMenu() # elif self.index == self.STATE_CHOISE_SOFTCAM: # self.enabled = ConfigYesNo(default = True) # modes = {"cccam": _("default") + " (CCcam)", "scam": "scam"} # self.softcam_type = ConfigSelection(choices = modes, default = "cccam") # self.createMenu() def checkNetworkCB(self, data): if data < 3: config.misc.installwizard.hasnetwork.setValue(True) self.createMenu() def checkNetworkLinkCB(self, retval): if retval: iNetwork.checkNetworkState(self.checkNetworkCB) else: self.createMenu() def createMenu(self): try: test = self.index except: return self.list = [] if self.index == self.STATE_UPDATE: if config.misc.installwizard.hasnetwork.getValue(): self.list.append(getConfigListEntry(_("Your internet connection is working (ip: %s)") % (self.ipConfigEntry.getText()), self.enabled)) else: self.list.append(getConfigListEntry(_("Your receiver does not have an internet connection"), self.enabled)) elif self.index == self.STATE_CHOISE_CHANNELLIST: self.list.append(getConfigListEntry(_("Install channel list"), self.enabled)) if self.enabled.getValue(): self.list.append(getConfigListEntry(_("Channel list type"), self.channellist_type)) # elif self.index == self.STATE_CHOISE_SOFTCAM: # self.list.append(getConfigListEntry(_("Install softcam"), self.enabled)) # if self.enabled.value: # self.list.append(getConfigListEntry(_("Softcam type"), self.softcam_type)) self["config"].list = self.list self["config"].l.setList(self.list) def keyLeft(self): if self.index == 0: return ConfigListScreen.keyLeft(self) self.createMenu() def keyRight(self): if self.index == 0: return ConfigListScreen.keyRight(self) self.createMenu() def run(self): if self.index == self.STATE_UPDATE: if config.misc.installwizard.hasnetwork.getValue(): self.session.open(InstallWizardIpkgUpdater, self.index, _('Please wait (updating packages)'), IpkgComponent.CMD_UPDATE) elif self.index == self.STATE_CHOISE_CHANNELLIST and self.enabled.getValue() and self.channellist_type.getValue() != "AAF": self.session.open(InstallWizardIpkgUpdater, self.index, _('Please wait (downloading channel list)'), IpkgComponent.CMD_REMOVE, {'package': 'enigma2-plugin-settings-henksat-' + self.channellist_type.getValue()}) # elif self.index == self.STATE_CHOISE_SOFTCAM and self.enabled.value: # self.session.open(InstallWizardIpkgUpdater, self.index, _('Please wait (downloading softcam)'), IpkgComponent.CMD_INSTALL, {'package': 'enigma2-plugin-softcams-' + self.softcam_type.value}) return
class OSD3DSetupScreen(Screen, ConfigListScreen): skin = """ <screen position="c-200,c-100" size="400,200" title="OSD 3D setup"> <widget name="config" position="c-175,c-75" size="350,150" /> <ePixmap pixmap="skin_default/buttons/green.png" position="c-145,e-45" zPosition="0" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/red.png" position="c+5,e-45" zPosition="0" size="140,40" alphatest="on" /> <widget name="ok" position="c-145,e-45" size="140,40" valign="center" halign="center" zPosition="1" font="Regular;20" transparent="1" backgroundColor="green" /> <widget name="cancel" position="c+5,e-45" size="140,40" valign="center" halign="center" zPosition="1" font="Regular;20" transparent="1" backgroundColor="red" /> </screen>""" def __init__(self, session): self.skin = OSD3DSetupScreen.skin Screen.__init__(self, session) from Components.ActionMap import ActionMap from Components.Button import Button self["ok"] = Button(_("OK")) self["cancel"] = Button(_("Cancel")) self["actions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "green": self.keyGo, "red": self.keyCancel, "menu": self.closeRecursive, }, -2) self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session) mode = config.plugins.OSD3DSetup.mode.getValue() znorm = config.plugins.OSD3DSetup.znorm.getValue() self.mode = ConfigSelection(choices = modelist, default = mode) self.znorm = ConfigSlider(default = znorm + 50, increment = 1, limits = (0, 100)) self.list.append(getConfigListEntry(_("3d mode"), self.mode)) self.list.append(getConfigListEntry(_("Depth"), self.znorm)) self["config"].list = self.list self["config"].l.setList(self.list) def keyLeft(self): ConfigListScreen.keyLeft(self) self.setPreviewSettings() def keyRight(self): ConfigListScreen.keyRight(self) self.setPreviewSettings() def setPreviewSettings(self): applySettings(self.mode.getValue(), int(self.znorm.getValue()) - 50) def keyGo(self): config.plugins.OSD3DSetup.mode.value = self.mode.getValue() config.plugins.OSD3DSetup.znorm.value = int(self.znorm.getValue()) - 50 config.plugins.OSD3DSetup.save() self.close() def keyCancel(self): setConfiguredSettings() self.close()
class RecordingSettings(Screen,ConfigListScreen): def removeNotifier(self): config.usage.setup_level.notifiers.remove(self.levelChanged) def levelChanged(self, configElement): list = [] self.refill(list) self["config"].setList(list) def refill(self, list): xmldata = setupdom().getroot() for x in xmldata.findall("setup"): if x.get("key") != self.setup: continue self.addItems(list, x) self.setup_title = x.get("title", "").encode("UTF-8") self.seperation = int(x.get('separation', '0')) def __init__(self, session): from Components.Sources.StaticText import StaticText Screen.__init__(self, session) self.skinName = "Setup" self['footnote'] = Label() self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self["VKeyIcon"] = Boolean(False) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self["description"] = Label(_("")) self.onChangedEntry = [ ] self.setup = "recording" list = [] ConfigListScreen.__init__(self, list, session = session, on_change = self.changedEntry) self.createSetup() self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "green": self.keySave, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, "menu": self.closeRecursive, }, -2) self.onLayoutFinish.append(self.layoutFinished) def checkReadWriteDir(self, configele): # print "checkReadWrite: ", configele.getValue() if configele.getValue() in [x[0] for x in self.styles] or fileExists(configele.value, "w"): configele.last_value = configele.getValue() return True else: dir = configele.getValue() configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead.")%dir, type = MessageBox.TYPE_ERROR ) return False def createSetup(self): self.styles = [ ("<default>", _("<Default movie location>")), ("<current>", _("<Current movielist location>")), ("<timer>", _("<Last timer location>")) ] styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.getValue() default = config.usage.default_path.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) # print "DefaultPath: ", default, tmp self.default_dirname = ConfigSelection(default = default, choices = tmp) tmp = config.movielist.videodirs.getValue() default = config.usage.timer_path.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) # print "TimerPath: ", default, tmp self.timer_dirname = ConfigSelection(default = default, choices = self.styles+tmp) tmp = config.movielist.videodirs.getValue() default = config.usage.instantrec_path.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) # print "InstantrecPath: ", default, tmp self.instantrec_dirname = ConfigSelection(default = default, choices = self.styles+tmp) self.default_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.timer_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.instantrec_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) list = [] if config.usage.setup_level.index >= 2: self.default_entry = getConfigListEntry(_("Default movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer recording location"), self.timer_dirname, _("Set the default location for your timers. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry(_("Instant recording location"), self.instantrec_dirname, _("Set the default location for your instant recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location.")) list.append(self.default_entry) self.refill(list) self["config"].setList(list) if config.usage.sort_settings.getValue(): self["config"].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) # for summary: def changedEntry(self): self.item = self["config"].getCurrent() if self["config"].getCurrent()[0] == _("Default movie location") or self["config"].getCurrent()[0] == _("Timer record location") or self["config"].getCurrent()[0] == _("Instant record location") or self["config"].getCurrent()[0] == _("Movie location"): self.checkReadWriteDir(self["config"].getCurrent()[1]) for x in self.onChangedEntry: x() try: if isinstance(self["config"].getCurrent()[1], ConfigYesNo) or isinstance(self["config"].getCurrent()[1], ConfigSelection): self.createSetup() except: pass def getCurrentEntry(self): return self["config"].getCurrent() and self["config"].getCurrent()[0] or "" def getCurrentValue(self): return self["config"].getCurrent() and str(self["config"].getCurrent()[1].getText()) or "" def getCurrentDescription(self): return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or "" def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.getValue() self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.getValue() if config.usage.setup_level.index >= 2: txt = _("Default movie location") else: txt = _("Movie location") if currentry == self.default_entry: self.entrydirname = self.default_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, txt, preferredPath(self.default_dirname.getValue()) ) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("New timers location"), preferredPath(self.timer_dirname.getValue()) ) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Instant recordings location"), preferredPath(self.instantrec_dirname.getValue()) ) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.getValue() != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.getValue() default = self.default_dirname.getValue() if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.getValue() default = self.timer_dirname.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.timer_dirname.setChoices(self.styles+tmp, default=default) tmp = config.movielist.videodirs.getValue() default = self.instantrec_dirname.getValue() if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.instantrec_dirname.setChoices(self.styles+tmp, default=default) self.entrydirname.value = res if self.entrydirname.last_value != res: self.checkReadWriteDir(self.entrydirname) def saveAll(self): currentry = self["config"].getCurrent() config.usage.default_path.value = self.default_dirname.getValue() config.usage.timer_path.value = self.timer_dirname.getValue() config.usage.instantrec_path.value = self.instantrec_dirname.getValue() config.usage.default_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() for x in self["config"].list: x[1].save() configfile.save() # keySave and keyCancel are just provided in case you need them. # you have to call them by yourself. def keySave(self): self.saveAll() self.close() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() self.close() def keyCancel(self): if self["config"].isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"), default = False) else: self.close() def createSummary(self): return SetupSummary def addItems(self, list, parentNode): for x in parentNode: if not x.tag: continue if x.tag == 'item': item_level = int(x.get("level", 0)) if not self.levelChanged in config.usage.setup_level.notifiers: config.usage.setup_level.notifiers.append(self.levelChanged) self.onClose.append(self.removeNotifier) if item_level > config.usage.setup_level.index: continue requires = x.get("requires") if requires and requires.startswith('config.'): item = eval(requires or "") if item.getValue() and not item.getValue() == "0": SystemInfo[requires] = True else: SystemInfo[requires] = False if requires and not SystemInfo.get(requires, False): continue item_text = _(x.get("text", "??").encode("UTF-8")) item_description = _(x.get("description", " ").encode("UTF-8")) b = eval(x.text or "") if b == "": continue #add to configlist item = b # the first b is the item itself, ignored by the configList. # the second one is converted to string. if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): def __init__(self, session): Screen.__init__(self, session) Screen.setTitle(self, _("Manual Scan")) self.finished_cb = None self.updateSatList() self.service = session.nav.getCurrentService() self.feinfo = None self.networkid = 0 frontendData = None if self.service is not None: self.feinfo = self.service.frontendInfo() frontendData = self.feinfo and self.feinfo.getAll(True) self.createConfig(frontendData) del self.feinfo del self.service self.session.postScanService = session.nav.getCurrentlyPlayingServiceOrGroup() self["key_red"] = StaticText(_("Close")) self["key_green"] = StaticText(_("Scan")) self["actions"] = NumberActionMap(["SetupActions", "MenuActions", "ColorActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "red": self.keyCancel, "green": self.keyGo, "menu": self.doCloseRecursive, }, -2) self.statusTimer = eTimer() self.statusTimer.callback.append(self.updateStatus) #self.statusTimer.start(5000, True) self.list = [] ConfigListScreen.__init__(self, self.list) self["header"] = Label(_("Manual Scan")) if not self.scan_nims.getValue() == "": self.createSetup() self["introduction"] = Label(_("Press OK to start the scan")) else: self["introduction"] = Label(_("Nothing to scan!\nPlease setup your tuner settings before you start a service scan.")) def runAsync(self, finished_cb): self.finished_cb = finished_cb self.keyGo() def updateSatList(self): self.satList = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.satList.append(nimmanager.getSatListForNim(slot.slot)) else: self.satList.append(None) def createSetup(self): self.list = [] self.multiscanlist = [] index_to_scan = int(self.scan_nims.getValue()) print "ID: ", index_to_scan self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) if self.scan_nims == [ ]: return self.typeOfScanEntry = None self.systemEntry = None self.modulationEntry = None nim = nimmanager.nim_slots[index_to_scan] if nim.isCompatible("DVB-S"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-C"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typecable) self.list.append(self.typeOfScanEntry) elif nim.isCompatible("DVB-T"): self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial) self.list.append(self.typeOfScanEntry) self.scan_networkScan.setValue(False) if nim.isCompatible("DVB-S"): if self.scan_type.getValue() == "single_transponder": self.updateSatList() if nim.isCompatible("DVB-S2"): self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system) self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active self.scan_sat.system.setValue(eDVBFrontendParametersSatellite.System_DVB_S) self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan])) self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency)) self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion)) self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate)) self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization)) if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) elif self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S2: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2)) self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation) self.list.append(self.modulationEntry) self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff)) self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) elif self.scan_type.getValue() == "single_satellite": self.updateSatList() print self.scan_satselection[index_to_scan] self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan])) self.scan_networkScan.setValue(True) elif self.scan_type.getValue().find("multisat") != -1: tlist = [] SatList = nimmanager.getSatListForNim(index_to_scan) for x in SatList: if self.Satexists(tlist, x[0]) == 0: tlist.append(x[0]) sat = ConfigEnableDisable(default = self.scan_type.getValue().find("_yes") != -1 and True or False) configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat) self.list.append(configEntry) self.multiscanlist.append((x[0], sat)) self.scan_networkScan.setValue(True) elif nim.isCompatible("DVB-C"): if self.scan_typecable.getValue() == "single_transponder": self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency)) self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion)) self.list.append(getConfigListEntry(_("Symbol rate"), self.scan_cab.symbolrate)) self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation)) self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec)) if config.Nims[index_to_scan].cable.scan_networkid.getValue(): self.networkid = config.Nims[index_to_scan].cable.scan_networkid.getValue() self.scan_networkScan.setValue(True) elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.getValue() == "single_transponder": self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency)) self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion)) self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth)) self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh)) self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow)) self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation)) self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission)) self.list.append(getConfigListEntry(_("Guard interval"), self.scan_ter.guard)) self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy)) self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan)) self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices)) self.list.append(getConfigListEntry(_("Only free scan"), self.scan_onlyfree)) self["config"].list = self.list self["config"].l.setList(self.list) def Satexists(self, tlist, pos): for x in tlist: if x == pos: return 1 return 0 def newConfig(self): cur = self["config"].getCurrent() print "cur is", cur if cur == self.typeOfScanEntry or \ cur == self.tunerEntry or \ cur == self.systemEntry or \ (self.modulationEntry and self.systemEntry[1].getValue() == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry): self.createSetup() def createConfig(self, frontendData): defaultSat = { "orbpos": 192, "system": eDVBFrontendParametersSatellite.System_DVB_S, "frequency": 11836, "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown, "symbolrate": 27500, "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal, "fec": eDVBFrontendParametersSatellite.FEC_Auto, "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10, "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK } defaultCab = { "frequency": 466, "inversion": eDVBFrontendParametersCable.Inversion_Unknown, "modulation": eDVBFrontendParametersCable.Modulation_QAM64, "fec": eDVBFrontendParametersCable.FEC_Auto, "symbolrate": 6900, "system": eDVBFrontendParametersCable.System_DVB_C_ANNEX_A } defaultTer = { "frequency" : 466000, "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown, "bandwidth" : 7000000, "fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto, "feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto, "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto, "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto, "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto, "system": eDVBFrontendParametersTerrestrial.System_DVB_T } if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S) defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000 defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown) defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal) if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2: defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35) defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown) else: defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) elif ttype == "DVB-C": defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000 defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown) defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto) defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16) defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersCable.System_DVB_C_ANNEX_A) elif ttype == "DVB-T": defaultTer["frequency"] = frontendData.get("frequency", 0) defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown) defaultTer["bandwidth"] = frontendData.get("bandwidth", 7000000) defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto) defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto) defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto) defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto) defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto) defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto) defaultTer["system"] = frontendData.get("system", eDVBFrontendParametersTerrestrial.System_DVB_T) self.scan_sat = ConfigSubsection() self.scan_cab = ConfigSubsection() self.scan_ter = ConfigSubsection() self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat"))]) self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))]) self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))]) self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))]) self.scan_onlyfree = ConfigYesNo(default = False) self.scan_networkScan = ConfigYesNo(default = False) nim_list = [] # collect all nims which are *not* set to "nothing" for n in nimmanager.nim_slots: if n.config_mode == "nothing": continue if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1: continue if n.config_mode in ("loopthrough", "satposdepends"): root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.getValue())) if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa continue nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices = nim_list) # status self.scan_snr = ConfigSlider() self.scan_snr.enabled = False self.scan_agc = ConfigSlider() self.scan_agc.enabled = False self.scan_ber = ConfigSlider() self.scan_ber.enabled = False # sat self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [ (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")), (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]) self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999)) self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [ (eDVBFrontendParametersSatellite.Inversion_Off, _("Off")), (eDVBFrontendParametersSatellite.Inversion_On, _("On")), (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))]) self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999)) self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [ (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")), (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")), (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")), (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))]) self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [ (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")), (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), (eDVBFrontendParametersSatellite.FEC_None, _("None"))]) self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [ (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"), (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"), (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"), (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")]) self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [ (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"), (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")]) self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [ (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"), (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"), (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20"), (eDVBFrontendParametersSatellite.RollOff_auto, _("Auto"))]) self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [ (eDVBFrontendParametersSatellite.Pilot_Off, _("Off")), (eDVBFrontendParametersSatellite.Pilot_On, _("On")), (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))]) # cable self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999)) self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [ (eDVBFrontendParametersCable.Inversion_Off, _("Off")), (eDVBFrontendParametersCable.Inversion_On, _("On")), (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))]) self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [ (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"), (eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"), (eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"), (eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"), (eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")]) self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [ (eDVBFrontendParametersCable.FEC_Auto, _("Auto")), (eDVBFrontendParametersCable.FEC_1_2, "1/2"), (eDVBFrontendParametersCable.FEC_2_3, "2/3"), (eDVBFrontendParametersCable.FEC_3_4, "3/4"), (eDVBFrontendParametersCable.FEC_5_6, "5/6"), (eDVBFrontendParametersCable.FEC_6_7, "6/7"), (eDVBFrontendParametersCable.FEC_7_8, "7/8"), (eDVBFrontendParametersCable.FEC_8_9, "8/9"), (eDVBFrontendParametersCable.FEC_None, _("None"))]) self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999)) self.scan_cab.system = ConfigSelection(default = defaultCab["system"], choices = [ (eDVBFrontendParametersCable.System_DVB_C_ANNEX_A, _("DVB-C")), (eDVBFrontendParametersCable.System_DVB_C_ANNEX_C, _("DVB-C ANNEX C"))]) # terrestial self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000)) self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [ (eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")), (eDVBFrontendParametersTerrestrial.Inversion_On, _("On")), (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))]) # WORKAROUND: we can't use BW-auto self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [ (10000000, "10MHz"), (8000000, "8MHz"), (7000000, "7MHz"), (6000000, "6MHz"), (5000000, "5MHz"), (1712000, "1.712MHz") ]) #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto")))) self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [ (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [ (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), (eDVBFrontendParametersTerrestrial.FEC_6_7, "6/7"), (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), (eDVBFrontendParametersTerrestrial.FEC_8_9, "8/9"), (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [ (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"), (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"), (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"), (eDVBFrontendParametersTerrestrial.Modulation_QAM256, "QAM256"), (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_4k, "4K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))]) self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [ (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"), (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"), (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))]) self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [ (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")), (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"), (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"), (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"), (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))]) self.scan_ter.system = ConfigSelection(default = defaultTer["system"], choices = [ (eDVBFrontendParametersTerrestrial.System_DVB_T, _("DVB-T")), (eDVBFrontendParametersTerrestrial.System_DVB_T2, _("DVB-T2"))]) self.scan_scansat = {} for sat in nimmanager.satList: #print sat[1] self.scan_scansat[sat[0]] = ConfigYesNo(default = False) self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot])) else: self.scan_satselection.append(None) return True def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() def updateStatus(self): print "updatestatus" def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot): print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) print "orbpos: " + str(orbital_position) parm = eDVBFrontendParametersSatellite() parm.modulation = modulation parm.system = system parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.polarisation = polarisation parm.fec = fec parm.inversion = inversion parm.orbital_position = orbital_position parm.rolloff = rolloff parm.pilot = pilot tlist.append(parm) def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion): print "Add Cab: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(modulation) + " fec: " + str(fec) + " inversion: " + str(inversion) parm = eDVBFrontendParametersCable() parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.modulation = modulation parm.fec = fec parm.inversion = inversion tlist.append(parm) def addTerTransponder(self, tlist, *args, **kwargs): tlist.append(buildTerTransponder(*args, **kwargs)) def keyGo(self): infoBarInstance = InfoBar.instance if infoBarInstance: infoBarInstance.checkTimeshiftRunning(self.keyGoCheckTimeshiftCallback) else: self.keyGoCheckTimeshiftCallback(True) def keyGoCheckTimeshiftCallback(self, answer): if not answer or self.scan_nims.value == "": return tlist = [] flags = None startScan = True removeAll = True index_to_scan = int(self.scan_nims.getValue()) if self.scan_nims == [ ]: self.session.open(MessageBox, _("No tuner is enabled!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) return nim = nimmanager.nim_slots[index_to_scan] print "nim", nim.slot if nim.isCompatible("DVB-S"): print "is compatible with DVB-S" if self.scan_type.getValue() == "single_transponder": # these lists are generated for each tuner, so this has work. assert len(self.satList) > index_to_scan assert len(self.scan_satselection) > index_to_scan nimsats = self.satList[index_to_scan] selsatidx = self.scan_satselection[index_to_scan].index # however, the satList itself could be empty. in that case, "index" is 0 (for "None"). if len(nimsats): orbpos = nimsats[selsatidx][0] if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.getValue() else: fec = self.scan_sat.fec_s2.getValue() print "add sat transponder" self.addSatTransponder(tlist, self.scan_sat.frequency.getValue(), self.scan_sat.symbolrate.getValue(), self.scan_sat.polarization.getValue(), fec, self.scan_sat.inversion.getValue(), orbpos, self.scan_sat.system.getValue(), self.scan_sat.modulation.getValue(), self.scan_sat.rolloff.getValue(), self.scan_sat.pilot.getValue()) removeAll = False elif self.scan_type.getValue() == "single_satellite": sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] getInitialTransponderList(tlist, sat[0]) elif self.scan_type.getValue().find("multisat") != -1: SatList = nimmanager.getSatListForNim(index_to_scan) for x in self.multiscanlist: if x[1].getValue(): print " " + str(x[0]) getInitialTransponderList(tlist, x[0]) elif nim.isCompatible("DVB-C"): if self.scan_typecable.getValue() == "single_transponder": self.addCabTransponder(tlist, self.scan_cab.frequency.getValue(), self.scan_cab.symbolrate.getValue(), self.scan_cab.modulation.getValue(), self.scan_cab.fec.getValue(), self.scan_cab.inversion.getValue()) removeAll = False elif self.scan_typecable.getValue() == "complete": if config.Nims[index_to_scan].cable.scan_type.getValue() == "provider": getInitialCableTransponderList(tlist, index_to_scan) else: startScan = False elif nim.isCompatible("DVB-T"): if self.scan_typeterrestrial.getValue() == "single_transponder": self.addTerTransponder(tlist, self.scan_ter.frequency.getValue() * 1000, inversion = self.scan_ter.inversion.getValue(), bandwidth = self.scan_ter.bandwidth.getValue(), fechigh = self.scan_ter.fechigh.getValue(), feclow = self.scan_ter.feclow.getValue(), modulation = self.scan_ter.modulation.getValue(), transmission = self.scan_ter.transmission.getValue(), guard = self.scan_ter.guard.getValue(), hierarchy = self.scan_ter.hierarchy.getValue()) removeAll = False elif self.scan_typeterrestrial.getValue() == "complete": getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan)) flags = self.scan_networkScan.getValue() and eComponentScan.scanNetworkSearch or 0 tmp = self.scan_clearallservices.getValue() if tmp == "yes": flags |= eComponentScan.scanRemoveServices elif tmp == "yes_hold_feeds": flags |= eComponentScan.scanRemoveServices flags |= eComponentScan.scanDontRemoveFeeds if tmp != "no" and not removeAll: flags |= eComponentScan.scanDontRemoveUnscanned if self.scan_onlyfree.getValue(): flags |= eComponentScan.scanOnlyFree for x in self["config"].list: x[1].save() if startScan: self.startScan(tlist, flags, index_to_scan, self.networkid) else: self.flags = flags self.feid = index_to_scan self.tlist = [] self.startCableTransponderSearch(self.feid) def setCableTransponderSearchResult(self, tlist): self.tlist = tlist def cableTransponderSearchFinished(self): if self.tlist is None: self.tlist = [] else: self.startScan(self.tlist, self.flags, self.feid) def startScan(self, tlist, flags, feid, networkid = 0): if len(tlist): # flags |= eComponentScan.scanSearchBAT if self.finished_cb: self.session.openWithCallback(self.finished_cb, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}]) else: self.session.open(ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags, "networkid": networkid}]) else: if self.finished_cb: self.session.openWithCallback(self.finished_cb, MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) else: self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR) def keyCancel(self): self.session.nav.playService(self.session.postScanService) for x in self["config"].list: x[1].cancel() self.close() def doCloseRecursive(self): self.session.nav.playService(self.session.postScanService) self.closeRecursive()
class SoftcamPanel(ConfigListScreen, Screen): def __init__(self, session): global emuDir emuDir = "/etc/" self.service = None Screen.__init__(self, session) self.skin = SOFTCAM_SKIN self.onShown.append(self.setWindowTitle) self.partyfeed = None self.YellowAction = REFRESH self.mlist = [] self["key_green"] = Label(_("Restart")) self["key_red"] = Label(_("Stop")) self["key_yellow"] = Label(_("Refresh")) self.partyfeed = os.path.exists("/etc/opkg/3rdparty-feed.conf") or os.path.exists("/etc/opkg/3rd-party-feed.conf") if self.partyfeed: self["key_blue"]= Label(_("Install")) else: self["key_blue"]= Label(_("Exit")) self["ecminfo"] = Label(_("No ECM info")) self["actifcam"] = Label(_("no CAM 1 active")) self["actifcam2"] = Label(_("no CAM 2 active")) #// create listings self.emuDirlist = [] self.emuList = [] self.emuBin = [] self.emuStart = [] self.emuStop = [] self.emuRgui = [] self.emuDirlist = os.listdir(emuDir) self.ecmtel = 0 self.first = 0 global count count = 0 #// check emu dir for config files print "************ go in the emuloop ************" for x in self.emuDirlist: #// if file contains the string "emu" (then this is a emu config file) if x.find("emu") > -1: self.emuList.append(emuDir + x) em = open(emuDir + x) self.emuRgui.append(0) #// read the emu config file for line in em.readlines(): line1 = line #// startcam line = line1 if line.find("startcam") > -1: line = line.split("=") self.emuStart.append(line[1].strip()) #// stopcam line = line1 if line.find("stopcam") > -1: line = line.split("=") self.emuStop.append(line[1].strip()) #// Restart GUI line = line1 if line.find("restartgui") > -1: self.emuRgui[count] = 1 #// binname line = line1 if line.find("binname") > -1: line = line.split("=") self.emuBin.append(line[1].strip()) em.close() count += 1 self.maxcount = count self.onChangedEntry = [ ] self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry) self.ReadMenu() self.createSetup() self["ecminfo"].show() self.read_shareinfo() self.Timer = eTimer() self.Timer.callback.append(self.layoutFinished) self.Timer.start(2000, True) #// get the remote buttons self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ColorActions"], { "cancel": self.Exit, "ok": self.ok, "blue": self.Blue, "red": self.Red, "green": self.Green, "yellow": self.Yellow, }, -1) #// update screen self.onLayoutFinish.append(self.layoutFinished) def setWindowTitle(self): self.setTitle(_("Softcam Panel V2.0")) def ReadMenu(self): self.whichCam() for x in self.emuDirlist: #// if file contains the string "emu" (then this is a emu config file) if x.find("emu") > -1: self.emuList.append(emuDir + x) em = open(emuDir + x) self.emuRgui.append(0) #// read the emu config file for line in em.readlines(): line1 = line #// emuname line = line1 if line.find("emuname") > -1: line = line.split("=") self.mlist.append(line[1].strip()) name = line[1].strip() em.close() emusel = [_('no cam')] for x in self.mlist: emusel.append(x) self.cam1sel = ConfigSelection(emusel) self.cam2sel = ConfigSelection(emusel) self.setYellowKey(self.curcam) def whichCam(self): #// check for active cam 1 cam = config.softcam.actCam.getValue() self.curcam = None self.curcamIndex = None if cam in self.mlist: index = self.mlist.index(cam) x = self.emuBin[index] if self.isCamrunning(x): self.curcam = x self.curcamIndex = index #// check for active cam 2 cam = config.softcam.actCam2.getValue() self.curcam2 = None self.curcam2Index = None if cam in self.mlist: index = self.mlist.index(cam) x = self.emuBin[index] if self.isCamrunning(x): self.curcam2 = x self.curcam2Index = index if not self.curcam and not self.curcam2 and self.mlist: print "[SOFTCAMPANEL] try to find a running cam" for cam in self.emuBin: index = self.emuBin.index(cam) if self.isCamrunning(cam): self.curcam = cam self.curcamIndex = index camname = self.mlist[index] print"[SOFTCAMPANEL] found %s running" % camname self.Save_Settings(camname) break def createSetup(self): self.editListEntry = None self.list = [] self.list.append(getConfigListEntry(_("Select Cam 1"), self.cam1sel)) if len(self.emuStart) > 1: self["actifcam2"].show() if self.cam1sel.getValue() != _('no cam') or config.softcam.actCam.getValue() != _("no CAM 1 active"): self.list.append(getConfigListEntry(_("Select Cam 2"), self.cam2sel)) if self.cam2sel.getValue() != _('no cam'): self.list.append(getConfigListEntry(_("Wait time before start Cam 2"), config.softcam.waittime)) else: self["actifcam2"].hide() self.cam2sel.setValue(_('no cam')) self["config"].list = self.list self["config"].setList(self.list) def setYellowKey(self, cam): if cam == None or cam == _('no cam'): self.YellowAction = REFRESH self["key_yellow"].setText(_("Refresh")) return if cam.upper().startswith('CCCAM'): self.YellowAction = CCCAMINFO self["key_yellow"].setText(_("CCcamInfo")) elif cam.upper().startswith('OSCAM'): self.YellowAction = OSCAMINFO self["key_yellow"].setText(_("OscamInfo")) else: self.YellowAction = REFRESH self["key_yellow"].setText(_("Refresh")) def selectionChanged(self): #self["status"].setText(self["config"].getCurrent()[0]) pass def changedEntry(self): for x in self.onChangedEntry: x() self.selectionChanged() self.createSetup() def getCurrentEntry(self): return self["config"].getCurrent()[0] def getCurrentValue(self): return str(self["config"].getCurrent()[1].getText()) def getCurrentDescription(self): return self["config"].getCurrent() and len(self["config"].getCurrent()) > 2 and self["config"].getCurrent()[2] or "" def layoutFinished(self): self.Timer.stop() if not Check_Softcam(): self.Exit() #// check for active cam try: self.whichCam() global oldcamIndex, oldcam2Index oldcamIndex = -1 oldcam2Index = -1 tel = 0 if self.curcam: oldcamIndex = self.curcamIndex actcam = self.mlist[oldcamIndex] if self.first == 0: self.cam1sel.setValue(actcam) self["key_green"].setText(_("Restart")) self["actifcam"].setText(_("active CAM 1: ") + actcam ) print '[SOFTCAM] set active cam 1 to: ' + actcam else: actcam = _("no CAM 1 active") self["actifcam"].setText(actcam) if self.curcam2: oldcam2Index = self.curcam2Index actcam = self.mlist[oldcam2Index] if self.first == 0: self.cam2sel.setValue(actcam) self["actifcam2"].setText(_("active CAM 2: ") + actcam ) print '[SOFTCAM] set active cam 2 to: ' + actcam else: actcam2 = _("no CAM 2 active") self["actifcam2"].setText(actcam2) if self.first == 0: # Only update first time or when refresh button was pressed self.createSetup() self.first = 1 #// CAM IS NOT RUNNING if not self.curcam and not self.curcam2: self["key_green"].setText(_("Start")) self.YellowAction = REFRESH self["key_yellow"].setText(_("Refresh")) if os.path.exists('/tmp/ecm.info') is True: os.system("rm /tmp/ecm.info") if os.path.exists('/tmp/ecm0.info') is True: os.system("rm /tmp/ecm0.info") except: pass if self["config"].getCurrent()[0] == _("Select Cam 1"): self.setYellowKey(self.curcam) else: self.setYellowKey(self.curcam2) #// read ecm.info ecmi = "" if os.path.exists('/tmp/ecm.info') is True: ecmi = self.read_ecm('/tmp/ecm.info') elif os.path.exists('/tmp/ecm1.info') is True: ecmi = self.read_ecm('/tmp/ecm1.info') else: ecmi = _("No ECM info") ecmold = self["ecminfo"].getText() if ecmold == ecmi: self.ecmtel += 1 if self.ecmtel > 5: ecmi = _("No new ECM info") else: self.ecmtel = 0 self["ecminfo"].setText(ecmi) self.Timer.start(2000, True) #reset timer def read_shareinfo(self): #// read share.info and put in list self.shareinfo =[] if os.path.exists('/tmp/share.info') is True: s = open('/tmp/share.info') for x in s.readlines(): self.shareinfo.append(x) s.close() def read_ecm(self, ecmpath): #// read ecm.info and check for share.info ecmi2 = '' Caid = '' Prov = '' f = open(ecmpath) for line in f.readlines(): line= line.replace('=', '') line= line.replace(' ', '', 1) #// search CaID if line.find('ECM on CaID') > -1: k = line.find('ECM on CaID') + 14 Caid = line[k:k+4] #// search Boxid if line.find('prov:') > -1: tmpprov = line.split(':') Prov = tmpprov[1].strip() #// search peer in share.info only if share.info exists if Caid <> '' and Prov <> '' and len(self.shareinfo) > 0 : for x in self.shareinfo: cel = x.split(' ') #// search Boxid and Caid if cel[5][0:4] == Caid and cel[9][3:7] == Prov: line = 'Peer: ' + Prov + ' - ' + cel[3] + ' - ' + cel[8] + '\n' break ecmi2 = ecmi2 + line f.close() return ecmi2 def Red(self): #// Stopping the CAM when pressing the RED button self.Timer.stop() self.Stopcam() self.Timer.start(2000, True) #reset timer def Yellow(self): if self.YellowAction == CCCAMINFO: self.Timer.stop() self.session.openWithCallback(self.ShowSoftcamCallback, CCcamInfoMain) elif self.YellowAction == OSCAMINFO: self.Timer.stop() self.session.openWithCallback(self.ShowSoftcamCallback, OscamInfoMenu) else: self.first = 0 self.layoutFinished() def Green(self): #// Start the CAM when pressing the GREEN button self.Timer.stop() self.Startcam() self.Timer.start(2000, True) #reset timer def Exit(self): self.Timer.stop() self.close() def Blue(self): if not self.partyfeed: self.Exit() else: self.Timer.stop() self.session.openWithCallback(self.ShowSoftcamCallback, ShowSoftcamPackages) def ShowSoftcamCallback(self): self.Timer.start(2000, True) def ok(self): #// Exit Softcam when pressing the OK button self.Timer.stop() self.Startcam() if self.YellowAction == REFRESH: self.Yellow() self.Timer.start(2000, True) #reset timer def Stopcam(self): #// Stopping the CAM global oldcamIndex, oldcam2Index if oldcamIndex >= 0: oldcam = self.emuBin[oldcamIndex] else: oldcam = None if oldcam2Index >= 0: oldcam2 = self.emuBin[oldcam2Index] else: oldcam2 = None import time self.container = eConsoleAppContainer() if config.softcam.camstartMode.getValue() == "0" or not fileExists('/etc/init.d/softcam'): if oldcam: print '[SOFTCAM] Python stop cam 1: ' + oldcam self.container.execute(self.emuStop[oldcamIndex]) time.sleep(1) # was 5sec t = 0 while t < 5: p = command('pidof %s |wc -w' % oldcam ) if not p.isdigit(): p=0 if int(p) > 0: self.container = eConsoleAppContainer() self.container.execute('killall -9 ' + oldcam) t += 1 time.sleep(1) else: t = 5 if oldcam2: print '[SOFTCAM] Python stop cam 2: ' + oldcam2 self.container.execute(self.emuStop[oldcam2Index]) time.sleep(1) # was 5sec t = 0 while t < 5: p = command('pidof %s |wc -w' % oldcam2 ) if not p.isdigit(): p=0 if int(p) > 0: self.container = eConsoleAppContainer() self.container.execute('killall -9 ' + oldcam2) t += 1 time.sleep(1) else: t = 5 else: self.container.execute('/etc/init.d/softcam.cam1 stop') self.container.execute('/etc/init.d/softcam.cam2 stop') if os.path.exists('/tmp/ecm.info') is True: os.system("rm /tmp/ecm.info") actcam = _("no CAM 1 active") actcam2 = _("no CAM 2 active") self["actifcam"].setText(actcam) self["actifcam2"].setText(actcam2) self["key_green"].setText(_("Start")) self["ecminfo"].setText(_("No ECM info")) self.Save_Settings(actcam) self.Save_Settings2(actcam2) def Startcam(self): #// Starting the CAM try: if count > 0: if self.cam1sel.getValue() == self.cam2sel.getValue(): self.session.openWithCallback(self.doNothing, MessageBox, _("No Cam started !!\n\nCam 1 must be different from Cam 2"), MessageBox.TYPE_ERROR, simple=True) return if config.softcam.camstartMode.getValue() == "0": self.Stopcam() self.camIndex = self.cam1sel.getIndex() -1 self.cam2Index = self.cam2sel.getIndex() - 1 if self.camIndex >= 0: actcam = self.cam1sel.getValue() self["actifcam"].setText(_("active CAM 1: ") + actcam) self.Save_Settings(actcam) start = self.emuStart[self.camIndex] if self.checkBinName(self.emuBin[self.camIndex], start): self.session.openWithCallback(self.startcam2, MessageBox, actcam + _(" Not Started !!\n\nCam binname must be in the start command line\nCheck your emu config file"), MessageBox.TYPE_ERROR, simple=True) return if config.softcam.camstartMode.getValue() == "0": print '[SOFTCAM] Python start cam 1: ' + actcam self.session.openWithCallback(self.waitTime, MessageBox, _("Starting Cam 1: ") + actcam, MessageBox.TYPE_WARNING, timeout=5, simple=True) self.container = eConsoleAppContainer() self.container.execute(start) else: # Create INIT.D start self.session.openWithCallback(self.doNothing, MessageBox, _("Creating start scripts and starting the cam"), MessageBox.TYPE_WARNING, timeout=10, simple=True) self.Save_Settings2(self.cam2sel.getValue()) camname1 = self.emuBin[self.camIndex] camname2 = self.emuBin[self.cam2Index] self.deleteInit() camname = "/usr/bin/" + camname1 startcmd = self.emuStart[self.camIndex] stopcmd = self.emuStop[self.camIndex] self.createInitdscript("cam1", camname, startcmd, stopcmd) if self.cam2Index >= 0: camname = "/usr/bin/" + camname2 startcmd = self.emuStart[self.cam2Index] stopcmd = self.emuStop[self.cam2Index] self.createInitdscript("cam2", camname, startcmd, stopcmd, config.softcam.waittime.getValue()) self["key_green"].setText(_("Restart")) except: pass def waitTime(self, ret): if self.cam2Index >= 0: if config.softcam.waittime.getValue() == '0': self.startcam2(None) else: self.session.openWithCallback(self.startcam2, MessageBox, _("Waiting..."), MessageBox.TYPE_WARNING, timeout=int(config.softcam.waittime.getValue()), simple=True) def doNothing(self, ret): pass def startcam2(self, ret): camIndex = self.cam2Index if camIndex >= 0: actcam = self.cam2sel.getValue() self["actifcam2"].setText(_("active CAM 2: ") + actcam) self.Save_Settings2(actcam) start = self.emuStart[camIndex] if self.checkBinName(self.emuBin[self.cam2Index], start): self.session.open(MessageBox, actcam + _(" Not Started !!\n\nCam binname must be in the start command line\nCheck your emu config file"), MessageBox.TYPE_ERROR, simple=True) return print '[SOFTCAM] Python start cam 2: ' + actcam self.session.open(MessageBox, _("Starting Cam 2: ") + actcam, MessageBox.TYPE_WARNING, timeout=5, simple=True) self.container = eConsoleAppContainer() self.container.execute(start) def Save_Settings(self, cam_name): #// Save Came Name to Settings file config.softcam.actCam.setValue(cam_name) config.softcam.save() configfile.save() def Save_Settings2(self, cam_name): #// Save Came Name to Settings file config.softcam.actCam2.setValue(cam_name) config.softcam.save() configfile.save() def isCamrunning(self, cam): p = command('pidof ' + cam + ' |wc -w') if not p.isdigit(): p=0 if int(p) > 0: return True else: return False def checkBinName(self, binname, start): print "[CHECKBINNAME] bin=%s ,start=%s" %(binname,start) if start.find(binname + ' ') > -1: print "[CHECKBINNAME] OK" return False else: if start[start.rfind('/')+1:] == binname: print "[CHECKBINNAME] OK" return False else: print "[CHECKBINNAME] ERROR" return True def createInitdscript(self, camname, emubin, start, stop, wait=None): Adir = "/etc/init.d/softcam." + camname softcamfile = [] softcamfile.append('#!/bin/sh') softcamfile.append('DAEMON=%s' % emubin) softcamfile.append('STARTCAM="%s"' % start) softcamfile.append('STOPCAM="%s"' % stop) softcamfile.append('DESC="Softcam"') softcamfile.append('') softcamfile.append('test -f $DAEMON || exit 0') softcamfile.append('set -e') softcamfile.append('') softcamfile.append('case "$1" in') softcamfile.append(' start)') softcamfile.append(' echo -n "starting $DESC: $DAEMON... "') if wait: softcamfile.append(' sleep ' + wait) softcamfile.append(' $STARTCAM') softcamfile.append(' echo "done."') softcamfile.append(' ;;') softcamfile.append(' stop)') softcamfile.append(' echo -n "stopping $DESC: $DAEMON... "') softcamfile.append(' $STOPCAM') softcamfile.append(' echo "done."') softcamfile.append(' ;;') softcamfile.append(' restart)') softcamfile.append(' echo "restarting $DESC: $DAEMON... "') softcamfile.append(' $0 stop') softcamfile.append(' echo "wait..."') softcamfile.append(' sleep 5') softcamfile.append(' $0 start') softcamfile.append(' echo "done."') softcamfile.append(' ;;') softcamfile.append(' *)') softcamfile.append(' echo "Usage: $0 {start|stop|restart}"') softcamfile.append(' exit 1') softcamfile.append(' ;;') softcamfile.append('esac') softcamfile.append('') softcamfile.append('exit 0') f = open( Adir, "w" ) for x in softcamfile: f.writelines(x + '\n') f.close() self.container = eConsoleAppContainer() # Set execute rights os.chmod(Adir,0755) # Create symbolic link for startup if not os.path.exists("/etc/rc2.d/S20softcam." + camname): self.container.execute('update-rc.d -f softcam.' + camname + ' defaults') # Wait a few seconds import time time.sleep (3) # Start cam if self.isCamrunning(emubin): self.container.execute('/etc/init.d/softcam.' + camname + ' restart') else: self.container.execute('/etc/init.d/softcam.' + camname + ' start') def deleteInit(self): if os.path.exists("/etc/rc2.d/S20softcam.cam1"): print "Delete Symbolink link" self.container = eConsoleAppContainer() self.container.execute('update-rc.d -f softcam.cam1 defaults') if os.path.exists("/etc/init.d/softcam.cam1"): print "Delete softcam init script cam1" os.system("rm /etc/init.d/softcam.cam1") if os.path.exists("/etc/rc2.d/S20softcam.cam2"): print "Delete Symbolink link" self.container = eConsoleAppContainer() self.container.execute('update-rc.d -f softcam.cam2 defaults') if os.path.exists("/etc/init.d/softcam.cam2"): print "Delete softcam init script cam2" os.system("rm /etc/init.d/softcam.cam2")
class FastScanScreen(ConfigListScreen, Screen): skin = """ <screen position="100,115" size="520,290" title="Fast Scan"> <widget name="config" position="10,10" size="500,250" scrollbarMode="showOnDemand" /> <widget name="introduction" position="10,265" size="500,25" font="Regular;20" halign="center" /> </screen>""" def __init__(self, session, nimList): Screen.__init__(self, session) self.setTitle(_("Fast Scan")) self.providers = {} #hacky way self.providers['Kontinent'] = (0, 900, True) self.providers['Ntvplus'] = (0, 900, True) self.providers['Raduga'] = (0, 900, True) self.providers['Telekarta'] = (0, 900, True) self.providers['Tricolor'] = (0, 900, True) #orgin self.providers['Canal Digitaal'] = (1, 900, True) self.providers['TV Vlaanderen'] = (1, 910, True) self.providers['TéléSAT'] = (0, 920, True) self.providers['AustriaSat'] = (0, 950, False) self.providers['Skylink Czech Republic'] = (1, 30, False) self.providers['Skylink Slovak Republic'] = (1, 31, False) self.providers['TéléSAT Astra3'] = (1, 920, True) self.providers['AustriaSat Astra3'] = (1, 950, False) self.providers['Canal Digitaal Astra 1'] = (0, 900, True) self.providers['TV Vlaanderen Astra 1'] = (0, 910, True) self.transponders = ((12515000, 22000000, eDVBFrontendParametersSatellite.FEC_5_6, 192, eDVBFrontendParametersSatellite.Polarisation_Horizontal, eDVBFrontendParametersSatellite.Inversion_Unknown, eDVBFrontendParametersSatellite.System_DVB_S, eDVBFrontendParametersSatellite.Modulation_QPSK, eDVBFrontendParametersSatellite.RollOff_alpha_0_35, eDVBFrontendParametersSatellite.Pilot_Off), (12070000, 27500000, eDVBFrontendParametersSatellite.FEC_3_4, 235, eDVBFrontendParametersSatellite.Polarisation_Horizontal, eDVBFrontendParametersSatellite.Inversion_Unknown, eDVBFrontendParametersSatellite.System_DVB_S, eDVBFrontendParametersSatellite.Modulation_QPSK, eDVBFrontendParametersSatellite.RollOff_alpha_0_35, eDVBFrontendParametersSatellite.Pilot_Off)) self["actions"] = ActionMap(["SetupActions", "MenuActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "menu": self.closeRecursive, }, -2) providerList = list(x[0] for x in sorted(self.providers.iteritems(), key = operator.itemgetter(1))) lastConfiguration = eval(config.misc.fastscan.last_configuration.value) if not lastConfiguration: lastConfiguration = (nimList[0][0], providerList[0], True, True, False) self.scan_nims = ConfigSelection(default = lastConfiguration[0], choices = nimList) self.scan_provider = ConfigSelection(default = lastConfiguration[1], choices = providerList) self.scan_hd = ConfigYesNo(default = lastConfiguration[2]) self.scan_keepnumbering = ConfigYesNo(default = lastConfiguration[3]) self.scan_keepsettings = ConfigYesNo(default = lastConfiguration[4]) self.list = [] self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) self.scanProvider = getConfigListEntry(_("Provider"), self.scan_provider) self.list.append(self.scanProvider) self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd) self.list.append(self.scanHD) self.list.append(getConfigListEntry(_("Use fastscan channel numbering"), self.scan_keepnumbering)) self.list.append(getConfigListEntry(_("Use fastscan channel names"), self.scan_keepsettings)) ConfigListScreen.__init__(self, self.list) self["config"].list = self.list self["config"].l.setList(self.list) self.finished_cb = None self["introduction"] = Label(_("Select your provider, and press OK to start the scan")) def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot): print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) print "orbpos: " + str(orbital_position) parm = eDVBFrontendParametersSatellite() parm.modulation = modulation parm.system = system parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.polarisation = polarisation parm.fec = fec parm.inversion = inversion parm.orbital_position = orbital_position parm.rolloff = rolloff parm.pilot = pilot tlist.append(parm) def readXML(self, xml): tlist = [] import xml.dom.minidom as minidom xmldoc = "/usr/lib/enigma2/python/Plugins/SystemPlugins/FastScan/xml/" + xml + ".xml" xmldoc = minidom.parse(xmldoc) tr_list = xmldoc.getElementsByTagName('transporder') for lista in tr_list: frequency = lista.getAttribute("frequency") symbolrate = lista.getAttribute("symbolrate") fec = lista.getAttribute("fec") orbpos = lista.getAttribute("orbpos") pol = lista.getAttribute("pol") system = lista.getAttribute("system") modulation = lista.getAttribute("modulation") self.frequency = frequency self.symbolrate = symbolrate if pol == "H": pol = 0 elif pol == "V": pol = 1 elif pol == "L": pol = 2 elif pol == "R": pol = 3 self.polarization = pol # 0 - H, 1 - V, 2- CL, 3 - CR if fec == "Auto": fec = 0 elif fec == "1/2": fec = 1 elif fec == "2/3": fec = 2 elif fec == "3/4": fec = 3 elif fec == "3/5": fec = 4 elif fec == "4/5": fec = 5 elif fec == "5/6": fec = 6 elif fec == "7/8": fec = 7 elif fec == "8/9": fec = 8 elif fec == "9/10": fec = 9 self.fec = fec # 0 - Auto, 1 - 1/2, 2 - 2/3, 3 - 3/4, 4 - 3/5, 5 - 4/5, 6 - 5/6, 7 - 7/8, 8 - 8/9 , 9 - 9/10, self.inversion = 2 # 0 - off, 1 -on, 2 - AUTO self.orbpos = orbpos if system == "DVBS": system = 0 elif system == "DVBS2": system = 1 self.system = system # DVB-S = 0, DVB-S2 = 1 if modulation == "QPSK": modulation = 0 elif modulation == "8PSK": modulation = 1 self.modulation = modulation # 0- QPSK, 1 -8PSK self.rolloff = 0 # self.pilot = 2 # 0 - off, 1 - on 2 - AUTO print "add sat transponder" self.addSatTransponder(tlist, int(self.frequency), int(self.symbolrate), int(self.polarization), int(fec), int(self.inversion), int(orbpos), int(self.system), int(self.modulation), int(self.rolloff), int(self.pilot)) self.session.open(ServiceScan, [{"transponders": tlist, "feid": int(self.scan_nims.getValue()), "flags": 0, "networkid": 0}]) def keyGo(self): prov = self.scan_provider.value.lower() if prov == "tricolor" or prov == "kontinent" or prov == "telekarta" or prov == "ntvplus" or prov == "raduga": self.readXML(self.scan_provider.value.lower()) else: config.misc.fastscan.last_configuration.value = `(self.scan_nims.value, self.scan_provider.value, self.scan_hd.value, self.scan_keepnumbering.value, self.scan_keepsettings.value)` config.misc.fastscan.save() self.startScan() def getTransponderParameters(self, number): transponderParameters = eDVBFrontendParametersSatellite() transponderParameters.frequency = self.transponders[number][0] transponderParameters.symbol_rate = self.transponders[number][1] transponderParameters.fec = self.transponders[number][2] transponderParameters.orbital_position = self.transponders[number][3] transponderParameters.polarisation = self.transponders[number][4] transponderParameters.inversion = self.transponders[number][5] transponderParameters.system = self.transponders[number][6] transponderParameters.modulation = self.transponders[number][7] transponderParameters.rolloff = self.transponders[number][8] transponderParameters.pilot = self.transponders[number][9] return transponderParameters def startScan(self): pid = self.providers[self.scan_provider.getValue()][1] if self.scan_hd.getValue() and self.providers[self.scan_provider.value][2]: pid += 1 if self.scan_nims.value: self.session.open(FastScanStatus, scanTuner = int(self.scan_nims.getValue()), transponderParameters = self.getTransponderParameters(self.providers[self.scan_provider.getValue()][0]), scanPid = pid, keepNumbers = self.scan_keepnumbering.getValue(), keepSettings = self.scan_keepsettings.getValue(), providerName = self.scan_provider.getText()) def keyCancel(self): self.close()
class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen): def __init__(self, session, feid): Screen.__init__(self, session) # for the skin: first try MediaPlayerSettings, then Setup, this allows individual skinning self.skinName = ["DiseqcTesterTestTypeSelection", "Setup" ] self.setup_title = _("DiSEqC-tester settings") self.onChangedEntry = [ ] self.feid = feid self.list = [] ConfigListScreen.__init__(self, self.list, session = self.session, on_change = self.changedEntry) self["actions"] = ActionMap(["SetupActions", "MenuActions"], { "cancel": self.keyCancel, "save": self.keyOK, "ok": self.keyOK, "menu": self.closeRecursive, }, -2) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("OK")) self.createSetup() self.onLayoutFinish.append(self.__layoutFinished) def __layoutFinished(self): self.setTitle(self.setup_title) def createSetup(self): self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random"), "complete": _("Complete")}, default = "quick") self.testtypeEntry = getConfigListEntry(_("Test type"), self.testtype) self.list.append(self.testtypeEntry) self.loopsfailed = ConfigSelection(choices={"-1": _("Every known"), "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "3") self.loopsfailedEntry = getConfigListEntry(_("Stop testing plane after # failed transponders"), self.loopsfailed) self.list.append(self.loopsfailedEntry) self.loopssuccessful = ConfigSelection(choices={"-1": _("Every known"), "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "1") self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful) self.list.append(self.loopssuccessfulEntry) self.log = ConfigYesNo(False) self.logEntry = getConfigListEntry(_("Log results to /tmp"), self.log) self.list.append(self.logEntry) self["config"].list = self.list self["config"].l.setList(self.list) def keyOK(self): print self.testtype.getValue() testtype = DiseqcTester.TEST_TYPE_QUICK if self.testtype.getValue() == "quick": testtype = DiseqcTester.TEST_TYPE_QUICK elif self.testtype.getValue() == "random": testtype = DiseqcTester.TEST_TYPE_RANDOM elif self.testtype.getValue() == "complete": testtype = DiseqcTester.TEST_TYPE_COMPLETE self.session.open(DiseqcTester, feid = self.feid, test_type = testtype, loopsfailed = int(self.loopsfailed.value), loopssuccessful = int(self.loopssuccessful.value), log = self.log.value) def keyCancel(self): self.close() # for summary: def changedEntry(self): for x in self.onChangedEntry: x() def getCurrentEntry(self): return self["config"].getCurrent()[0] def getCurrentValue(self): return str(self["config"].getCurrent()[1].getText()) def createSummary(self): from Screens.Setup import SetupSummary return SetupSummary
class OSD3DSetupScreen(Screen, ConfigListScreen): skin = """ <screen position="c-200,c-100" size="400,200" title="OSD 3D setup"> <widget name="config" position="c-175,c-75" size="350,150" /> <ePixmap pixmap="buttons/green.png" position="c-145,e-45" zPosition="0" size="140,40" alphatest="on" /> <ePixmap pixmap="buttons/red.png" position="c+5,e-45" zPosition="0" size="140,40" alphatest="on" /> <widget name="ok" position="c-145,e-45" size="140,40" valign="center" halign="center" zPosition="1" font="Regular;20" transparent="1" backgroundColor="green" /> <widget name="cancel" position="c+5,e-45" size="140,40" valign="center" halign="center" zPosition="1" font="Regular;20" transparent="1" backgroundColor="red" /> </screen>""" def __init__(self, session): self.skin = OSD3DSetupScreen.skin Screen.__init__(self, session) from Components.ActionMap import ActionMap from Components.Button import Button self["ok"] = Button(_("OK")) self["cancel"] = Button(_("Cancel")) self["actions"] = ActionMap( ["SetupActions", "ColorActions", "MenuActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "green": self.keyGo, "red": self.keyCancel, "menu": self.closeRecursive, }, -2) self.list = [] ConfigListScreen.__init__(self, self.list, session=self.session) mode = config.plugins.OSD3DSetup.mode.getValue() znorm = config.plugins.OSD3DSetup.znorm.getValue() self.mode = ConfigSelection(choices=modelist, default=mode) self.znorm = ConfigSlider(default=znorm + 50, increment=1, limits=(0, 100)) self.list.append(getConfigListEntry(_("3d mode"), self.mode)) self.list.append(getConfigListEntry(_("Depth"), self.znorm)) self["config"].list = self.list self["config"].l.setList(self.list) def keyLeft(self): ConfigListScreen.keyLeft(self) self.setPreviewSettings() def keyRight(self): ConfigListScreen.keyRight(self) self.setPreviewSettings() def setPreviewSettings(self): applySettings(self.mode.getValue(), int(self.znorm.getValue()) - 50) def keyGo(self): config.plugins.OSD3DSetup.mode.value = self.mode.getValue() config.plugins.OSD3DSetup.znorm.value = int(self.znorm.getValue()) - 50 config.plugins.OSD3DSetup.save() self.close() def keyCancel(self): setConfiguredSettings() self.close()