class NetworkConfigGlobal(Screen, ConfigListScreen): skin = """ <screen name="NetworkConfigGlobal" position="center,center" size="720,100" title="Network: General configuration"> <widget name="config" position="10,10" size="700,80" scrollbarMode="showOnDemand" zPosition="1"/> </screen>""" def __init__(self, session): Screen.__init__(self, session) ConfigListScreen.__init__(self, [], session=session) self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], { "save": self.close, "cancel": self.close, "ok" : self.close, }, -2) self._nm = eNetworkManager.getInstance(); choices_timeupdates = { eNetworkManager.TIME_UPDATES_AUTO : _("auto"), eNetworkManager.TIME_UPDATES_MANUAL : _("manual") } self._config_timeupdates = ConfigSelection(choices_timeupdates, default=self._nm.timeUpdates()) self._config_timeupdates.addNotifier(self._config_changed, initial_call=False) self._createSetup() self.onLayoutFinish.append(self._layoutFinished) def _layoutFinished(self): self.setTitle(_("Network: General configuration")) def _config_changed(self, element): self._nm.setTimeUpdates(self._config_timeupdates.value) self._createSetup() def _createSetup(self): lst = [getConfigListEntry(_("NTP Time Updates"), self._config_timeupdates)] self["config"].list = lst
def setToggleSubsFilterKey(self, arg=None): if self.settings.menupage.getValue() == PAGE_SUBTITLES: cur = self["streams"].getCurrent() sel_sub = cur and isinstance( cur[0], SelectionTrackinfoEntry) and cur[0].info conflist = self["config"].list if sel_sub and ( sel_sub.getType() == iSt.DVD or sel_sub.getType() == iSt.GST and sel_sub.getGstSubtype() in [iGSt.stPGS, iGSt.stVOB]): forcefilter = str(sel_sub.getFilter()) choicelist = [ (str( iSubtitleFilterType_ENUMS.SUB_FILTER_SHOW_FORCED_ONLY), "forced only"), (str(iSubtitleFilterType_ENUMS.SUB_FILTER_SHOW_ALL), "show all") ] togglesubsfilter = ConfigSelection(choices=choicelist, default=forcefilter) togglesubsfilter.addNotifier(boundFunction( self.toggleSubsFilter, cur[0]), initial_call=False) self["key_green"].setBoolean(True) conflist[1] = getConfigListEntry(_("Toggle Subtitle Filter"), togglesubsfilter) else: self["key_green"].setBoolean(False) togglesubsfilter = None conflist[1] = (('', )) self["config"].l.setList(conflist)
class NetworkConfigGlobal(Screen, ConfigListScreen): skin = """ <screen name="NetworkConfigGlobal" position="center,center" size="520,50" title="Network: General configuration"> <widget name="config" position="10,10" size="500,30" scrollbarMode="showOnDemand"/> </screen>""" def __init__(self, session): Screen.__init__(self, session) ConfigListScreen.__init__(self, [], session=session) self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], { "save": self.close, "cancel": self.close, "ok" : self.close, }, -2) self._nm = eNetworkManager.getInstance(); choices_timeupdates = { eNetworkManager.TIME_UPDATES_AUTO : _("auto"), eNetworkManager.TIME_UPDATES_MANUAL : _("manual") } self._config_timeupdates = ConfigSelection(choices_timeupdates, default=self._nm.timeUpdates()) self._config_timeupdates.addNotifier(self._config_changed, initial_call=False) self._createSetup() self.onLayoutFinish.append(self._layoutFinished) def _layoutFinished(self): self.setTitle(_("Network: General configuration")) def _config_changed(self, element): self._nm.setTimeUpdates(self._config_timeupdates.value) self._createSetup() def _createSetup(self): lst = [getConfigListEntry(_("NTP Time Updates"), self._config_timeupdates)] self["config"].list = lst
def ConfigIntSelection(choices, default=None): def int_converter(cfg_elem): try: cfg_elem.int_value = None if cfg_elem.value is None else int(cfg_elem.value) except ValueError: cfg_elem.int_value = None def make_str_choices(c): return [str(i) if type(i) == int else (str(i[0]), i[1]) for i in c] ctrl = ConfigSelection(choices, default=None if default is None else str(default)) ctrl.addNotifier(int_converter) return ctrl
def setToggleSubsFilterKey(self, arg=None): if self.settings.menupage.getValue() == PAGE_SUBTITLES: cur = self["streams"].getCurrent() sel_sub = cur and isinstance(cur[0], SelectionTrackinfoEntry) and cur[0].info conflist = self["config"].list if sel_sub and (sel_sub.getType() == iSt.DVD or sel_sub.getType() == iSt.GST and sel_sub.getGstSubtype() in [iGSt.stPGS, iGSt.stVOB]): forcefilter = str(sel_sub.getFilter()) choicelist = [(str(iSubtitleFilterType_ENUMS.SUB_FILTER_SHOW_FORCED_ONLY), "forced only"), (str(iSubtitleFilterType_ENUMS.SUB_FILTER_SHOW_ALL), "show all")] togglesubsfilter = ConfigSelection(choices = choicelist, default = forcefilter) togglesubsfilter.addNotifier(boundFunction(self.toggleSubsFilter, cur[0]), initial_call = False) self["key_green"].setBoolean(True) conflist[1] = getConfigListEntry(_("Toggle Subtitle Filter"), togglesubsfilter) else: self["key_green"].setBoolean(False) togglesubsfilter = None conflist[1] = (('',)) self["config"].l.setList(conflist)
class Satfinder(ScanSetup): def __init__(self, session, feid): self.initcomplete = False self.feid = feid self.oldref = None self.frontendData = None service = session and session.nav.getCurrentService() feinfo = service and service.frontendInfo() self.frontendData = feinfo and feinfo.getAll(True) del feinfo del service ScanSetup.__init__(self, session) self.setTitle(_("Satfinder")) self["introduction"].setText(_("Press OK to scan")) self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100) self["actions"] = ActionMap(["SetupActions"], { "save": self.keyGoScan, "ok": self.keyGoScan, "cancel": self.keyCancel, }, -3) self.initcomplete = True self.oldref = self.session.nav.getCurrentlyPlayingServiceReference() self.onClose.append(self.__onClose) self.onShow.append(self.__onShow) 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 __onShow(self): if self.oldref is not None: self.session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if self.session.pipshown: # try to disable pip self.session.pipshown = False del self.session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen self.tuner = Tuner(self.frontend) self.retune(None) def __onClose(self): self.session.nav.playService(self.oldref) def createSetup(self): self.typeOfTuningEntry = None self.satEntry = None self.list = [] self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat) self.list.append(self.satEntry) self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type) self.list.append(self.typeOfTuningEntry) nim = nimmanager.nim_slots[self.feid] self.systemEntry = None if self.tuning_type.getValue() == "manual_transponder": 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.value = eDVBFrontendParametersSatellite.System_DVB_S self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency)) self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization)) self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate)) self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion)) 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.tuning_transponder and self.tuning_type.getValue() == "predefined_transponder": self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder)) self["config"].list = self.list self["config"].l.setList(self.list) def newConfig(self): cur = self["config"].getCurrent() if cur in (self.typeOfTuningEntry, self.systemEntry): self.createSetup() elif cur == self.satEntry: self.updateSats() self.createSetup() def sat_changed(self, config_element): self.newConfig() self.retune(config_element) def retune(self, configElement): returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) satpos = int(self.tuning_sat.getValue()) if self.tuning_type.getValue() == "manual_transponder": if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S2: fec = self.scan_sat.fec_s2.getValue() else: fec = self.scan_sat.fec.getValue() returnvalue = ( self.scan_sat.frequency.getValue(), self.scan_sat.symbolrate.getValue(), self.scan_sat.polarization.getValue(), fec, self.scan_sat.inversion.getValue(), satpos, self.scan_sat.system.getValue(), self.scan_sat.modulation.getValue(), self.scan_sat.rolloff.getValue(), self.scan_sat.pilot.getValue()) self.tune(returnvalue) elif self.tuning_type.getValue() == "predefined_transponder": tps = nimmanager.getTransponders(satpos) l = len(tps) if l > self.tuning_transponder.index: transponder = tps[self.tuning_transponder.index] returnvalue = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9]) self.tune(returnvalue) def createConfig(self, foo): self.tuning_transponder = None self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))]) orbital_position = 192 if self.frontendData and self.frontendData.has_key('orbital_position'): orbital_position = self.frontendData['orbital_position'] self.tuning_sat = getConfigSatlist(orbital_position, nimmanager.getSatListForNim(self.feid)) ScanSetup.createConfig(self, self.frontendData) self.updateSats() for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system): x.addNotifier(self.retune, initial_call = False) def updateSats(self): orb_pos = self.tuning_sat.orbital_position if orb_pos is not None: transponderlist = nimmanager.getTransponders(orb_pos) list = [] default = None index = 0 for x in transponderlist: if x[3] == 0: pol = "H" elif x[3] == 1: pol = "V" elif x[3] == 2: pol = "CL" elif x[3] == 3: pol = "CR" else: pol = "??" if x[4] == 0: fec = "FEC Auto" elif x[4] == 1: fec = "FEC 1/2" elif x[4] == 2: fec = "FEC 2/3" elif x[4] == 3: fec = "FEC 3/4" elif x[4] == 4: fec = "FEC 5/6" elif x[4] == 5: fec = "FEC 7/8" elif x[4] == 6: fec = "FEC 8/9" elif x[4] == 7: fec = "FEC 3/5" elif x[4] == 8: fec = "FEC 4/5" elif x[4] == 9: fec = "FEC 9/10" elif x[4] == 15: fec = "FEC None" else: fec = "FEC Unknown" e = "%d %s %d %s" % ((x[1] / 1000), pol, (x[2] / 1000), fec) if default is None: default = str(index) list.append((str(index), e)) index += 1 self.tuning_transponder = ConfigSelection(choices = list, default = default) self.tuning_transponder.addNotifier(self.retune, initial_call = False) def keyGoScan(self): self.frontend = None del self.raw_channel self.updateSatList() self.scan_satselection = [ self.tuning_sat ] self.satfinder = True self.scan_sat.frequency.setValue(self.transponder[0]) self.scan_sat.symbolrate.setValue(self.transponder[1]) self.scan_sat.polarization.setValue(self.transponder[2]) if self.scan_sat.system.getValue() == eDVBFrontendParametersSatellite.System_DVB_S: self.scan_sat.fec.setValue(self.transponder[3]) else: self.scan_sat.fec_s2.setValue(self.transponder[3]) self.scan_sat.inversion.setValue(self.transponder[4]) self.scan_sat.system.setValue(self.transponder[6]) self.scan_sat.modulation.setValue(self.transponder[7]) self.scan_sat.rolloff.setValue(self.transponder[8]) self.scan_sat.pilot.setValue(self.transponder[9]) self.keyGo() 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 satfinder?"), MessageBox.TYPE_YESNO) else: self.restartPrevService(False) def tune(self, transponder): if self.initcomplete: if transponder is not None: self.tuner.tune(transponder) self.transponder = transponder
class SetupFallbacktuner(ConfigListScreen, Screen): def __init__(self, session): Screen.__init__(self, session) Screen.setTitle(self, _("Fallback tuner setup")) self.skinName = ["FallbackTunerSetup", "Setup"] self.onChangedEntry = [] self.session = session ConfigListScreen.__init__(self, [], session=session, on_change=self.changedEntry) self["actions2"] = ActionMap( ["SetupActions"], { "ok": self.run, "menu": self.keyCancel, "cancel": self.keyCancel, "save": self.run, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(_("Save")) self["description"] = Label("") self["VKeyIcon"] = Boolean(False) self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self.force_update_list = False self.createConfig() self.createSetup() self.remote_fallback_prev = config.usage.remote_fallback_import.value self["config"].onSelectionChanged.append(self.selectionChanged) self.selectionChanged() def createConfig(self): def set_avahiselect_seperate(configElement): self.seperateBoxes = [("same", _("Same as stream")) ] + self.peerStreamingBoxes if configElement.value not in ( "url", "ip") and configElement.value in self.seperateBoxes: self.seperateBoxes.remove(configElement.value) default = config.usage.remote_fallback_import_url.value if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value != config.usage.remote_fallback.value else "same" self.avahiselect_seperate = ConfigSelection( default=default, choices=self.seperateBoxes) default = config.usage.remote_fallback_dvb_t.value if config.usage.remote_fallback_dvb_t.value and config.usage.remote_fallback_dvb_t.value != config.usage.remote_fallback.value else "same" self.avahi_dvb_t = ConfigSelection(default=default, choices=self.seperateBoxes) default = config.usage.remote_fallback_dvb_c.value if config.usage.remote_fallback_dvb_c.value and config.usage.remote_fallback_dvb_c.value != config.usage.remote_fallback.value else "same" self.avahi_dvb_c = ConfigSelection(default=default, choices=self.seperateBoxes) default = config.usage.remote_fallback_atsc.value if config.usage.remote_fallback_atsc.value and config.usage.remote_fallback_atsc.value != config.usage.remote_fallback.value else "same" self.avahi_atsc = ConfigSelection(default=default, choices=self.seperateBoxes) self.peerStreamingBoxes = getPeerStreamingBoxes() + [ ("ip", _("Enter IP address")), ("url", _("Enter URL")) ] peerDefault = peerDefault_sepearate = None if config.usage.remote_fallback.value: peerDefault = peerDefault_sepearate = config.usage.remote_fallback.value if config.usage.remote_fallback.value and config.usage.remote_fallback.value not in self.peerStreamingBoxes: self.peerStreamingBoxes = [config.usage.remote_fallback.value ] + self.peerStreamingBoxes if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value not in self.peerStreamingBoxes: self.peerStreamingBoxes = [ config.usage.remote_fallback_import_url.value ] + self.peerStreamingBoxes if config.usage.remote_fallback_dvb_t.value and config.usage.remote_fallback_dvb_t.value not in self.peerStreamingBoxes: self.peerStreamingBoxes = [ config.usage.remote_fallback_dvb_t.value ] + self.peerStreamingBoxes if config.usage.remote_fallback_dvb_c.value and config.usage.remote_fallback_dvb_c.value not in self.peerStreamingBoxes: self.peerStreamingBoxes = [ config.usage.remote_fallback_dvb_c.value ] + self.peerStreamingBoxes if config.usage.remote_fallback_atsc.value and config.usage.remote_fallback_atsc.value not in self.peerStreamingBoxes: self.peerStreamingBoxes = [ config.usage.remote_fallback_atsc.value ] + self.peerStreamingBoxes self.avahiselect = ConfigSelection(default=peerDefault, choices=self.peerStreamingBoxes) self.avahiselect.addNotifier(set_avahiselect_seperate) try: ipDefault = [ int(x) for x in config.usage.remote_fallback.value.split(":") [1][2:].split(".") ] portDefault = int(config.usage.remote_fallback.value.split(":")[2]) except: ipDefault = [0, 0, 0, 0] portDefault = 8001 self.ip = ConfigIP(default=ipDefault, auto_jump=True) self.port = ConfigInteger(default=portDefault, limits=(1, 65535)) self.ip_seperate = ConfigIP(default=ipDefault, auto_jump=True) self.port_seperate = ConfigInteger(default=portDefault, limits=(1, 65535)) self.ip_dvb_t = ConfigIP(default=ipDefault, auto_jump=True) self.port_dvb_t = ConfigInteger(default=portDefault, limits=(1, 65535)) self.ip_dvb_c = ConfigIP(default=ipDefault, auto_jump=True) self.port_dvb_c = ConfigInteger(default=portDefault, limits=(1, 65535)) self.ip_atsc = ConfigIP(default=ipDefault, auto_jump=True) self.port_atsc = ConfigInteger(default=portDefault, limits=(1, 65535)) def createSetup(self): self.list = [] self.list.append( getConfigListEntry( _("Enable fallback remote receiver"), config.usage.remote_fallback_enabled, _("Enable remote enigma2 receiver to be tried to tune into services that cannot be tuned into locally (e.g. tuner is occupied or service type is unavailable on the local tuner. Specify complete URL including http:// and port number (normally ...:8001), e.g. http://second_box:8001." ))) self.list.append( getConfigListEntry( _("Import from remote receiver URL"), config.usage.remote_fallback_import, _("Import channels and/or EPG from remote receiver URL when receiver is booted" ))) if config.usage.remote_fallback_enabled.value or config.usage.remote_fallback_import.value: self.list.append( getConfigListEntry( _("Enable import timer from fallback tuner"), config.usage.remote_fallback_external_timer, _("When enabled the timer from the fallback tuner is imported" ))) self.list.append( getConfigListEntry( _("Fallback remote receiver"), self.avahiselect, _("Destination of fallback remote receiver"))) if self.avahiselect.value == "ip": self.list.append( getConfigListEntry(_("Fallback remote receiver IP"), self.ip, _("IP of fallback remote receiver"))) self.list.append( getConfigListEntry(_("Fallback remote receiver Port"), self.port, _("Port of fallback remote receiver"))) if self.avahiselect.value == "url": self.list.append( getConfigListEntry(_("Fallback remote receiver URL"), config.usage.remote_fallback, _("URL of fallback remote receiver"))) if config.usage.remote_fallback_enabled.value and config.usage.remote_fallback_import.value and config.usage.remote_fallback.value: self.list.append( getConfigListEntry(_("Import remote receiver URL"), self.avahiselect_seperate, _("URL of fallback remote receiver"))) if self.avahiselect_seperate.value == "ip": self.list.append( getConfigListEntry(_("Fallback remote receiver IP"), self.ip_seperate, _("IP of fallback remote receiver"))) self.list.append( getConfigListEntry(_("Fallback remote receiver Port"), self.port_seperate, _("Port of fallback remote receiver"))) if self.avahiselect_seperate.value == "url": self.list.append( getConfigListEntry(_("Fallback remote receiver URL"), config.usage.remote_fallback_import_url, _("URL of fallback remote receiver"))) if config.usage.remote_fallback_enabled.value and config.usage.remote_fallback_import.value: self.list.append( getConfigListEntry( _("Also import at reboot/restart enigma2"), config.usage.remote_fallback_import_restart, _("Import channels and/or EPG from remote receiver URL when receiver or enigma2 is restarted" ))) self.list.append( getConfigListEntry( _("Also import when box is leaving standby"), config.usage.remote_fallback_import_standby, _("Import channels and/or EPG from remote receiver URL also when the receiver is getting out of standby" ))) self.list.append( getConfigListEntry( _("Also import from the extension menu"), config.usage.remote_fallback_extension_menu, _("Make it possible to manually initiate the channels import and/or EPG via the extension menu" ))) self.list.append( getConfigListEntry( _("Show notification when import channels was successful"), config.usage.remote_fallback_ok, _("Show notification when import channels and/or EPG from remote receiver URL is completed" ))) self.list.append( getConfigListEntry( _("Show notification when import channels was not successful" ), config.usage.remote_fallback_nok, _("Show notification when import channels and/or EPG from remote receiver URL did not complete" ))) self.list.append( getConfigListEntry( _("Customize OpenWebIF settings for fallback tuner"), config.usage.remote_fallback_openwebif_customize, _("When enabled you can customize the OpenWebIf settings for the fallback tuner" ))) if config.usage.remote_fallback_openwebif_customize.value: self.list.append( getConfigListEntry( _("User ID"), config.usage.remote_fallback_openwebif_userid, _("Set the User ID of the OpenWebif from your fallback tuner" ))) self.list.append( getConfigListEntry( _("Password"), config.usage.remote_fallback_openwebif_password, _("Set the password of the OpenWebif from your fallback tuner" ))) self.list.append( getConfigListEntry( _("Port"), config.usage.remote_fallback_openwebif_port, " %s" % _("Set the port of the OpenWebif from your fallback tuner" ))) if config.usage.remote_fallback_enabled.value and config.usage.remote_fallback.value: self.list.append( getConfigListEntry( _("Alternative URLs for DVB-T/C or ATSC"), config.usage.remote_fallback_alternative, _("Set alternative fallback tuners for DVB-T/C or ATSC"))) if config.usage.remote_fallback_alternative.value: self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver for DVB-T"), self.avahi_dvb_t, _("Destination of fallback remote receiver for DVB-T")) ) if self.avahi_dvb_t.value == "ip": self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver IP"), self.ip_dvb_t, _("IP of fallback remote receiver"))) self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver Port"), self.port_dvb_t, _("Port of fallback remote receiver"))) if self.avahi_dvb_t.value == "url": self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver URL"), config.usage.remote_fallback_dvb_t, _("URL of fallback remote receiver"))) self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver for DVB-C"), self.avahi_dvb_c, _("Destination of fallback remote receiver for DVB-C")) ) if self.avahi_dvb_c.value == "ip": self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver IP"), self.ip_dvb_c, _("IP of fallback remote receiver"))) self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver Port"), self.port_dvb_c, _("Port of fallback remote receiver"))) if self.avahi_dvb_c.value == "url": self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver URL"), config.usage.remote_fallback_dvb_c, _("URL of fallback remote receiver"))) self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver for ATSC"), self.avahi_atsc, _("Destination of fallback remote receiver for ATSC"))) if self.avahi_atsc.value == "ip": self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver IP"), self.ip_atsc, _("IP of fallback remote receiver"))) self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver Port"), self.port_atsc, _("Port of fallback remote receiver"))) if self.avahi_atsc.value == "url": self.list.append( getConfigListEntry( " %s" % _("Fallback remote receiver URL"), config.usage.remote_fallback_atsc, _("URL of fallback remote receiver"))) self["config"].list = self.list self["config"].l.setList(self.list) def selectionChanged(self): if self.force_update_list: self["config"].onSelectionChanged.remove(self.selectionChanged) self.createSetup() self["config"].onSelectionChanged.append(self.selectionChanged) self.force_update_list = False if not (isinstance(self["config"].getCurrent()[1], ConfigBoolean) or isinstance(self["config"].getCurrent()[1], ConfigSelection)): self.force_update_list = True self["description"].setText(self.getCurrentDescription()) def changedEntry(self): if isinstance(self["config"].getCurrent()[1], ConfigBoolean) or isinstance( self["config"].getCurrent()[1], ConfigSelection): self.createSetup() def run(self): if self.avahiselect.value == "ip": config.usage.remote_fallback.value = "http://%d.%d.%d.%d:%d" % ( tuple(self.ip.value) + (self.port.value, )) elif self.avahiselect.value != "url": config.usage.remote_fallback.value = self.avahiselect.value if self.avahiselect_seperate.value == "ip": config.usage.remote_fallback_import_url.value = "http://%d.%d.%d.%d:%d" % ( tuple(self.ip_seperate.value) + (self.port_seperate.value, )) elif self.avahiselect_seperate.value == "same": config.usage.remote_fallback_import_url.value = "" elif self.avahiselect_seperate.value != "url": config.usage.remote_fallback_import_url.value = self.avahiselect_seperate.value if config.usage.remote_fallback_alternative.value and not ( self.avahi_dvb_t.value == self.avahi_dvb_c.value == self.avahi_atsc.value == "same"): if self.avahi_dvb_t.value == "ip": config.usage.remote_fallback_dvb_t.value = "http://%d.%d.%d.%d:%d" % ( tuple(self.ip_dvb_t.value) + (self.port_dvb_t.value, )) elif self.avahi_dvb_t.value == "same": config.usage.remote_fallback_dvb_t.value = config.usage.remote_fallback.value elif self.avahi_dvb_t.value != "url": config.usage.remote_fallback_dvb_t.value = self.avahi_dvb_t.value if self.avahi_dvb_c.value == "ip": config.usage.remote_fallback_dvb_c.value = "http://%d.%d.%d.%d:%d" % ( tuple(self.ip_dvb_c.value) + (self.port_dvb_c.value, )) elif self.avahi_dvb_c.value == "same": config.usage.remote_fallback_dvb_c.value = config.usage.remote_fallback.value elif self.avahi_dvb_c.value != "url": config.usage.remote_fallback_dvb_c.value = self.avahi_dvb_c.value if self.avahi_atsc.value == "ip": config.usage.remote_fallback_atsc.value = "http://%d.%d.%d.%d:%d" % ( tuple(self.ip_atsc.value) + (self.port_atsc.value, )) elif self.avahi_atsc.value == "same": config.usage.remote_fallback_atsc.value = config.usage.remote_fallback.value elif self.avahi_atsc.value != "url": config.usage.remote_fallback_atsc.value = self.avahi_atsc.value else: config.usage.remote_fallback_dvb_t.value = config.usage.remote_fallback_dvb_c.value = config.usage.remote_fallback_atsc.value = "" config.usage.remote_fallback_alternative.value = False if config.usage.remote_fallback_import_url.value == config.usage.remote_fallback.value: config.usage.remote_fallback_import_url.value = "" config.usage.remote_fallback_enabled.save() config.usage.remote_fallback_import.save() config.usage.remote_fallback_import_url.save() config.usage.remote_fallback_import_restart.save() config.usage.remote_fallback_import_standby.save() config.usage.remote_fallback_extension_menu.save() config.usage.remote_fallback_ok.save() config.usage.remote_fallback_nok.save() config.usage.remote_fallback.save() config.usage.remote_fallback_external_timer.save() config.usage.remote_fallback_openwebif_customize.save() config.usage.remote_fallback_openwebif_userid.save() config.usage.remote_fallback_openwebif_password.save() config.usage.remote_fallback_openwebif_port.save() config.usage.remote_fallback_alternative.save() config.usage.remote_fallback_dvb_t.save() config.usage.remote_fallback_dvb_c.save() config.usage.remote_fallback_atsc.save() configfile.save() if not self.remote_fallback_prev and config.usage.remote_fallback_import.value: ImportChannels() self.close(False)
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, menu_path=""): Screen.__init__(self, session) self.menu_path = menu_path self.skinName = "Setup" self["menu_path_compressed"] = 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["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.value) ) + '/' in locations or Components.Harddisk.findMountPoint( os.path.realpath(configele.value)) in locations: if fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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.value 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.value 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.value tmp = config.usage.allowed_timeshift_paths.value 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.value: self["config"].list.sort() def layoutFinished(self): if config.usage.show_menupath.value == 'large' and self.menu_path: title = self.menu_path + _(self.setup_title) self["menu_path_compressed"].setText("") elif config.usage.show_menupath.value == 'small': title = _(self.setup_title) self["menu_path_compressed"].setText( self.menu_path + " >" if not self.menu_path.endswith(' / ') else self.menu_path[:-3] + " >" or "") else: title = _(self.setup_title) self["menu_path_compressed"].setText("") self.setup_title = title self.setTitle(title) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value 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.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.timeshift_dirname.value 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.value) ) + '/' in locations or Components.Harddisk.findMountPoint( os.path.realpath( config.usage.timeshift_path.value)) in locations: config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.timeshift_path.save() self.saveAll() self.close() else: if int(config.timeshift.startdelay.value) > 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.value, type=MessageBox.TYPE_ERROR) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() else: if int(config.timeshift.startdelay.value) > 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.value, 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.value and not item.value == "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 VcsProfileSetup(ConfigListScreen, Screen): skin = """ <screen name="VcsProfileSetup" position="center,center" size="550,350" title="%s" backgroundColor="transparent" flags="wfNoBorder" > <widget source="header" render="Label" position="0,0" zPosition="1" size="550,80" halign="center" valign="center" noWrap="1" font="Regular;26" foregroundColor="red" backgroundColor="background" shadowColor="black" shadowOffset="-2,-2" transparent="1"/> <widget name="config" position="0,100" size="550,200" scrollbarMode="showOnDemand" zPosition="1" foregroundColor="white" backgroundColor="transparent" /> <ePixmap pixmap="skin_default/buttons/red.png" position="135,310" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/green.png" position="275,310" size="140,40" alphatest="on" /> <widget source="key_red" render="Label" position="135,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" /> <widget source="key_green" render="Label" position="275,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" /> </screen>""" % (_('%s: Profile Setup')%(PLUGIN_NAME)) def __init__(self, session, profile): Screen.__init__(self, session) self["header"] = StaticText("") self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("OK")) self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], { "red": self.cancel, "green": self.save, "save": self.save, "cancel": self.cancel, "ok": self.keyOk, }, -2) self.pf_saved_value = profile.saved_value self.prev_stretch = getStretch() self.prev_aspect = getAspect() self.prev_cliprect = getClipRect() self.initConfig(profile) ConfigListScreen.__init__(self, []) self.createSetup() self.onClose.append(self.__onClose) def __onClose(self): setStretch(self.prev_stretch) setAspect(self.prev_aspect) setClipRect(self.prev_cliprect) def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() def keyOk(self): cur = self["config"].getCurrent() if cur[1] in (self.clip.X,self.clip.Y,self.clip.W,self.clip.H): from Components.Input import Input from Screens.InputBox import InputBox from Tools.BoundFunction import boundFunction self.session.openWithCallback(boundFunction(self.setSliderStep, cur[1]), InputBox, title=_("Set slider step (1 - 20):"), text=str(cur[1].increment), type = Input.NUMBER) def setSliderStep(self, slider, step): if step and (0 < int(step) < 21): slider.increment = int(step) self["config"].instance.invalidate() def initConfig(self, pf): self.profile = pf self.clip = ConfigSubsection() self.clip.X = ConfigSlider(default = pf.cliprect.value[0], increment = 5, limits = (0, 719)) self.clip.Y = ConfigSlider(default = pf.cliprect.value[1], increment = 5, limits = (0, 575)) self.clip.W = ConfigSlider(default = pf.cliprect.value[2], increment = 5, limits = (0, 720)) self.clip.H = ConfigSlider(default = pf.cliprect.value[3], increment = 5, limits = (0, 576)) self.pf_stretch = ConfigSelection([("0",_("no")), ("1", _("yes"))], default = pf.stretch.value) self.pf_aspect = ConfigSelection([(0, _("4:3 Letterbox")), (1, _("4:3 PanScan")), (2, _("16:9")), (3, _("16:9 always")), (4, _("16:10 Letterbox")), (5, _("16:10 PanScan")), (6, _("16:9 Letterbox"))], default = pf.aspect.value) self.pf_aspect.addNotifier(self.aspectSettingChanged) self.pf_stretch.addNotifier(self.stretchSettingChanged) for elem in [self.clip.X,self.clip.Y,self.clip.W,self.clip.H]: elem.addNotifier(self.videoSettingChanged) def newConfig(self): pass def createSetup(self): list = [ ] list.append(getConfigListEntry(_("Profile Name"), self.profile.name)) list.append(getConfigListEntry(_("Enable Profile"), self.profile.enabled)) list.append(getConfigListEntry(_("Use Video Stretch (3D content)"), self.pf_stretch)) list.append(getConfigListEntry(_("Aspect Ratio"), self.pf_aspect)) list.append(getConfigListEntry(_("Video Left"), self.clip.X)) list.append(getConfigListEntry(_("Video Width"), self.clip.W)) list.append(getConfigListEntry(_("Video Top"), self.clip.Y)) list.append(getConfigListEntry(_("Video Height"), self.clip.H)) self["config"].list = list self["config"].l.setList(list) def save(self): self.profile.cliprect.value = [self.clip.X.value,self.clip.Y.value,self.clip.W.value,self.clip.H.value] self.profile.stretch.value = self.pf_stretch.value self.profile.aspect.value = self.pf_aspect.value self.profile.save() self.close(True, self.profile) def cancel(self): for x in self["config"].list: x[1].cancel() if self.pf_saved_value: self.profile.saved_value = self.pf_saved_value self.close(False, self.profile) def stretchSettingChanged(self, elem): setStretch(int(elem.value)) def aspectSettingChanged(self, elem): setAspect(int(elem.value)) self.updateHeaderText() def videoSettingChanged(self, elem): if self.clip.X.value + self.clip.W.value > 720: self.clip.W.value = 720 - self.clip.X.value if self.clip.Y.value + self.clip.H.value > 576: self.clip.H.value = 576 - self.clip.Y.value if "config" in self: self["config"].instance.invalidate() setClipRect([self.clip.X.value,self.clip.Y.value,self.clip.W.value,self.clip.H.value]) self.updateHeaderText() def updateHeaderText(self): if "header" in self: self["header"].setText("%s\n[%d, %d, %d, %d]"%(getAspectString(self.pf_aspect.value),self.clip.X.value,self.clip.Y.value,self.clip.W.value,self.clip.H.value))
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) 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', 'cifs')) 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.value)) + '/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(configele.value)) in locations: if fileExists(configele.value, 'w'): configele.last_value = configele.value return True else: dir = configele.value 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.value configele.value = configele.last_value self.session.open(MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.') % dir, type=MessageBox.TYPE_ERROR) return False else: dir = configele.value configele.value = configele.last_value self.session.open(MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.') % dir, type=MessageBox.TYPE_ERROR) return False def createSetup(self): default = config.usage.timeshift_path.value cooldefault = config.usage.autorecord_path.value tmp = config.usage.allowed_timeshift_paths.value cooltmp = config.usage.allowed_autorecord_paths.value if default not in tmp: tmp = tmp[:] tmp.append(default) if cooldefault not in cooltmp: cooltmp = cooltmp[:] cooltmp.append(cooldefault) 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.value: self['config'].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) def ok(self): currentry = self['config'].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value self.lastautorecorddirs = config.usage.allowed_autorecord_paths.value if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value self.session.openWithCallback(self.dirnameSelected, TimeshiftLocationBox) if currentry == self.autorecord_entry: self.entrydirname = self.autorecord_dirname config.usage.autorecord_path.value = self.autorecord_dirname.value 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', 'cifs')) 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.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.timeshift_dirname.value 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.value != self.lastautorecorddirs: tmp = config.usage.allowed_autorecord_paths.value default = self.autorecord_dirname.value 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, NFS or CIFS 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, NFS or CIFS 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() def keySave(self): import os.path import Components.Harddisk supported_filesystems = frozenset(('ext4', 'ext3', 'ext2', 'nfs', 'cifs')) 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.value)) + '/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(config.usage.timeshift_path.value)) in locations: config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.timeshift_path.save() self.saveAll() self.close() elif int(config.timeshift.startdelay.value) > 0: self.session.open(MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.') % config.usage.timeshift_path.value, type=MessageBox.TYPE_ERROR) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() elif int(config.timeshift.startdelay.value) > 0: self.session.open(MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.') % config.usage.timeshift_path.value, 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 self.levelChanged not 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.value and not item.value == '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 item = b if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class Config(ConfigListScreen, Screen): skin = """ <screen position="center,center" size="560,400" title="AutoBackup Configuration" > <ePixmap name="red" position="0,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" /> <ePixmap name="green" position="140,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" /> <ePixmap name="yellow" position="280,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" /> <ePixmap name="blue" position="420,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" /> <widget name="key_red" position="0,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_green" position="140,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_yellow" position="280,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_blue" position="420,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="config" position="10,40" size="540,200" scrollbarMode="showOnDemand" /> <widget name="statusbar" position="10,250" size="470,20" font="Regular;18" /> <widget name="status" position="10,280" size="540,130" font="Console;14" /> <ePixmap alphatest="on" pixmap="skin_default/icons/clock.png" position="480,383" size="14,14" zPosition="3"/> <widget font="Regular;18" halign="left" position="505,380" render="Label" size="55,20" source="global.CurrentTime" transparent="1" valign="center" zPosition="3"> <convert type="ClockToText">Default</convert> </widget> </screen>""" def __init__(self, session, args=0): self.session = session self.skinName = ["Config_AutoBackup", "Config"] self.setup_title = _("AutoBackup Configuration") Screen.__init__(self, session) cfg = config.plugins.autobackup choices = getLocationChoices() if choices: currentwhere = cfg.where.value defaultchoice = choices[0][0] for k, v in choices: if k == currentwhere: defaultchoice = k break else: defaultchoice = "" choices = [("", _("Nowhere"))] self.cfgwhere = ConfigSelection(default=defaultchoice, choices=choices) configList = [ getConfigListEntry(_("Backup location"), self.cfgwhere), getConfigListEntry(_("Daily automatic backup"), cfg.enabled), getConfigListEntry(_("Automatic start time"), cfg.wakeup), getConfigListEntry(_("Create Autoinstall"), cfg.autoinstall), getConfigListEntry(_("EPG cache backup"), cfg.epgcache), getConfigListEntry(_("Save previous backup"), cfg.prevbackup), ] ConfigListScreen.__init__(self, configList, session=session, on_change=self.changedEntry) self["key_red"] = Button(_("Cancel")) self["key_green"] = Button(_("Ok")) self["key_yellow"] = Button(_("Manual")) self["key_blue"] = Button("") self["statusbar"] = Label() self["status"] = ScrollLabel('', showscrollbar=False) self["setupActions"] = ActionMap( ["SetupActions", "ColorActions", "MenuActions"], { "red": self.cancel, "green": self.save, "yellow": self.dobackup, "blue": self.disable, "save": self.save, "cancel": self.cancel, "ok": self.save, "menu": self.menu, }, -2) self.onChangedEntry = [] self.data = '' self.container = enigma.eConsoleAppContainer() self.container.appClosed.append(self.appClosed) self.container.dataAvail.append(self.dataAvail) self.cfgwhere.addNotifier(self.changedWhere) self.onClose.append(self.__onClose) self.setTitle(_("AutoBackup Configuration")) # 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 def changedWhere(self, cfg): self.isActive = False self.hasAutoinstall = False if not cfg.value: self["status"].setText( _("No suitable media found, insert USB stick, flash card or harddisk." )) self.isActive = False else: config.plugins.autobackup.where.value = cfg.value path = os.path.join(cfg.value, 'backup') if not os.path.exists(path): self["status"].setText(_("No backup present")) else: self.hasAutoinstall = os.path.exists( os.path.join(path, "autoinstall")) try: st = os.stat(os.path.join(path, ".timestamp")) try: macaddr = open('/sys/class/net/eth0/address').read( ).strip().replace(':', '') fn = "AutoBackup%s.tar.gz" % macaddr st = os.stat(os.path.join(path, fn)) if not self.hasAutoinstall: self.hasAutoinstall = os.path.exists( os.path.join(path, "autoinstall" + macaddr)) except: # No box-specific backup found pass self.isActive = True self["status"].setText( _("Last backup date") + ": " + " ".join(FuzzyTime(st.st_mtime, inPast=True))) except Exception, ex: print "Failed to stat %s: %s" % (path, ex) self["status"].setText(_("Disabled")) if self.isActive: self["key_blue"].setText(_("Disable")) else: self["key_blue"].setText("")
class RecordPathsSettings(Screen,ConfigListScreen): def __init__(self, session): from Components.Sources.StaticText import StaticText Screen.__init__(self, session) self.skinName = "RecordPathsSettings" self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self["key_yellow"] = StaticText() self["key_blue"] = StaticText() self["introduction"] = StaticText() ConfigListScreen.__init__(self, []) self.initConfigList() self["setupActions"] = ActionMap(["SetupActions", "ColorActions"], { "green": self.save, "red": self.cancel, "cancel": self.cancel, "ok": self.ok, }, -2) def checkReadWriteDir(self, configele): print "checkReadWrite: ", configele.value if configele.value in [x[0] for x in self.styles] or configele.value in [x[0] for x in self.storage_styles] or fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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 initConfigList(self): self.styles = [ ("<default>", _("<Default movie location>")), ("<current>", _("<Current movielist location>")), ("<timer>", _("<Last timer location>")) ] styles_keys = [x[0] for x in self.styles] mountpoints = [ (p.mountpoint, p.description) for p in harddiskmanager.getConfiguredStorageDevices() if p.isInitialized] mountpoints.sort(reverse = True) self.storage_styles = [ ("<undefined>", _("<No default storage device selected.>"))] self.storage_styles += mountpoints storage_styles_keys = [x[0] for x in self.storage_styles] default = defaultStorageDevice() if default not in storage_styles_keys: p = harddiskmanager.getDefaultStorageDevicebyUUID(default) if p is not None: default = p.mountpoint if p.mountpoint not in storage_styles_keys: self.storage_styles.append((p.mountpoint, p.description)) else: cfg_uuid = config.storage.get(default, None) if cfg_uuid is not None: if cfg_uuid["enabled"].value: default = cfg_uuid["mountpoint"].value if default not in storage_styles_keys: description = cfg_uuid["device_description"].value.split()[0] or "" description += " ( " + _("Offline") + " )" self.storage_styles.append((default, description )) else: default = "<undefined>" else: default = "<undefined>" print "DefaultDevice: ", default, self.storage_styles self.default_device = ConfigSelection(default = default, choices = self.storage_styles) tmp = config.movielist.videodirs.value default = config.usage.default_path.value 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.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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) default = config.usage.timeshift_path.value tmp = config.usage.allowed_timeshift_paths.value 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.last_value = self.timeshift_dirname.value self.default_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.default_dirname.last_value = self.default_dirname.value self.timer_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.timer_dirname.last_value = self.timer_dirname.value self.instantrec_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.instantrec_dirname.last_value = self.instantrec_dirname.value self.timeshift_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.timeshift_dirname.last_value = self.timeshift_dirname.value self.list = [] self.device_entry = getConfigListEntry(_("Default storage device"), self.default_device) self.list.append(self.device_entry) if config.usage.setup_level.index >= 2: self.default_entry = getConfigListEntry(_("Default movie location"), self.default_dirname) self.list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer record location"), self.timer_dirname) self.list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry(_("Instant record location"), self.instantrec_dirname) self.list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname) self.list.append(self.default_entry) self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname) self.list.append(self.timeshift_entry) self["config"].setList(self.list) if not self.selectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.selectionChanged) def selectionChanged(self): currentry = self["config"].getCurrent() if currentry == self.device_entry: self["introduction"].setText(_("Please select the default storage device you want to use for recordings. This device gets mounted to /media/hdd.")) elif currentry == self.default_entry: self["introduction"].setText(_("Please select the default movielist location which is used for recordings.")) elif currentry == self.timeshift_entry: self["introduction"].setText(_("Please select the timeshift location which is used for storing timeshift recordings.")) if config.usage.setup_level.index >= 2: if currentry == self.timer_entry: self["introduction"].setText(_("Please select the default timer record location which is used for timer based recordings.")) elif currentry == self.instantrec_entry: self["introduction"].setText(_("Please select the default instant record location which is used for instant recordings.")) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value 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.value)) elif currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value self.session.openWithCallback(self.dirnameSelected, TimeshiftLocationBox) if config.usage.setup_level.index >= 2: if currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback(self.dirnameSelected, MovieLocationBox,_("Initial location in new timers"), preferredPath(self.timer_dirname.value)) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback(self.dirnameSelected, MovieLocationBox, _("Location for instant recordings"), preferredPath(self.instantrec_dirname.value)) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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 config.usage.allowed_timeshift_paths.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.instantrec_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if self.entrydirname.last_value != res: self.checkReadWriteDir(self.entrydirname) def save(self): currentry = self["config"].getCurrent() defaultChanged = None if self.checkReadWriteDir(currentry[1]): config.usage.default_path.value = self.default_dirname.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.default_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() config.usage.timeshift_path.save() if self.default_device.value != "/media/hdd": if self.default_device.value != "<undefined>": #changing default ? tmp = harddiskmanager.getPartitionbyMountpoint(self.default_device.value) if tmp is not None: defaultChanged = harddiskmanager.changeStorageDevice(tmp.uuid, "mount_default", None) else: #disabling default ? p = harddiskmanager.getDefaultStorageDevicebyUUID(defaultStorageDevice()) if p is not None: defaultChanged = harddiskmanager.changeStorageDevice(defaultStorageDevice(), "unmount", None) if defaultChanged is None: self.close() elif defaultChanged is False: self.session.open(MessageBox, _("There was en error while configuring your storage device."), MessageBox.TYPE_ERROR) else: self.close() def cancel(self): self.close()
class NimSetup(Screen, ConfigListScreen, ServiceStopScreen): def createSimpleSetup(self, list, mode): nim = self.nimConfig if mode == "single": self.singleSatEntry = getConfigListEntry(_("Satellite"), nim.diseqcA) list.append(self.singleSatEntry) if nim.diseqcA.value in ("360", "560"): list.append(getConfigListEntry(_("Use circular LNB"), nim.simpleDiSEqCSetCircularLNB)) list.append(getConfigListEntry(_("Send DiSEqC"), nim.simpleSingleSendDiSEqC)) else: list.append(getConfigListEntry(_("Port A"), nim.diseqcA)) if mode in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"): list.append(getConfigListEntry(_("Port B"), nim.diseqcB)) if mode == "diseqc_a_b_c_d": list.append(getConfigListEntry(_("Port C"), nim.diseqcC)) list.append(getConfigListEntry(_("Port D"), nim.diseqcD)) if mode != "toneburst_a_b": list.append(getConfigListEntry(_("Set voltage and 22KHz"), nim.simpleDiSEqCSetVoltageTone)) list.append(getConfigListEntry(_("Send DiSEqC only on satellite change"), nim.simpleDiSEqCOnlyOnSatChange)) def createPositionerSetup(self, list): nim = self.nimConfig if nim.diseqcMode.value == "positioner_select": self.selectSatsEntry = getConfigListEntry(_("Press OK to select satellites"), self.nimConfig.pressOKtoList) list.append(self.selectSatsEntry) list.append(getConfigListEntry(_("Longitude"), nim.longitude)) list.append(getConfigListEntry(" ", nim.longitudeOrientation)) list.append(getConfigListEntry(_("Latitude"), nim.latitude)) list.append(getConfigListEntry(" ", nim.latitudeOrientation)) if SystemInfo["CanMeasureFrontendInputPower"]: self.advancedPowerMeasurement = getConfigListEntry(_("Use power measurement"), nim.powerMeasurement) list.append(self.advancedPowerMeasurement) if nim.powerMeasurement.value: list.append(getConfigListEntry(_("Power threshold in mA"), nim.powerThreshold)) self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), nim.turningSpeed) list.append(self.turningSpeed) if nim.turningSpeed.value == "fast epoch": self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), nim.fastTurningBegin) self.turnFastEpochEnd = getConfigListEntry(_("End time"), nim.fastTurningEnd) list.append(self.turnFastEpochBegin) list.append(self.turnFastEpochEnd) else: if nim.powerMeasurement.value: nim.powerMeasurement.value = False nim.powerMeasurement.save() if not hasattr(self, 'additionalMotorOptions'): self.additionalMotorOptions = NoSave(ConfigYesNo(False)) self.showAdditionalMotorOptions = getConfigListEntry(_("Extra motor options"), self.additionalMotorOptions) self.list.append(self.showAdditionalMotorOptions) if self.additionalMotorOptions.value: self.list.append(getConfigListEntry(" " + _("Horizontal turning speed") + " [" + chr(176) + "/sec]", nim.turningspeedH)) self.list.append(getConfigListEntry(" " + _("Vertical turning speed") + " [" + chr(176) + "/sec]", nim.turningspeedV)) self.list.append(getConfigListEntry(" " + _("Turning step size") + " [" + chr(176) + "]", nim.tuningstepsize)) self.list.append(getConfigListEntry(" " + _("Max memory positions"), nim.rotorPositions)) def createConfigMode(self): if self.nim.isCompatible("DVB-S"): choices = {"nothing": _("Not configured"), "simple": _("Simple"), "advanced": _("Advanced")} if len(nimmanager.canEqualTo(self.slotid)) > 0: choices["equal"] = _("Equal to") if len(nimmanager.canDependOn(self.slotid)) > 0: choices["satposdepends"] = _("Second cable of motorized LNB") if len(nimmanager.canInternalConnectTo(self.slotid)) > 0: choices["loopthrough_internal"] = _("Internal loopthrough to") if len(nimmanager.canExternalConnectTo(self.slotid)) > 0: choices["loopthrough_external"] = _("External loopthrough to") if self.nim.isFBCLink(): choices = { "nothing": _("FBC automatic"), "advanced": _("FBC SCR (Unicable/JESS)")} self.nimConfig.configMode.setChoices(choices, self.nim.isFBCLink() and "nothing" or "simple") def createSetup(self): self.list = [ ] self.multiType = None self.configMode = None self.diseqcModeEntry = None self.advancedSatsEntry = None self.advancedLnbsEntry = None self.advancedDiseqcMode = None self.advancedUsalsEntry = None self.advancedLof = None self.advancedPowerMeasurement = None self.turningSpeed = None self.turnFastEpochBegin = None self.turnFastEpochEnd = None self.toneburst = None self.committedDiseqcCommand = None self.uncommittedDiseqcCommand = None self.commandOrder = None self.cableScanType = None self.cableConfigScanDetails = None self.have_advanced = False self.advancedUnicable = None self.advancedFormat = None self.advancedPosition = None self.advancedType = None self.advancedManufacturer = None self.advancedSCR = None self.advancedConnected = None self.showAdditionalMotorOptions = None self.selectSatsEntry = None self.advancedSelectSatsEntry = None self.singleSatEntry = None self.terrestrialRegionsEntry = None self.cableRegionsEntry = None if not hasattr(self, "terrestrialCountriesEntry"): self.terrestrialCountriesEntry = None if not hasattr(self, "cableCountriesEntry"): self.cableCountriesEntry = None self.toneamplitude = None self.scpc = None self.forcelnbpower = None self.forcetoneburst = None self.terrestrialRegionsEntry = None self.cableRegionsEntry = None if not hasattr(self, "terrestrialCountriesEntry"): self.terrestrialCountriesEntry = None if not hasattr(self, "cableCountriesEntry"): self.cableCountriesEntry = None if self.nim.isMultiType(): multiType = self.nimConfig.multiType self.multiType = getConfigListEntry(_("Tuner type"), multiType) self.list.append(self.multiType) if self.nim.isCompatible("DVB-S"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) if self.nimConfig.configMode.value == "simple": #simple setup self.diseqcModeEntry = getConfigListEntry(pgettext("Satellite configuration mode", "Mode"), self.nimConfig.diseqcMode) self.list.append(self.diseqcModeEntry) if self.nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"): self.createSimpleSetup(self.list, self.nimConfig.diseqcMode.value) if self.nimConfig.diseqcMode.value in ("positioner", "positioner_select"): self.createPositionerSetup(self.list) elif self.nimConfig.configMode.value == "equal": choices = [] nimlist = nimmanager.canEqualTo(self.nim.slot) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo)) elif self.nimConfig.configMode.value == "satposdepends": choices = [] nimlist = nimmanager.canDependOn(self.nim.slot) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo)) elif self.nimConfig.configMode.value == "loopthrough_internal": choices = [] print "internal connectable to:", nimmanager.canInternalConnectTo(self.slotid) connectable = nimmanager.canInternalConnectTo(self.slotid) for id in connectable: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Internal connected to"), self.nimConfig.connectedTo)) elif self.nimConfig.configMode.value == "loopthrough_external": choices = [] print "external connectable to:", nimmanager.canExternalConnectTo(self.slotid) connectable = nimmanager.canExternalConnectTo(self.slotid) for id in connectable: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("External connected to"), self.nimConfig.connectedTo)) elif self.nimConfig.configMode.value == "nothing": pass elif self.nimConfig.configMode.value == "advanced": # advanced # SATs self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats) self.list.append(self.advancedSatsEntry) current_config_sats = self.nimConfig.advanced.sats.value if current_config_sats in ("3605", "3606"): self.advancedSelectSatsEntry = getConfigListEntry(_("Press OK to select satellites"), self.nimConfig.pressOKtoList) self.list.append(self.advancedSelectSatsEntry) self.fillListWithAdvancedSatEntrys(self.nimConfig.advanced.sat[int(current_config_sats)]) else: cur_orb_pos = self.nimConfig.advanced.sats.orbital_position satlist = self.nimConfig.advanced.sat.keys() if cur_orb_pos is not None: if cur_orb_pos not in satlist: cur_orb_pos = satlist[0] self.fillListWithAdvancedSatEntrys(self.nimConfig.advanced.sat[cur_orb_pos]) self.have_advanced = True if self.nimConfig.configMode.value != "nothing" and config.usage.setup_level.index >= 2: if fileExists("/proc/stb/frontend/%d/tone_amplitude" % self.nim.slot): self.toneamplitude = getConfigListEntry(_("Tone amplitude"), self.nimConfig.toneAmplitude) self.list.append(self.toneamplitude) if fileExists("/proc/stb/frontend/%d/use_scpc_optimized_search_range" % self.nim.slot): self.scpc = getConfigListEntry(_("SCPC optimized search range"), self.nimConfig.scpcSearchRange) self.list.append(self.scpc) if SystemInfo["HasForceLNBOn"] and self.nim.isFBCRoot(): self.forcelnbpower = getConfigListEntry(_("Force LNB Power"), config.misc.forceLnbPower) self.list.append(self.forcelnbpower) if SystemInfo["HasForceToneburst"] and self.nim.isFBCRoot(): self.forcetoneburst = getConfigListEntry(_("Force ToneBurst"), config.misc.forceToneBurst) self.list.append(self.forcetoneburst) elif self.nim.isCompatible("DVB-C"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) if self.nimConfig.configMode.value == "enabled": self.list.append(getConfigListEntry(_("Network ID"), self.nimConfig.cable.scan_networkid)) self.cableScanType=getConfigListEntry(_("Used service scan type"), self.nimConfig.cable.scan_type) self.list.append(self.cableScanType) if self.nimConfig.cable.scan_type.value == "provider": # country/region tier one if self.cableCountriesEntry is None: cablecountrycodelist = nimmanager.getCablesCountrycodeList() cablecountrycode = nimmanager.getCableCountrycode(self.slotid) default = cablecountrycode in cablecountrycodelist and cablecountrycode or None choices = [("all", _("All"))]+sorted([(x, self.countrycodeToCountry(x)) for x in cablecountrycodelist], key=lambda listItem: listItem[1]) self.cableCountries = ConfigSelection(default = default, choices = choices) self.cableCountriesEntry = getConfigListEntry(_("Country"), self.cableCountries) self.originalCableRegion = self.nimConfig.cable.scan_provider.value # country/region tier two if self.cableCountries.value == "all": cableNames = [x[0] for x in sorted(sorted(nimmanager.getCablesList(), key=lambda listItem: listItem[0]), key=lambda listItem: self.countrycodeToCountry(listItem[2]))] else: cableNames = sorted([x[0] for x in nimmanager.getCablesByCountrycode(self.cableCountries.value)]) default = self.nimConfig.cable.scan_provider.value in cableNames and self.nimConfig.cable.scan_provider.value or None self.cableRegions = ConfigSelection(default = default, choices = cableNames) def updateCableProvider(configEntry): self.nimConfig.cable.scan_provider.value = configEntry.value self.nimConfig.cable.scan_provider.save() self.cableRegions.addNotifier(updateCableProvider) self.cableRegionsEntry = getConfigListEntry(_("Region"), self.cableRegions) self.list.append(self.cableCountriesEntry) self.list.append(self.cableRegionsEntry) else: self.cableConfigScanDetails = getConfigListEntry(_("Config Scan Details"), self.nimConfig.cable.config_scan_details) self.list.append(self.cableConfigScanDetails) if self.nimConfig.cable.config_scan_details.value: if self.nimConfig.cable.scan_type.value == "bands": # TRANSLATORS: option name, indicating which type of (DVB-C) band should be scanned. The name of the band is printed in '%s'. E.g.: 'Scan EU MID band' self.list.append(getConfigListEntry(_("Scan %s band") % ("EU VHF I"), self.nimConfig.cable.scan_band_EU_VHF_I)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU MID"), self.nimConfig.cable.scan_band_EU_MID)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU VHF III"), self.nimConfig.cable.scan_band_EU_VHF_III)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU UHF IV"), self.nimConfig.cable.scan_band_EU_UHF_IV)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU UHF V"), self.nimConfig.cable.scan_band_EU_UHF_V)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU SUPER"), self.nimConfig.cable.scan_band_EU_SUPER)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU HYPER"), self.nimConfig.cable.scan_band_EU_HYPER)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US LOW"), self.nimConfig.cable.scan_band_US_LOW)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US MID"), self.nimConfig.cable.scan_band_US_MID)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US HIGH"), self.nimConfig.cable.scan_band_US_HIGH)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US SUPER"), self.nimConfig.cable.scan_band_US_SUPER)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US HYPER"), self.nimConfig.cable.scan_band_US_HYPER)) else: self.list.append(getConfigListEntry(_("Frequency scan step size(khz)"), self.nimConfig.cable.scan_frequency_steps)) # TRANSLATORS: option name, indicating which type of (DVB-C) modulation should be scanned. The modulation type is printed in '%s'. E.g.: 'Scan QAM16' self.list.append(getConfigListEntry(_("Scan %s") % ("QAM16"), self.nimConfig.cable.scan_mod_qam16)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM32"), self.nimConfig.cable.scan_mod_qam32)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM64"), self.nimConfig.cable.scan_mod_qam64)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM128"), self.nimConfig.cable.scan_mod_qam128)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM256"), self.nimConfig.cable.scan_mod_qam256)) self.list.append(getConfigListEntry(_("Scan %s") % ("SR6900"), self.nimConfig.cable.scan_sr_6900)) self.list.append(getConfigListEntry(_("Scan %s") % ("SR6875"), self.nimConfig.cable.scan_sr_6875)) self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext1)) self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext2)) self.have_advanced = False elif self.nim.isCompatible("DVB-T"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) self.have_advanced = False if self.nimConfig.configMode.value == "enabled": # country/region tier one if self.terrestrialCountriesEntry is None: terrestrialcountrycodelist = nimmanager.getTerrestrialsCountrycodeList() terrestrialcountrycode = nimmanager.getTerrestrialCountrycode(self.slotid) default = terrestrialcountrycode in terrestrialcountrycodelist and terrestrialcountrycode or None choices = [("all", _("All"))]+sorted([(x, self.countrycodeToCountry(x)) for x in terrestrialcountrycodelist], key=lambda listItem: listItem[1]) self.terrestrialCountries = ConfigSelection(default = default, choices = choices) self.terrestrialCountriesEntry = getConfigListEntry(_("Country"), self.terrestrialCountries) self.originalTerrestrialRegion = self.nimConfig.terrestrial.value # country/region tier two if self.terrestrialCountries.value == "all": terrstrialNames = [x[0] for x in sorted(sorted(nimmanager.getTerrestrialsList(), key=lambda listItem: listItem[0]), key=lambda listItem: self.countrycodeToCountry(listItem[2]))] else: terrstrialNames = sorted([x[0] for x in nimmanager.getTerrestrialsByCountrycode(self.terrestrialCountries.value)]) default = self.nimConfig.terrestrial.value in terrstrialNames and self.nimConfig.terrestrial.value or None self.terrestrialRegions = ConfigSelection(default = default, choices = terrstrialNames) def updateTerrestrialProvider(configEntry): self.nimConfig.terrestrial.value = configEntry.value self.nimConfig.terrestrial.save() self.terrestrialRegions.addNotifier(updateTerrestrialProvider) self.terrestrialRegionsEntry = getConfigListEntry(_("Region"), self.terrestrialRegions) self.list.append(self.terrestrialCountriesEntry) self.list.append(self.terrestrialRegionsEntry) self.list.append(getConfigListEntry(_("Enable 5V for active antenna"), self.nimConfig.terrestrial_5V)) elif self.nim.isCompatible("ATSC"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) if self.nimConfig.configMode.value == "enabled": self.list.append(getConfigListEntry(_("ATSC provider"), self.nimConfig.atsc)) self.have_advanced = False else: self.have_advanced = False self["config"].list = self.list self["config"].l.setList(self.list) self.setTextKeyYellow() def newConfig(self): self.setTextKeyBlue() if self["config"].getCurrent() == self.multiType: update_slots = [self.slotid] from Components.NimManager import InitNimManager InitNimManager(nimmanager, update_slots) self.nim = nimmanager.nim_slots[self.slotid] self.nimConfig = self.nim.config if self["config"].getCurrent() in (self.configMode, self.diseqcModeEntry, self.advancedSatsEntry, self.advancedLnbsEntry, self.advancedDiseqcMode, self.advancedUsalsEntry,\ self.advancedLof, self.advancedPowerMeasurement, self.turningSpeed, self.advancedType, self.advancedSCR, self.advancedPosition, self.advancedFormat, self.advancedManufacturer,\ self.advancedUnicable, self.advancedConnected, self.toneburst, self.committedDiseqcCommand, self.uncommittedDiseqcCommand, self.singleSatEntry, self.commandOrder,\ self.showAdditionalMotorOptions, self.cableScanType, self.multiType, self.cableConfigScanDetails, self.terrestrialCountriesEntry, self.cableCountriesEntry, \ self.toneamplitude, self.scpc, self.forcelnbpower, self.forcetoneburst): self.createSetup() def run(self): if self.nimConfig.configMode.value == "simple": autodiseqc_ports = 0 if self.nimConfig.diseqcMode.value == "single": if self.nimConfig.diseqcA.orbital_position == 3600: autodiseqc_ports = 1 elif self.nimConfig.diseqcMode.value == "diseqc_a_b": if self.nimConfig.diseqcA.orbital_position == 3600 or self.nimConfig.diseqcB.orbital_position == 3600: autodiseqc_ports = 2 elif self.nimConfig.diseqcMode.value == "diseqc_a_b_c_d": if self.nimConfig.diseqcA.orbital_position == 3600 or self.nimConfig.diseqcB.orbital_position == 3600 or self.nimConfig.diseqcC.orbital_position == 3600 or self.nimConfig.diseqcD.orbital_position == 3600: autodiseqc_ports = 4 if autodiseqc_ports: self.autoDiseqcRun(autodiseqc_ports) return False if self.have_advanced and self.nim.config_mode == "advanced": self.fillAdvancedList() for x in self.list: if x in (self.turnFastEpochBegin, self.turnFastEpochEnd): # workaround for storing only hour*3600+min*60 value in configfile # not really needed.. just for cosmetics.. tm = localtime(x[1].value) dt = datetime(1970, 1, 1, tm.tm_hour, tm.tm_min) x[1].value = int(mktime(dt.timetuple())) x[1].save() nimmanager.sec.update() self.saveAll() return True def autoDiseqcRun(self, ports): self.stopService() self.session.openWithCallback(self.autoDiseqcCallback, AutoDiseqc, self.slotid, ports, self.nimConfig.simpleDiSEqCSetVoltageTone, self.nimConfig.simpleDiSEqCOnlyOnSatChange) def autoDiseqcCallback(self, result): from Screens.Wizard import Wizard if Wizard.instance is not None: Wizard.instance.back() else: self.restartPrevService(close=False) self.createSetup() def fillListWithAdvancedSatEntrys(self, Sat): lnbnum = int(Sat.lnb.value) currLnb = self.nimConfig.advanced.lnb[lnbnum] if isinstance(currLnb, ConfigNothing): currLnb = None # LNBs self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb) self.list.append(self.advancedLnbsEntry) if currLnb: if self.nim.isFBCLink(): currLnb.lof.value = "unicable" self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) self.advancedLof = getConfigListEntry("LOF", currLnb.lof) self.list.append(self.advancedLof) if currLnb.lof.value == "user_defined": self.list.append(getConfigListEntry("LOF/L", currLnb.lofl)) self.list.append(getConfigListEntry("LOF/H", currLnb.lofh)) self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) if currLnb.lof.value == "unicable": self.advancedUnicable = getConfigListEntry("SCR (Unicable/JESS) "+_("type"), currLnb.unicable) self.list.append(self.advancedUnicable) if currLnb.unicable.value == "unicable_user": self.advancedFormat = getConfigListEntry(_("Format"), currLnb.format) self.advancedPosition = getConfigListEntry(_("Position"), currLnb.positionNumber) self.advancedSCR = getConfigListEntry(_("Channel"), currLnb.scrList) self.list.append(self.advancedFormat) self.list.append(self.advancedPosition) self.list.append(self.advancedSCR) self.list.append(getConfigListEntry(_("Frequency"), currLnb.scrfrequency)) self.list.append(getConfigListEntry("LOF/L", currLnb.lofl)) self.list.append(getConfigListEntry("LOF/H", currLnb.lofh)) self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) else: self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableManufacturer) self.advancedType = getConfigListEntry(_("Model"), currLnb.unicableProduct) self.advancedSCR = getConfigListEntry(_("Channel"), currLnb.scrList) self.advancedPosition = getConfigListEntry(_("Position"), currLnb.positionNumber) self.list.append(self.advancedManufacturer) self.list.append(self.advancedType) if currLnb.positions.value > 1: self.list.append(self.advancedPosition) self.list.append(self.advancedSCR) choices = [] connectable = nimmanager.canInternalConnectTo(self.slotid) for id in connectable: choices.append((str(id), nimmanager.getNimDescription(id) + _(" (internal connection)"))) connectable = nimmanager.canExternalConnectTo(self.slotid) for id in connectable: choices.append((str(id), nimmanager.getNimDescription(id) + _(" (external connection)"))) if len(choices): if self.nim.isFBCLink(): if self.nimConfig.advanced.unicableconnected.value != True: self.nimConfig.advanced.unicableconnected.value = True self.advancedConnected = getConfigListEntry(_("connected"), self.nimConfig.advanced.unicableconnected) self.list.append(self.advancedConnected) if self.nimConfig.advanced.unicableconnected.value == True: self.nimConfig.advanced.unicableconnectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Connected to"),self.nimConfig.advanced.unicableconnectedTo)) print "[Satconfig] unicableconnectedTo choices : ", choices else: #no Unicable self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage)) self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode)) if lnbnum < 65: self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode) self.list.append(self.advancedDiseqcMode) if currLnb.diseqcMode.value != "none": self.list.append(getConfigListEntry(_("Fast DiSEqC"), currLnb.fastDiseqc)) self.toneburst = getConfigListEntry(_("Toneburst"), currLnb.toneburst) self.list.append(self.toneburst) self.committedDiseqcCommand = getConfigListEntry(_("DiSEqC 1.0 command"), currLnb.commitedDiseqcCommand) self.list.append(self.committedDiseqcCommand) if currLnb.diseqcMode.value == "1_0": if currLnb.toneburst.index and currLnb.commitedDiseqcCommand.index: self.list.append(getConfigListEntry(_("Command order"), currLnb.commandOrder1_0)) else: self.uncommittedDiseqcCommand = getConfigListEntry(_("DiSEqC 1.1 command"), currLnb.uncommittedDiseqcCommand) self.list.append(self.uncommittedDiseqcCommand) if currLnb.uncommittedDiseqcCommand.index: if currLnb.commandOrder.value == "ct": currLnb.commandOrder.value = "cut" elif currLnb.commandOrder.value == "tc": currLnb.commandOrder.value = "tcu" else: if currLnb.commandOrder.index & 1: currLnb.commandOrder.value = "tc" else: currLnb.commandOrder.value = "ct" self.commandOrder = getConfigListEntry(_("Command order"), currLnb.commandOrder) if 1 < ((1 if currLnb.uncommittedDiseqcCommand.index else 0) + (1 if currLnb.commitedDiseqcCommand.index else 0) + (1 if currLnb.toneburst.index else 0)): self.list.append(self.commandOrder) if currLnb.uncommittedDiseqcCommand.index: self.list.append(getConfigListEntry(_("DiSEqC 1.1 repeats"), currLnb.diseqcRepeats)) self.list.append(getConfigListEntry(_("Sequence repeat"), currLnb.sequenceRepeat)) if currLnb.diseqcMode.value == "1_2": if SystemInfo["CanMeasureFrontendInputPower"]: self.advancedPowerMeasurement = getConfigListEntry(_("Use power measurement"), currLnb.powerMeasurement) self.list.append(self.advancedPowerMeasurement) if currLnb.powerMeasurement.value: self.list.append(getConfigListEntry(_("Power threshold in mA"), currLnb.powerThreshold)) self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), currLnb.turningSpeed) self.list.append(self.turningSpeed) if currLnb.turningSpeed.value == "fast epoch": self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), currLnb.fastTurningBegin) self.turnFastEpochEnd = getConfigListEntry(_("End time"), currLnb.fastTurningEnd) self.list.append(self.turnFastEpochBegin) self.list.append(self.turnFastEpochEnd) else: if currLnb.powerMeasurement.value: currLnb.powerMeasurement.value = False currLnb.powerMeasurement.save() self.advancedUsalsEntry = getConfigListEntry(_("Use USALS for this sat"), Sat.usals) if lnbnum < 65: self.list.append(self.advancedUsalsEntry) if Sat.usals.value: self.list.append(getConfigListEntry(_("Longitude"), currLnb.longitude)) self.list.append(getConfigListEntry(" ", currLnb.longitudeOrientation)) self.list.append(getConfigListEntry(_("Latitude"), currLnb.latitude)) self.list.append(getConfigListEntry(" ", currLnb.latitudeOrientation)) else: self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition)) if not hasattr(self, 'additionalMotorOptions'): self.additionalMotorOptions = NoSave(ConfigYesNo(False)) self.showAdditionalMotorOptions = getConfigListEntry(_("Extra motor options"), self.additionalMotorOptions) self.list.append(self.showAdditionalMotorOptions) if self.additionalMotorOptions.value: self.list.append(getConfigListEntry(" " + _("Horizontal turning speed") + " [" + chr(176) + "/sec]", currLnb.turningspeedH)) self.list.append(getConfigListEntry(" " + _("Vertical turning speed") + " [" + chr(176) + "/sec]", currLnb.turningspeedV)) self.list.append(getConfigListEntry(" " + _("Turning step size") + " [" + chr(176) + "]", currLnb.tuningstepsize)) self.list.append(getConfigListEntry(" " + _("Max memory positions"), currLnb.rotorPositions)) def fillAdvancedList(self): self.list = [ ] self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats) self.list.append(self.advancedSatsEntry) for x in self.nimConfig.advanced.sat.keys(): Sat = self.nimConfig.advanced.sat[x] self.fillListWithAdvancedSatEntrys(Sat) self["config"].list = self.list def unicableconnection(self): if self.nimConfig.configMode.value == "advanced": connect_count = 0 dvbs_slots = nimmanager.getNimListOfType('DVB-S') dvbs_slots_len = len(dvbs_slots) for x in dvbs_slots: try: nim_slot = nimmanager.nim_slots[x] if nim_slot == self.nimConfig: self_idx = x if nim_slot.config.configMode.value == "advanced": if nim_slot.config.advanced.unicableconnected.value == True: connect_count += 1 except: pass print "[Satconfig] connections %d %d" %(connect_count, dvbs_slots_len) if connect_count >= dvbs_slots_len: return False self.slot_dest_list = [] def checkRecursiveConnect(slot_id): if slot_id in self.slot_dest_list: print slot_id return False self.slot_dest_list.append(slot_id) slot_config = nimmanager.nim_slots[slot_id].config if slot_config.configMode.value == "advanced": try: connected = slot_config.advanced.unicableconnected.value except: connected = False if connected == True: return checkRecursiveConnect(int(slot_config.advanced.unicableconnectedTo.value)) return True return checkRecursiveConnect(self.slotid) def checkLoopthrough(self): if self.nimConfig.configMode.value in ("loopthrough_internal", "loopthrough_external"): loopthrough_count = 0 dvbs_slots = nimmanager.getNimListOfType('DVB-S') dvbs_slots_len = len(dvbs_slots) for x in dvbs_slots: try: nim_slot = nimmanager.nim_slots[x] if nim_slot == self.nimConfig: self_idx = x if nim_slot.config.configMode.value in ("loopthrough_internal", "loopthrough_external"): loopthrough_count += 1 except: pass if loopthrough_count >= dvbs_slots_len: return False self.slot_dest_list = [] def checkRecursiveConnect(slot_id): if slot_id in self.slot_dest_list: return False self.slot_dest_list.append(slot_id) slot_config = nimmanager.nim_slots[slot_id].config if slot_config.configMode.value in ("loopthrough_internal", "loopthrough_external"): return checkRecursiveConnect(int(slot_config.connectedTo.value)) return True return checkRecursiveConnect(self.slotid) def keyOk(self): if self.isChanged(): self.stopService() if self["config"].getCurrent() == self.advancedSelectSatsEntry and self.advancedSelectSatsEntry: conf = self.nimConfig.advanced.sat[int(self.nimConfig.advanced.sats.value)].userSatellitesList self.session.openWithCallback(boundFunction(self.updateConfUserSatellitesList, conf), SelectSatsEntryScreen, userSatlist=conf.value) elif self["config"].getCurrent() == self.selectSatsEntry and self.selectSatsEntry: conf = self.nimConfig.userSatellitesList self.session.openWithCallback(boundFunction(self.updateConfUserSatellitesList, conf), SelectSatsEntryScreen, userSatlist=conf.value) else: self.keySave() def updateConfUserSatellitesList(self, conf, val=None): if val is not None: conf.value = val conf.save() def keySave(self): if self.isChanged(): self.stopService() if not self.unicableconnection(): self.session.open(MessageBox, _("The unicable connection setting is wrong.\n Maybe recursive connection of tuners."),MessageBox.TYPE_ERROR,timeout=10) return if not self.checkLoopthrough(): self.session.open(MessageBox, _("The loopthrough setting is wrong."),MessageBox.TYPE_ERROR,timeout=10) return old_configured_sats = nimmanager.getConfiguredSats() if not self.run(): return new_configured_sats = nimmanager.getConfiguredSats() self.unconfed_sats = old_configured_sats - new_configured_sats self.satpos_to_remove = None self.deleteConfirmed((None, "no")) def deleteConfirmed(self, confirmed): if confirmed is None: confirmed = (None, "no") if confirmed[1] == "yes" or confirmed[1] == "yestoall": eDVBDB.getInstance().removeServices(-1, -1, -1, self.satpos_to_remove) if self.satpos_to_remove is not None: self.unconfed_sats.remove(self.satpos_to_remove) self.satpos_to_remove = None for orbpos in self.unconfed_sats: self.satpos_to_remove = orbpos orbpos = self.satpos_to_remove try: # why we need this cast? sat_name = str(nimmanager.getSatDescription(orbpos)) except: if orbpos > 1800: # west orbpos = 3600 - orbpos h = _("W") else: h = _("E") sat_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10) if confirmed[1] == "yes" or confirmed[1] == "no": # TRANSLATORS: The satellite with name '%s' is no longer used after a configuration change. The user is asked whether or not the satellite should be deleted. self.session.openWithCallback(self.deleteConfirmed, ChoiceBox, _("%s is no longer used. Should it be deleted?") % sat_name, [(_("Yes"), "yes"), (_("No"), "no"), (_("Yes to all"), "yestoall"), (_("No to all"), "notoall")], None, 1) if confirmed[1] == "yestoall" or confirmed[1] == "notoall": self.deleteConfirmed(confirmed) break else: self.restartPrevService() def __init__(self, session, slotid): Screen.__init__(self, session) self.list = [ ] ServiceStopScreen.__init__(self) ConfigListScreen.__init__(self, self.list) self["key_red"] = Label(_("Cancel")) self["key_green"] = Label(_("Save")) self["key_yellow"] = Label() self["key_blue"] = Label() self["actions"] = ActionMap(["SetupActions", "SatlistShortcutAction"], { "ok": self.keyOk, "save": self.keySave, "cancel": self.keyCancel, "changetype": self.changeConfigurationMode, "nothingconnected": self.nothingConnectedShortcut }, -2) self.slotid = slotid self.nim = nimmanager.nim_slots[slotid] self.nimConfig = self.nim.config self.createConfigMode() self.createSetup() self.setTitle(_("Setup tuner") + " " + self.nim.input_name) def keyLeft(self): if self.nim.isFBCLink() and self["config"].getCurrent() in (self.advancedLof, self.advancedConnected): return ConfigListScreen.keyLeft(self) if self["config"].getCurrent() in (self.advancedSelectSatsEntry, self.selectSatsEntry): self.keyOk() else: self.newConfig() def setTextKeyYellow(self): self["key_yellow"].setText(self.nimConfig.configMode.value == "simple" and _("Auto Diseqc") or _("Configuration mode")) def setTextKeyBlue(self): self["key_blue"].setText(self.isChanged() and _("Set default") or "") def keyRight(self): if self.nim.isFBCLink() and self["config"].getCurrent() in (self.advancedLof, self.advancedConnected): return ConfigListScreen.keyRight(self) if self["config"].getCurrent() in (self.advancedSelectSatsEntry, self.selectSatsEntry): self.keyOk() else: self.newConfig() def handleKeyFileCallback(self, answer): ConfigListScreen.handleKeyFileCallback(self, answer) self.newConfig() def keyCancel(self): if self.isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?")) else: self.restartPrevService() def isChanged(self): is_changed = False for x in self["config"].list: if x == self.showAdditionalMotorOptions: continue is_changed |= x[1].isChanged() return is_changed def saveAll(self): if self.nim.isCompatible("DVB-S"): # reset connectedTo to all choices to properly store the default value choices = [] nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) # sanity check for empty sat list if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1: self.nimConfig.configMode.value = "nothing" if self.nim.isFBCRoot(): if SystemInfo["HasForceLNBOn"]: config.misc.forceLnbPower.save() if SystemInfo["HasForceToneburst"]: config.misc.forceToneBurst.save() if self.isChanged(): for x in self["config"].list: x[1].save() configfile.save() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() if hasattr(self, "originalTerrestrialRegion"): self.nimConfig.terrestrial.value = self.originalTerrestrialRegion self.nimConfig.terrestrial.save() if hasattr(self, "originalCableRegion"): self.nimConfig.cable.scan_provider.value = self.originalCableRegion self.nimConfig.cable.scan_provider.save() # we need to call saveAll to reset the connectedTo choices self.saveAll() self.restartPrevService() def changeConfigurationMode(self): if self.nimConfig.configMode.value == "simple": self.autoDiseqcRun(self.nimConfig.diseqcMode.value == "diseqc_a_b_c_d" and 4 or self.nimConfig.diseqcMode.value == "diseqc_a_b" and 2 or 1) elif self.configMode: self.nimConfig.configMode.selectNext() self["config"].invalidate(self.configMode) self.setTextKeyBlue() self.createSetup() def nothingConnectedShortcut(self): if self.isChanged(): for x in self["config"].list: x[1].cancel() self.setTextKeyBlue() self.createSetup() def countrycodeToCountry(self, cc): if not hasattr(self, 'countrycodes'): self.countrycodes = {} from Tools.CountryCodes import ISO3166 for country in ISO3166: self.countrycodes[country[2]] = country[0] if cc.upper() in self.countrycodes: return self.countrycodes[cc.upper()] return cc
class RecordingSettings(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): 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): if configele.value in [ x[0] for x in self.styles ] or fileExists(configele.value, 'w'): configele.last_value = configele.value return True else: dir = configele.value 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.value default = config.usage.default_path.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname = ConfigSelection(default=default, choices=tmp) tmp = config.movielist.videodirs.value default = config.usage.timer_path.value if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.timer_dirname = ConfigSelection(default=default, choices=self.styles + tmp) tmp = config.movielist.videodirs.value default = config.usage.instantrec_path.value if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) 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.value: self['config'].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) 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.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value self.lastautorecorddirs = config.usage.allowed_autorecord_paths.value 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.value)) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback(self.dirnameSelected, MovieLocationBox, _('New timers location'), preferredPath(self.timer_dirname.value)) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback(self.dirnameSelected, MovieLocationBox, _('Instant recordings location'), preferredPath(self.instantrec_dirname.value)) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [ x[0] for x in self.styles ] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value 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() 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 self.levelChanged not 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.value and not item.value == '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 item = b if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class Config(ConfigListScreen,Screen): skin = """ <screen position="center,center" size="560,400" title="AutoBackup Configuration" > <ePixmap name="red" position="0,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" /> <ePixmap name="green" position="140,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" /> <ePixmap name="yellow" position="280,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/yellow.png" transparent="1" alphatest="on" /> <ePixmap name="blue" position="420,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" /> <widget name="key_red" position="0,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_green" position="140,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_yellow" position="280,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_blue" position="420,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="config" position="10,40" size="540,200" scrollbarMode="showOnDemand" /> <widget name="status" position="10,250" size="540,130" font="Regular;16" /> <ePixmap alphatest="on" pixmap="skin_default/icons/clock.png" position="480,383" size="14,14" zPosition="3"/> <widget font="Regular;18" halign="left" position="505,380" render="Label" size="55,20" source="global.CurrentTime" transparent="1" valign="center" zPosition="3"> <convert type="ClockToText">Default</convert> </widget> <widget name="statusbar" position="10,380" size="470,20" font="Regular;18" /> </screen>""" def __init__(self, session, args = 0): self.session = session self.skinName = ["Config_AutoBackup", "Config"] self.setup_title = _("AutoBackup Configuration") Screen.__init__(self, session) cfg = config.plugins.autobackup choices=getLocationChoices() if choices: currentwhere = cfg.where.value defaultchoice = choices[0][0] for k,v in choices: if k == currentwhere: defaultchoice = k break else: defaultchoice = "" choices = [("", _("Nowhere"))] self.cfgwhere = ConfigSelection(default=defaultchoice, choices=choices) configList = [ getConfigListEntry(_("Backup location"), self.cfgwhere), getConfigListEntry(_("Daily automatic backup"), cfg.enabled), getConfigListEntry(_("Automatic start time"), cfg.wakeup), getConfigListEntry (_("Create Autoinstall"), cfg.autoinstall), ] ConfigListScreen.__init__(self, configList, session=session, on_change = self.changedEntry) self["key_red"] = Button(_("Cancel")) self["key_green"] = Button(_("Ok")) self["key_yellow"] = Button(_("Manual")) self["key_blue"] = Button("") self["statusbar"] = Label() self["status"] = Label() self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "red": self.cancel, "green": self.save, "yellow": self.dobackup, "blue": self.disable, "save": self.save, "cancel": self.cancel, "ok": self.save, "menu": self.menu, }, -2) self.onChangedEntry = [] self.data = '' self.container = enigma.eConsoleAppContainer() self.container.appClosed.append(self.appClosed) self.container.dataAvail.append(self.dataAvail) self.cfgwhere.addNotifier(self.changedWhere) self.onClose.append(self.__onClose) self.setTitle(_("AutoBackup Configuration")) # 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 def changedWhere(self, cfg): self.isActive = False if not cfg.value: self["status"].setText(_("No suitable media found, insert USB stick, flash card or harddisk.")) self.isActive = False else: config.plugins.autobackup.where.value = cfg.value path = os.path.join(cfg.value, 'backup') if not os.path.exists(path): self["status"].setText(_("No backup present")) else: try: st = os.stat(os.path.join(path, ".timestamp")) try: macaddr = open('/sys/class/net/eth0/address').read().strip().replace(':','') fn = "AutoBackup%s.tar.gz" % macaddr st = os.stat(os.path.join(path, fn)) except: # No box-specific backup found pass self.isActive = True self["status"].setText(_("Last backup date") + ": " + " ".join(FuzzyTime(st.st_mtime, inPast=True))) except Exception, ex: print "Failed to stat %s: %s" % (path, ex) self["status"].setText(_("Disabled")) if self.isActive: self["key_blue"].setText(_("Disable")) else: self["key_blue"].setText("")
class RecordPathsSettings(Screen,ConfigListScreen): skin = """ <screen name="RecordPathsSettings" position="160,150" size="450,290" title="Settings 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,236" /> </screen>""" def __init__(self, session): from Components.Sources.StaticText import StaticText Screen.__init__(self, session) self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) ConfigListScreen.__init__(self, []) self.initConfigList() self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "green": self.save, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, "menu": self.closeRecursive, }, -2) def checkReadWriteDir(self, configele): print "checkReadWrite: ", configele.value if configele.value in [x[0] for x in self.styles] or fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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 initConfigList(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.value default = config.usage.default_path.value 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.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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) default = config.usage.timeshift_path.value tmp = config.usage.allowed_timeshift_paths.value if default not in tmp: tmp = tmp[:] tmp.append(default) print "TimeshiftPath: ", default, tmp self.timeshift_dirname = ConfigSelection(default = default, choices = tmp) default = "/usr/share/enigma2/picon/" try: default = config.misc.picon_path.value except: pass tmp = [ "/usr/share/enigma2/picon/", "/media/usb/picon/", "/media/hdd/picon/" ] if default not in tmp: tmp = tmp[:] tmp.append(default) print "Picon Path: ", default, tmp self.picon_dirname = ConfigSelection(default = default, choices = tmp) default = "/hdd/" try: default = '/'.join(config.misc.epgcache_filename.value.split('/')[:-1])+'/' except: pass tmp = [ "/media/hdd/", "/media/usb/" ] if default not in tmp: tmp = tmp[:] tmp.append(default) print "EPG Path: ", default, tmp self.epg_dirname = ConfigSelection(default = default, choices = tmp) default = "epg.dat" try: default = config.misc.epgcache_filename.value.split("/")[-1] except: pass print "EPG File name: ", default self.epg_filename = ConfigText(default = default) 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.timeshift_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.epg_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) self.list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer recording location"), self.timer_dirname) self.list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry(_("Instant recording location"), self.instantrec_dirname) self.list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname) self.list.append(self.default_entry) self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname) self.list.append(self.timeshift_entry) self.picon_entry = getConfigListEntry(_("Picon location"), self.picon_dirname) self.list.append(self.picon_entry) self.piconHDD_entry = getConfigListEntry(_("Search picons in /media/hdd"), config.misc.picon_search_hdd) self.list.append(self.piconHDD_entry) self.epgdir_entry = getConfigListEntry(_("EPG location"), self.epg_dirname) self.list.append(self.epgdir_entry) self.epgfile_entry = getConfigListEntry(_("EPG file name"), self.epg_filename) self.list.append(self.epgfile_entry) self["config"].setList(self.list) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value 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.value) ) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Initial location in new timers"), preferredPath(self.timer_dirname.value) ) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Location for instant recordings"), preferredPath(self.instantrec_dirname.value) ) elif currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value self.session.openWithCallback( self.dirnameSelected, TimeshiftLocationBox ) elif currentry == self.picon_entry: self.entrydirname = self.picon_dirname self.session.openWithCallback( self.dirnameSelected, LocationBox, _("Picon location"), currDir =preferredPath(self.picon_dirname.value), ) elif currentry == self.epgdir_entry: self.entrydirname = self.epg_dirname self.session.openWithCallback( self.dirnameSelected, LocationBox, _("EPG location"), currDir =preferredPath(self.epg_dirname.value), ) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res currentry = self["config"].getCurrent() if currentry == self.picon_entry: tmp = [ "/usr/share/enigma2/picon/", "/usb/picon/", "/hdd/picon/" ] default = res if default not in tmp: tmp = tmp[:] tmp.append(default) self.picon_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if currentry == self.epgdir_entry: tmp = [ "/hdd/", "/usb/" ] default = res if default not in tmp: tmp = tmp[:] tmp.append(default) self.epg_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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 config.usage.allowed_timeshift_paths.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.instantrec_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if self.entrydirname.last_value != res and currentry != self.picon_entry: self.checkReadWriteDir(self.entrydirname) def save(self): currentry = self["config"].getCurrent() save = True if currentry != self.epgfile_entry and currentry != self.picon_entry and currentry != self.piconHDD_entry: save = self.checkReadWriteDir(currentry[1]) if save: config.usage.default_path.value = self.default_dirname.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value config.usage.timeshift_path.value = self.timeshift_dirname.value config.misc.picon_path.value = self.picon_dirname.value config.misc.epgcache_filename.value = self.epg_dirname.value + self.epg_filename.value config.usage.default_path.save() config.misc.picon_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() config.usage.timeshift_path.save() config.misc.epgcache_filename.save() config.misc.picon_search_hdd.save() from Components.Renderer import Picon Picon.setPiconPath() 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>""" providers = [('Canal Digitaal', (1, 900, True)), ('TV Vlaanderen', (1, 910, True)), ('TéléSAT', (0, 920, True)), ('HD Austria', (0, 950, False)), ('Diveo', (0, 960, False)), ('Skylink Czech Republic', (1, 30, False)), ('Skylink Slovak Republic', (1, 31, False)), ('FreeSAT CZ', (2, 82, False)), ('FreeSAT SK', (2, 83, False)), ('FocusSAT Thor', (2, 84, False)), ('UPC Direct Thor', (2, 81, False)), ('KabelKiosk', (0, 970, False)), ('TéléSAT Astra3', (1, 920, True)), ('HD Austria Astra3', (1, 950, False)), ('Diveo Astra3', (1, 960, False)), ('Canal Digitaal Astra 1', (0, 900, True)), ('TV Vlaanderen Astra 1', (0, 910, True))] 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), (11727000, 28000000, eDVBFrontendParametersSatellite.FEC_7_8, 3592, eDVBFrontendParametersSatellite.Polarisation_Vertical, eDVBFrontendParametersSatellite.Inversion_Unknown, eDVBFrontendParametersSatellite.System_DVB_S, eDVBFrontendParametersSatellite.Modulation_QPSK, eDVBFrontendParametersSatellite.RollOff_alpha_0_35, eDVBFrontendParametersSatellite.Pilot_Off)) def __init__(self, session): Screen.__init__(self, session) self.setTitle(_("Fast Scan")) 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 self.providers) lastConfiguration = eval(config.misc.fastscan.last_configuration.value) def providerChanged(configEntry): if configEntry.value: nimList = [ (str(x), nimmanager.nim_slots[x].friendly_full_description) for x in nimmanager.getNimListForSat(transponders[[ x[1][0] for x in providers if x[0] == configEntry.value ][0]][3]) ] self.scan_nims = ConfigSelection( default=lastConfiguration[0] if lastConfiguration and lastConfiguration[0] in [x[0] for x in nimList] else nimList[0][0], choices=nimList) self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) providerList = getProviderList() if lastConfiguration and lastConfiguration[1] in providerList: self.scan_provider = ConfigSelection(default=lastConfiguration[1], choices=[(None, _("None"))] + providerList) self.scan_provider.addNotifier(providerChanged) self.scan_hd = ConfigYesNo(default=lastConfiguration[2]) self.scan_keepnumbering = ConfigYesNo(default=lastConfiguration[3]) self.scan_keepsettings = ConfigYesNo(default=lastConfiguration[4]) self.scan_create_radio_bouquet = ConfigYesNo( default=len(lastConfiguration) > 5 and lastConfiguration[5]) else: self.scan_provider = ConfigSelection(default=None, choices=[(None, _("None"))] + providerList) self.scan_provider.addNotifier(providerChanged) self.scan_hd = ConfigYesNo(default=True) self.scan_keepnumbering = ConfigYesNo(default=True) self.scan_keepsettings = ConfigYesNo(default=False) self.scan_create_radio_bouquet = ConfigYesNo(default=False) self.scanProvider = getConfigListEntry(_("Provider"), self.scan_provider) self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd) self.config_autoproviders = {} auto_providers = config.misc.fastscan.autoproviders.value.split(",") for provider in providers: self.config_autoproviders[provider[0]] = ConfigYesNo( default=provider[0] in auto_providers) self.list = [] ConfigListScreen.__init__(self, self.list) self.createSetup() self.finished_cb = None self["introduction"] = Label( _("Select your provider, and press OK to start the scan")) self["key_red"] = Label(_("Cancel")) self["key_green"] = Label(_("Save")) def createSetup(self): self.list = [] self.list.append(self.scanProvider) if self.scan_provider.value: self.list.append(self.tunerEntry) for index in providers: if index[0] == self.scan_provider.value and index[1][2]: self.list.append(self.scanHD) break self.list.append( getConfigListEntry(_("Use fastscan channel numbering"), self.scan_keepnumbering)) self.list.append( getConfigListEntry(_("Use fastscan channel names"), self.scan_keepsettings)) self.list.append( getConfigListEntry(_("Create separate radio userbouquet"), self.scan_create_radio_bouquet)) self.list.append( getConfigListEntry(_("Drop unconfigured satellites"), config.misc.fastscan.drop)) self.list.append( getConfigListEntry(_("Enable auto fast scan"), config.misc.fastscan.auto)) if config.misc.fastscan.auto.value == "multi": for provider in providers: if nimmanager.getNimListForSat( transponders[provider[1][0]][3]): self.list.append( getConfigListEntry( _("Enable auto fast scan for %s") % provider[0], self.config_autoproviders[provider[0]])) self["config"].list = self.list self["config"].l.setList(self.list) def keyLeft(self): ConfigListScreen.keyLeft(self) self.createSetup() def keyRight(self): ConfigListScreen.keyRight(self) self.createSetup() def saveConfiguration(self): if self.scan_provider.value: 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, self.scan_create_radio_bouquet.value) ` auto_providers = [] for provider in providers: if self.config_autoproviders[provider[0]].value: auto_providers.append(provider[0]) config.misc.fastscan.autoproviders.value = ",".join(auto_providers) else: config.misc.fastscan.last_configuration.value = "()" config.misc.fastscan.save() def keySave(self): self.saveConfiguration() self.close() def keyGo(self): if self.scan_provider.value: self.saveConfiguration() self.startScan() def getTransponderParameters(self, number): transponderParameters = eDVBFrontendParametersSatellite() transponderParameters.frequency = transponders[number][0] transponderParameters.symbol_rate = transponders[number][1] transponderParameters.fec = transponders[number][2] transponderParameters.orbital_position = transponders[number][3] transponderParameters.polarisation = transponders[number][4] transponderParameters.inversion = transponders[number][5] transponderParameters.system = transponders[number][6] transponderParameters.modulation = transponders[number][7] transponderParameters.rolloff = transponders[number][8] transponderParameters.pilot = transponders[number][9] transponderParameters.is_id = eDVBFrontendParametersSatellite.No_Stream_Id_Filter transponderParameters.pls_mode = eDVBFrontendParametersSatellite.PLS_Gold transponderParameters.pls_code = eDVBFrontendParametersSatellite.PLS_Default_Gold_Code transponderParameters.t2mi_plp_id = eDVBFrontendParametersSatellite.No_T2MI_PLP_Id return transponderParameters def startScan(self): parameters = tuple(x[1] for x in providers if x[0] == self.scan_provider.value)[0] pid = parameters[1] if self.scan_hd.value and parameters[2]: pid += 1 if self.scan_nims.value: self.session.open( FastScanStatus, scanTuner=int(self.scan_nims.value), transponderParameters=self.getTransponderParameters( parameters[0]), scanPid=pid, keepNumbers=self.scan_keepnumbering.value, keepSettings=self.scan_keepsettings.value, createRadioBouquet=self.scan_create_radio_bouquet.value, providerName=self.scan_provider.getText()) def keyCancel(self): self.close()
class RecordingSettings(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): 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): if configele.value in [x[0] for x in self.styles] or fileExists( configele.value, 'w'): configele.last_value = configele.value return True else: dir = configele.value 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.value default = config.usage.default_path.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname = ConfigSelection(default=default, choices=tmp) tmp = config.movielist.videodirs.value default = config.usage.timer_path.value if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) self.timer_dirname = ConfigSelection(default=default, choices=self.styles + tmp) tmp = config.movielist.videodirs.value default = config.usage.instantrec_path.value if default not in tmp and default not in styles_keys: tmp = tmp[:] tmp.append(default) 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.value: self['config'].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) 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.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value self.lastautorecorddirs = config.usage.allowed_autorecord_paths.value 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.value)) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _('New timers location'), preferredPath(self.timer_dirname.value)) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _('Instant recordings location'), preferredPath(self.instantrec_dirname.value)) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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) return def saveAll(self): currentry = self['config'].getCurrent() config.usage.default_path.value = self.default_dirname.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value 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() 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 self.levelChanged not 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.value and not item.value == '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 item = b if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class RecordPathsSettings(Screen, ConfigListScreen): def __init__(self, session): from Components.Sources.StaticText import StaticText Screen.__init__(self, session) self.skinName = "RecordPathsSettings" self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self["key_yellow"] = StaticText() self["key_blue"] = StaticText() self["introduction"] = StaticText() ConfigListScreen.__init__(self, []) self.initConfigList() self["setupActions"] = ActionMap( ["SetupActions", "ColorActions"], { "green": self.save, "red": self.cancel, "cancel": self.cancel, "ok": self.ok, }, -2) def checkReadWriteDir(self, configele): print("checkReadWrite: ", configele.value) if configele.value in [x[0] for x in self.styles] or configele.value in [ x[0] for x in self.storage_styles ] or fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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 initConfigList(self): self.styles = [("<default>", _("<Default movie location>")), ("<current>", _("<Current movielist location>")), ("<timer>", _("<Last timer location>"))] styles_keys = [x[0] for x in self.styles] mountpoints = [(p.mountpoint, p.description) for p in harddiskmanager.getConfiguredStorageDevices() if p.isInitialized] mountpoints.sort(reverse=True) self.storage_styles = [("<undefined>", _("<No default storage device selected.>"))] self.storage_styles += mountpoints storage_styles_keys = [x[0] for x in self.storage_styles] default = defaultStorageDevice() if default not in storage_styles_keys: p = harddiskmanager.getDefaultStorageDevicebyUUID(default) if p is not None: default = p.mountpoint if p.mountpoint not in storage_styles_keys: self.storage_styles.append((p.mountpoint, p.description)) else: cfg_uuid = config.storage.get(default, None) if cfg_uuid is not None: if cfg_uuid["enabled"].value: default = cfg_uuid["mountpoint"].value if default not in storage_styles_keys: description = cfg_uuid[ "device_description"].value.split()[0] or "" description += " ( " + _("Offline") + " )" self.storage_styles.append((default, description)) else: default = "<undefined>" else: default = "<undefined>" print("DefaultDevice: ", default, self.storage_styles) self.default_device = ConfigSelection(default=default, choices=self.storage_styles) tmp = config.movielist.videodirs.value default = config.usage.default_path.value 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.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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) default = config.usage.timeshift_path.value tmp = config.usage.allowed_timeshift_paths.value 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.last_value = self.timeshift_dirname.value self.default_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.default_dirname.last_value = self.default_dirname.value self.timer_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.timer_dirname.last_value = self.timer_dirname.value self.instantrec_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.instantrec_dirname.last_value = self.instantrec_dirname.value self.timeshift_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.timeshift_dirname.last_value = self.timeshift_dirname.value self.list = [] self.device_entry = getConfigListEntry(_("Default storage device"), self.default_device) self.list.append(self.device_entry) if config.usage.setup_level.index >= 2: self.default_entry = getConfigListEntry( _("Default movie location"), self.default_dirname) self.list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer record location"), self.timer_dirname) self.list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry( _("Instant record location"), self.instantrec_dirname) self.list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname) self.list.append(self.default_entry) self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname) self.list.append(self.timeshift_entry) self["config"].setList(self.list) if not self.selectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.selectionChanged) def selectionChanged(self): currentry = self["config"].getCurrent() if currentry == self.device_entry: self["introduction"].setText( _("Please select the default storage device you want to use for recordings. This device gets mounted to /media/hdd." )) elif currentry == self.default_entry: self["introduction"].setText( _("Please select the default movielist location which is used for recordings." )) elif currentry == self.timeshift_entry: self["introduction"].setText( _("Please select the timeshift location which is used for storing timeshift recordings." )) if config.usage.setup_level.index >= 2: if currentry == self.timer_entry: self["introduction"].setText( _("Please select the default timer record location which is used for timer based recordings." )) elif currentry == self.instantrec_entry: self["introduction"].setText( _("Please select the default instant record location which is used for instant recordings." )) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value 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.value)) elif currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value self.session.openWithCallback(self.dirnameSelected, TimeshiftLocationBox) if config.usage.setup_level.index >= 2: if currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Initial location in new timers"), preferredPath(self.timer_dirname.value)) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Location for instant recordings"), preferredPath(self.instantrec_dirname.value)) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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 config.usage.allowed_timeshift_paths.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.instantrec_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if self.entrydirname.last_value != res: self.checkReadWriteDir(self.entrydirname) def save(self): currentry = self["config"].getCurrent() defaultChanged = None if self.checkReadWriteDir(currentry[1]): config.usage.default_path.value = self.default_dirname.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.default_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() config.usage.timeshift_path.save() if self.default_device.value != "/media/hdd": if self.default_device.value != "<undefined>": #changing default ? tmp = harddiskmanager.getPartitionbyMountpoint( self.default_device.value) if tmp is not None: defaultChanged = harddiskmanager.changeStorageDevice( tmp.uuid, "mount_default", None) else: #disabling default ? p = harddiskmanager.getDefaultStorageDevicebyUUID( defaultStorageDevice()) if p is not None: defaultChanged = harddiskmanager.changeStorageDevice( defaultStorageDevice(), "unmount", None) if defaultChanged is None: self.close() elif defaultChanged is False: self.session.open( MessageBox, _("There was en error while configuring your storage device." ), MessageBox.TYPE_ERROR) else: self.close() def cancel(self): self.close()
class FastScanScreen(ConfigListScreen, Screen): skin = """ <screen position="100,115" size="520,290" title="FastScan"> <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(_("FastScan")) self["actions"] = ActionMap(["SetupActions", "MenuActions"], { "ok": self.keyGo, "save": self.keySave, "cancel": self.keyCancel, "menu": self.closeRecursive, }, -2) lastConfiguration = eval(config.misc.fastscan.last_configuration.value) def providerChanged(configEntry): if configEntry.value: nimList = [(str(x), nimmanager.nim_slots[x].friendly_full_description) for x in nimmanager.getNimListForSat(transponders[[x[1][0] for x in providers if x[0] == configEntry.value][0]][3])] self.scan_nims = ConfigSelection(default=lastConfiguration[0] if lastConfiguration and lastConfiguration[0] in [x[0] for x in nimList] else nimList[0][0], choices=nimList) self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) providerList = getProviderList() if lastConfiguration and lastConfiguration[1] in providerList: self.scan_provider = ConfigSelection(default=lastConfiguration[1], choices=[(None, _("None"))] + providerList) self.scan_provider.addNotifier(providerChanged) self.scan_hd = ConfigYesNo(default=lastConfiguration[2]) self.scan_keepnumbering = ConfigYesNo(default=lastConfiguration[3]) self.scan_keepsettings = ConfigYesNo(default=lastConfiguration[4]) self.scan_create_radio_bouquet = ConfigYesNo(default=len(lastConfiguration) > 5 and lastConfiguration[5]) else: self.scan_provider = ConfigSelection(default=None, choices=[(None, _("None"))] + providerList) self.scan_provider.addNotifier(providerChanged) self.scan_hd = ConfigYesNo(default=True) self.scan_keepnumbering = ConfigYesNo(default=True) self.scan_keepsettings = ConfigYesNo(default=False) self.scan_create_radio_bouquet = ConfigYesNo(default=False) self.scanProvider = getConfigListEntry(_("Provider"), self.scan_provider) self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd) self.config_autoproviders = {} auto_providers = config.misc.fastscan.autoproviders.value.split(",") for provider in providers: self.config_autoproviders[provider[0]] = ConfigYesNo(default=provider[0] in auto_providers) self.list = [] ConfigListScreen.__init__(self, self.list) self.createSetup() self.finished_cb = None self["introduction"] = Label(_("Select your provider, and press OK to start the scan")) self["key_red"] = Label(_("Cancel")) self["key_green"] = Label(_("Save")) def createSetup(self): self.list = [] self.list.append(self.scanProvider) if self.scan_provider.value: self.list.append(self.tunerEntry) for index in providers: if index[0] == self.scan_provider.value and index[1][2]: self.list.append(self.scanHD) break self.list.append(getConfigListEntry(_("Use fastscan channel numbering"), self.scan_keepnumbering)) self.list.append(getConfigListEntry(_("Use fastscan channel names"), self.scan_keepsettings)) self.list.append(getConfigListEntry(_("Create separate radio userbouquet"), self.scan_create_radio_bouquet)) self.list.append(getConfigListEntry(_("Drop unconfigured satellites"), config.misc.fastscan.drop)) self.list.append(getConfigListEntry(_("Enable auto fastscan"), config.misc.fastscan.auto)) if config.misc.fastscan.auto.value == "multi": for provider in providers: if nimmanager.getNimListForSat(transponders[provider[1][0]][3]): self.list.append(getConfigListEntry(_("Enable auto fastscan for %s") % provider[0], self.config_autoproviders[provider[0]])) self["config"].list = self.list self["config"].l.setList(self.list) def keyLeft(self): ConfigListScreen.keyLeft(self) self.createSetup() def keyRight(self): ConfigListScreen.keyRight(self) self.createSetup() def saveConfiguration(self): if self.scan_provider.value: 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, self.scan_create_radio_bouquet.value) auto_providers = [] for provider in providers: if self.config_autoproviders[provider[0]].value: auto_providers.append(provider[0]) config.misc.fastscan.autoproviders.value = ",".join(auto_providers) else: config.misc.fastscan.last_configuration.value = "()" config.misc.fastscan.save() def keySave(self): self.saveConfiguration() self.close() def keyGo(self): if self.scan_provider.value: self.saveConfiguration() self.startScan() def getTransponderParameters(self, number): transponderParameters = eDVBFrontendParametersSatellite() transponderParameters.frequency = transponders[number][0] transponderParameters.symbol_rate = transponders[number][1] transponderParameters.fec = transponders[number][2] transponderParameters.orbital_position = transponders[number][3] transponderParameters.polarisation = transponders[number][4] transponderParameters.inversion = transponders[number][5] transponderParameters.system = transponders[number][6] transponderParameters.modulation = transponders[number][7] transponderParameters.rolloff = transponders[number][8] transponderParameters.pilot = transponders[number][9] transponderParameters.is_id = eDVBFrontendParametersSatellite.No_Stream_Id_Filter transponderParameters.pls_mode = eDVBFrontendParametersSatellite.PLS_Gold transponderParameters.pls_code = eDVBFrontendParametersSatellite.PLS_Default_Gold_Code return transponderParameters def startScan(self): parameters = tuple(x[1] for x in providers if x[0] == self.scan_provider.value)[0] pid = parameters[1] if self.scan_hd.value and parameters[2]: pid += 1 if self.scan_nims.value: self.session.open(FastScanStatus, scanTuner=int(self.scan_nims.value), transponderParameters=self.getTransponderParameters(parameters[0]), scanPid=pid, keepNumbers=self.scan_keepnumbering.value, keepSettings=self.scan_keepsettings.value, createRadioBouquet=self.scan_create_radio_bouquet.value, providerName=self.scan_provider.getText()) def keyCancel(self): self.close()
class Satfinder(ScanSetup): 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 __init__(self, session, feid): self.initcomplete = False self.feid = feid self.oldref = None if not self.openFrontend(): self.oldref = session.nav.getCurrentlyPlayingServiceReference() session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if session.pipshown: # try to disable pip session.pipshown = False del session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen ScanSetup.__init__(self, session) self.tuner = Tuner(self.frontend) self["introduction"].setText("") self["Frontend"] = FrontendStatus( frontend_source=lambda: self.frontend, update_interval=100) self.initcomplete = True self.onClose.append(self.__onClose) def __onClose(self): self.session.nav.playService(self.oldref) def createSetup(self): self.typeOfTuningEntry = None self.satEntry = None self.list = [] self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type) self.list.append(self.typeOfTuningEntry) self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat) self.list.append(self.satEntry) nim = nimmanager.nim_slots[self.feid] self.systemEntry = None if self.tuning_type.value == "manual_transponder": 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.value = eDVBFrontendParametersSatellite.System_DVB_S 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(_("Polarity"), self.scan_sat.polarization)) if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append( getConfigListEntry(_("FEC"), self.scan_sat.fec)) elif self.scan_sat.system.value == 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(_('Rolloff'), self.scan_sat.rolloff)) self.list.append( getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder": self.list.append( getConfigListEntry(_("Transponder"), self.tuning_transponder)) self["config"].list = self.list self["config"].l.setList(self.list) def newConfig(self): cur = self["config"].getCurrent() if cur in (self.typeOfTuningEntry, self.systemEntry): self.createSetup() elif cur == self.satEntry: self.updateSats() self.createSetup() def sat_changed(self, config_element): self.newConfig() self.retune(config_element) def retune(self, configElement): returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) satpos = int(self.tuning_sat.value) if self.tuning_type.value == "manual_transponder": if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: fec = self.scan_sat.fec_s2.value else: fec = self.scan_sat.fec.value returnvalue = (self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, self.scan_sat.polarization.value, fec, self.scan_sat.inversion.value, satpos, self.scan_sat.system.value, self.scan_sat.modulation.value, self.scan_sat.rolloff.value, self.scan_sat.pilot.value) self.tune(returnvalue) elif self.tuning_type.value == "predefined_transponder": tps = nimmanager.getTransponders(satpos) l = len(tps) if l > self.tuning_transponder.index: transponder = tps[self.tuning_transponder.index] returnvalue = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9]) self.tune(returnvalue) def createConfig(self, foo): self.tuning_transponder = None self.tuning_type = ConfigSelection( choices=[("manual_transponder", _("Manual transponder") ), ("predefined_transponder", _("Predefined transponder"))]) self.tuning_sat = getConfigSatlist( 192, nimmanager.getSatListForNim(self.feid)) ScanSetup.createConfig(self, None) self.updateSats() for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system): x.addNotifier(self.retune, initial_call=False) def updateSats(self): orb_pos = self.tuning_sat.orbital_position if orb_pos is not None: transponderlist = nimmanager.getTransponders(orb_pos) list = [] default = None index = 0 for x in transponderlist: if x[3] == 0: pol = "H" elif x[3] == 1: pol = "V" elif x[3] == 2: pol = "CL" elif x[3] == 3: pol = "CR" else: pol = "??" if x[4] == 0: fec = "FEC Auto" elif x[4] == 1: fec = "FEC 1/2" elif x[4] == 2: fec = "FEC 2/3" elif x[4] == 3: fec = "FEC 3/4" elif x[4] == 4: fec = "FEC 5/6" elif x[4] == 5: fec = "FEC 7/8" elif x[4] == 6: fec = "FEC 8/9" elif x[4] == 7: fec = "FEC 3/5" elif x[4] == 8: fec = "FEC 4/5" elif x[4] == 9: fec = "FEC 9/10" elif x[4] == 15: fec = "FEC None" else: fec = "FEC Unknown" e = str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec if default is None: default = str(index) list.append((str(index), e)) index += 1 self.tuning_transponder = ConfigSelection(choices=list, default=default) self.tuning_transponder.addNotifier(self.retune, initial_call=False) def keyGo(self): self.retune(self.tuning_type) 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 satfinder?"), MessageBox.TYPE_YESNO) else: self.restartPrevService(False) def tune(self, transponder): if self.initcomplete: if transponder is not None: self.tuner.tune(transponder)
class SimpleSatScan(ConfigListScreen, Screen): skin = """ <screen position="center,center" size="520,480" title="Simple Satellite Scan"> <!-- little tune status --> <eLabel name="pos" text="Current position:" position="10,10" size="210,20" font="Regular;19" halign="right" transparent="1" /> <widget name="status" position="230,10" size="260,20" font="Console;19" valign="center" foregroundColor="#f8f711" transparent="1" /> <!-- dB --> <!--widget source="Frontend" render="Label" position="190,10" zPosition="2" size="260,20" font="Regular;19" foregroundColor="#02f408" halign="center" valign="center" transparent="1"--> <widget source="Frontend" render="Label" position="190,35" zPosition="2" size="260,20" font="Regular;19" halign="center" valign="center" transparent="1"> <convert type="FrontendInfo">SNRdB</convert> </widget> <!-- SNR --> <eLabel name="snr" text="SNR:" position="120,35" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Progress" position="190,35" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc"> <convert type="FrontendInfo">SNR</convert> </widget> <widget source="Frontend" render="Label" position="460,35" size="60,22" font="Regular;21"> <convert type="FrontendInfo">SNR</convert> </widget> <!-- Lock --> <eLabel name="lock" text="LOCK:" position="10,35" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_on.png" position="80,32" zPosition="1" size="38,31" alphatest="on"> <convert type="FrontendInfo">LOCK</convert> <convert type="ConditionalShowHide" /> </widget> <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_off.png" position="80,32" zPosition="1" size="38,31" alphatest="on"> <convert type="FrontendInfo">LOCK</convert> <convert type="ConditionalShowHide">Invert</convert> </widget> <!-- AGC --> <eLabel name="agc" text="AGC:" position="120,60" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Progress" position="190,60" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc"> <convert type="FrontendInfo">AGC</convert> </widget> <widget source="Frontend" render="Label" position="460,60" size="60,22" font="Regular;21"> <convert type="FrontendInfo">AGC</convert> </widget> <!-- BER --> <eLabel name="ber" text="BER:" position="120,85" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Progress" position="190,85" size="260,20" pixmap="skin_default/bar_ber.png" borderWidth="2" borderColor="#cccccc"> <convert type="FrontendInfo">BER</convert> </widget> <widget source="Frontend" render="Label" position="460,85" size="60,22" font="Regular;21"> <convert type="FrontendInfo">BER</convert> </widget> <!-- config --> <widget name="config" position="10,120" size="500,320" scrollbarMode="showOnDemand" transparent="1" /> <widget name="introduction" position="10,450" size="500,25" font="Regular;20" halign="center" valign="center" /> </screen>""" def __init__(self, session): self.skin = SimpleSatScan.skin Screen.__init__(self, session) self.initcomplete = False self.frontend = None self.prev_ref = False self.oldref = None self.updateSatList() self.service = session.nav.getCurrentService() self.feinfo = None 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["actions"] = NumberActionMap(["SetupActions"], {"ok": self.keyGo, "cancel": self.keyCancel}, -2) self.list = [] self.tpslist = [] self.tpslist_idx = 0 self.tuneTimer = eTimer() self.tuneTimer.callback.append(self.updateTuneStatus) ConfigListScreen.__init__(self, self.list) if not self.scan_nims.value == "": self.createSetup() self.feid = int(self.scan_nims.value) orbpos = "??" if ( len(self.satList) > self.feid and len(self.scan_satselection) > self.feid and len(self.satList[self.feid]) ): orbpos = self.OrbToStr(self.satList[self.feid][self.scan_satselection[self.feid].index][0]) self["status"] = Label( orbpos + ": " + str(self.scan_sat.frequency.value) + " " + self.PolToStr(self.scan_sat.polarization.value) ) 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.") ) self["status"] = Label("") self.feid = None self.initFrontend() self.initcomplete = self.feid != None 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 return False def initFrontend(self): if self.oldref is None: self.oldref = self.session.nav.getCurrentlyPlayingServiceReference() if not self.openFrontend(): self.prev_ref = True self.session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if self.session.pipshown: # try to disable pip self.session.pipshown = False del self.session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen try: self.tuner = Tuner(self.frontend) self["Frontend"] = FrontendStatus(frontend_source=lambda: self.frontend, update_interval=100) except: pass def deInitFrontend(self): if self.frontend: self.frontend = None del self.raw_channel def updateTuneStatus(self): if not self.frontend: return stop = False dict = {} self.frontend.getFrontendStatus(dict) if dict["tuner_state"] == "TUNING": self.tuneTimer.start(100, True) else: if dict["tuner_state"] == "LOSTLOCK" or dict["tuner_state"] == "FAILED": self.tpslist_idx += 1 if self.tpslist_idx >= len(self.tpslist): stop = True self["status"].setText("search failed!") self.tpslist_idx = 0 elif dict["tuner_state"] == "LOCKED": stop = True if not stop: self["status"].setText( self.OrbToStr(self.tpslist[self.tpslist_idx][5]) + ": " + str(self.tpslist[self.tpslist_idx][0]) + " " + self.PolToStr(self.tpslist[self.tpslist_idx][2]) ) self.tune(self.tpslist[self.tpslist_idx]) self.tuneTimer.start(100, True) def tune(self, transponder): if self.initcomplete: if transponder is not None and self.tuner is not None: self.tuner.tune(transponder) def retune(self, configElement): self.tuneTimer.stop() if self.scan_nims == []: return if self.scan_nims.value == "": return self.tpslist_idx = 0 tpslist = [] status_text = "" multi_tune = False index_to_scan = int(self.scan_nims.value) if len(self.satList) <= index_to_scan: return if len(self.scan_satselection) <= index_to_scan: return nim = nimmanager.nim_slots[index_to_scan] if not nim.isCompatible("DVB-S"): return nimsats = self.satList[index_to_scan] selsatidx = self.scan_satselection[index_to_scan].index if self.scan_type.value == "single_transponder": if len(nimsats): orbpos = nimsats[selsatidx][0] if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.value else: fec = self.scan_sat.fec_s2.value tpslist.append( ( self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, self.scan_sat.polarization.value, fec, self.scan_sat.inversion.value, orbpos, self.scan_sat.system.value, self.scan_sat.modulation.value, self.scan_sat.rolloff.value, self.scan_sat.pilot.value, ) ) elif self.scan_type.value == "predefined_transponder": if len(nimsats): orbpos = nimsats[selsatidx][0] index = self.scan_transponders.index if configElement and configElement._value == str(orbpos): index = 0 tps = nimmanager.getTransponders(orbpos) if len(tps) > index: x = tps[index] tpslist.append((x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], orbpos, x[5], x[6], x[8], x[9])) # else: # status_text = "tpslist for %d empty! %d" % (sat[0], index) elif self.scan_type.value == "single_satellite": if len(nimsats): multi_tune = True orbpos = nimsats[selsatidx][0] tps = nimmanager.getTransponders(orbpos) for x in tps: if x[0] == 0: # SAT tpslist.append((x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], orbpos, x[5], x[6], x[8], x[9])) elif self.scan_type.value == "multisat": if len(self.multiscanlist): for sat in self.multiscanlist: if sat[1].value or len(tpslist) == 0: if len(tpslist): del tpslist[:] tps = nimmanager.getTransponders(sat[0]) for x in tps: if x[0] == 0: # SAT tpslist.append( (x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], sat[0], x[5], x[6], x[8], x[9]) ) if sat[1].value: multi_tune = True break else: status_text = "multiscanlist empty!" SatList = nimmanager.getSatListForNim(index_to_scan) for sat in SatList: tps = nimmanager.getTransponders(sat[0]) for x in tps: if x[0] == 0: # SAT tpslist.append((x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], sat[0], x[5], x[6], x[8], x[9])) if len(tpslist): break self.tpslist = tpslist if len(self.tpslist): status_text = ( self.OrbToStr(self.tpslist[self.tpslist_idx][5]) + ": " + str(self.tpslist[self.tpslist_idx][0]) + " " + self.PolToStr(self.tpslist[self.tpslist_idx][2]) ) self.tune(self.tpslist[self.tpslist_idx]) if multi_tune: self.tuneTimer.start(100, True) self["status"].setText(status_text) def OrbToStr(self, orbpos=-1): if orbpos == -1 or orbpos > 3600: return "??" if orbpos > 1800: return "%d.%dW" % ((3600 - orbpos) / 10, (3600 - orbpos) % 10) else: return "%d.%dE" % (orbpos / 10, orbpos % 10) def PolToStr(self, pol): return (pol == 0 and "H") or (pol == 1 and "V") or (pol == 2 and "L") or (pol == 3 and "R") or "??" def FecToStr(self, fec): return ( (fec == 0 and "Auto") or (fec == 1 and "1/2") or (fec == 2 and "2/3") or (fec == 3 and "3/4") or (fec == 4 and "5/6") or (fec == 5 and "7/8") or (fec == 6 and "8/9") or (fec == 7 and "3/5") or (fec == 8 and "4/5") or (fec == 9 and "9/10") or (fec == 15 and "None") or "Unknown" ) def updateTranspondersList(self, orbpos): if orbpos is not None: index = 0 list = [] tps = nimmanager.getTransponders(orbpos) for x in tps: if x[0] == 0: # SAT s = ( str(x[1] / 1000) + " " + self.PolToStr(x[3]) + " / " + str(x[2] / 1000) + " / " + self.FecToStr(x[4]) ) list.append((str(index), s)) index += 1 self.scan_transponders = ConfigSelection(choices=list, default="0") self.scan_transponders.addNotifier(self.retune, initial_call=False) 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.tuneTimer.stop() self.list = [] self.multiscanlist = [] index_to_scan = int(self.scan_nims.value) self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) if self.scan_nims == []: return self.typeOfScanEntry = None self.systemEntry = None self.satelliteEntry = None self.modulationEntry = None self.scan_networkScan.value = False 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) if self.scan_type.value == "single_transponder": self.updateSatList() sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] self.updateTranspondersList(sat[0]) if nim.isCompatible("DVB-S2"): self.systemEntry = getConfigListEntry(_("System"), self.scan_sat.system) self.list.append(self.systemEntry) else: self.scan_sat.system.value = 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(_("Polarity"), self.scan_sat.polarization)) if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) elif self.scan_sat.system.value == 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(_("Rolloff"), self.scan_sat.rolloff)) self.list.append(getConfigListEntry(_("Pilot"), self.scan_sat.pilot)) elif self.scan_type.value == "predefined_transponder": self.updateSatList() self.satelliteEntry = getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan]) self.list.append(self.satelliteEntry) sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] self.updateTranspondersList(sat[0]) self.list.append(getConfigListEntry(_("Transponder"), self.scan_transponders)) elif self.scan_type.value == "single_satellite": self.updateSatList() sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] self.updateTranspondersList(sat[0]) print self.scan_satselection[index_to_scan] self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan])) self.scan_networkScan.value = True elif self.scan_type.value == "multisat": 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.value.find("_yes") != -1 and True or False) configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat) self.list.append(configEntry) self.multiscanlist.append((x[0], sat)) sat.addNotifier(self.retune, initial_call=False) self.scan_networkScan.value = True 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() if ( cur == self.typeOfScanEntry or cur == self.tunerEntry or cur == self.systemEntry or cur == self.satelliteEntry or ( self.modulationEntry and self.systemEntry[1].value == 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, } 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) self.scan_sat = ConfigSubsection() self.scan_type = ConfigSelection( default="single_transponder", choices=[ ("single_transponder", _("Single transponder")), ("predefined_transponder", _("Predefined transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ], ) self.scan_transponders = None 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 = [] 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.value)) if n.type == nimmanager.nim_slots[root_id].type: continue if n.isCompatible("DVB-S"): nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices=nim_list) 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"), ], ) 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")), ], ) self.scan_scansat = {} for sat in nimmanager.satList: self.scan_scansat[sat[0]] = ConfigYesNo(default=False) self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): x = getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]) x.addNotifier(self.retune, initial_call=False) self.scan_satselection.append(x) else: self.scan_satselection.append(None) for x in ( self.scan_nims, self.scan_type, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system, ): x.addNotifier(self.retune, initial_call=False) return True def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() 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 getInitialTransponderList(self, tlist, pos): list = nimmanager.getTransponders(pos) for x in list: if x[0] == 0: # SAT parm = eDVBFrontendParametersSatellite() parm.frequency = x[1] parm.symbol_rate = x[2] parm.polarisation = x[3] parm.fec = x[4] parm.inversion = x[7] parm.orbital_position = pos parm.system = x[5] parm.modulation = x[6] parm.rolloff = x[8] parm.pilot = x[9] tlist.append(parm) def keyGo(self): if self.scan_nims.value == "": return self.tuneTimer.stop() self.deInitFrontend() index_to_scan = int(self.scan_nims.value) self.feid = index_to_scan tlist = [] flags = None startScan = True removeAll = True self.prev_ref = True 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] if not nim.isCompatible("DVB-S"): return # if self.scan_type.value == "single_transponder": if self.scan_type.value.find("_transponder") != -1: 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 if len(nimsats): orbpos = nimsats[selsatidx][0] if self.scan_type.value == "single_transponder": if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.value else: fec = self.scan_sat.fec_s2.value self.addSatTransponder( tlist, self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, self.scan_sat.polarization.value, fec, self.scan_sat.inversion.value, orbpos, self.scan_sat.system.value, self.scan_sat.modulation.value, self.scan_sat.rolloff.value, self.scan_sat.pilot.value, ) elif self.scan_type.value == "predefined_transponder": tps = nimmanager.getTransponders(orbpos) if len(tps) > self.scan_transponders.index: x = tps[self.scan_transponders.index] self.addSatTransponder( tlist, x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], orbpos, x[5], x[6], x[8], x[9] ) removeAll = False elif self.scan_type.value == "single_satellite": sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] self.getInitialTransponderList(tlist, sat[0]) elif self.scan_type.value.find("multisat") != -1: SatList = nimmanager.getSatListForNim(index_to_scan) for x in self.multiscanlist: if x[1].value: print " " + str(x[0]) self.getInitialTransponderList(tlist, x[0]) flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0 tmp = self.scan_clearallservices.value 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.value: flags |= eComponentScan.scanOnlyFree for x in self["config"].list: x[1].save() if startScan: self.startScan(tlist, flags, index_to_scan) def keyCancel(self): for x in self["config"].list: x[1].cancel() if self.oldref and self.prev_ref: self.session.openWithCallback( self.restartPrevService, MessageBox, _("Zap back to service before a service scan?"), MessageBox.TYPE_YESNO, timeout=5, ) else: self.close() def restartPrevService(self, answer): if answer: self.tuneTimer.stop() self.deInitFrontend() if self.oldref: self.session.nav.playService(self.oldref) self.close() def startScan(self, tlist, flags, feid): if len(tlist): self.session.openWithCallback( self.serviceScanFinished, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags}] ) else: self.session.open( MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR, ) self.keyCancel() def serviceScanFinished(self): self.session.openWithCallback( self.restartSimpleSatScan, MessageBox, _("Do you want to scan another transponder/satellite?"), MessageBox.TYPE_YESNO, timeout=10, ) def restartSimpleSatScan(self, answer): if answer: # reinit FrontendStatus... self.frontend = None self.initFrontend() self.retune(None) else: self.keyCancel()
class NetworkTimeserverConfig(ConfigListScreen, Screen, ServiceBoundConfiguration): def __init__(self, session): Screen.__init__(self, session, windowTitle=_("Time server configuration")) ConfigListScreen.__init__(self, [], session=session) self.skinName = "NetworkServiceNSConfig" self._nm = eNetworkManager.getInstance() self._tsconfig = NetworkTimeserverConfiguration(self._nm) self["key_red"] = StaticText(_("Delete")) self["key_green"] = StaticText(_("New")) self["key_yellow"] = StaticText("") self["key_blue"] = StaticText(_("Reset")) self["activedns"] = StaticText(self.getActiveTimeserversText()) self["setupActions"] = ActionMap( ["OkCancelActions", "ColorActions"], { "red": self._remove, "green": self._add, "blue": self._reload, "save": self.close, "cancel": self.close, "ok": self.close, }, -2) self["config"].onSelectionChanged.append(self._checkButtons) choices_timeupdates = { eNetworkManager.TIME_UPDATES_AUTO: _("auto"), eNetworkManager.TIME_UPDATES_MANUAL: _("manual") } self._config_timeupdates = ConfigSelection( choices_timeupdates, default=self._nm.timeUpdates()) self._config_timeupdates.addNotifier(self._onConfigChange, initial_call=False) self.__timeservers_changed_conn = self._nm.timeserversChanged.connect( self._reload) self.onClose.append(self.__onClose) self._reload() def _checkButtons(self): cfg = self["config"].getCurrent() and self["config"].getCurrent()[1] self["key_red"].text = _( "Delete") if cfg != self._config_timeupdates else "" def _onConfigChange(self, element=None): self._nm.setTimeUpdates(self._config_timeupdates.value) self._createSetup() def getActiveTimeserversText(self): timeservers = list(self._nm.getTimeservers()) text = "" if timeservers: text = _("Active time servers:\n%s") % (", ".join(timeservers)) Log.i(text) return text def _remove(self): cfg = self["config"].getCurrent() if cfg and cfg[1] != self._config_timeupdates: self._tsconfig.remove(cfg[1]) self._createSetup() def _add(self): self._tsconfig.add() self._createSetup() def __onClose(self): self._tsconfig.save() def _reload(self): self._tsconfig.reload() self._createSetup() def _createSetup(self): self["activedns"].text = self.getActiveTimeserversText() lst = [ getConfigListEntry(_("NTP Time Updates"), self._config_timeupdates) ] lst.extend(self._tsconfig.getList()) self["config"].list = lst
class TimeshiftSettings(Screen,ConfigListScreen): def removeNotifier(self): self.onNotifiers.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.onNotifiers = [ ] 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.value))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(configele.value)) in locations: if fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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.value 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.value 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.value tmp = config.usage.allowed_timeshift_paths.value 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.value: self["config"].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value 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.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.timeshift_dirname.value 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.value))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(config.usage.timeshift_path.value)) in locations: config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.timeshift_path.save() self.saveAll() self.close() else: if int(config.timeshift.startdelay.value) > 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.value, type = MessageBox.TYPE_ERROR ) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() else: if int(config.timeshift.startdelay.value) > 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.value, 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.onNotifiers: self.onNotifiers.append(self.levelChanged) self.onClose.append(self.removeNotifier) if item_level > self.onNotifiers.index: continue requires = x.get("requires") if requires and requires.startswith('config.'): item = eval(requires or "") if item.value and not item.value == "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 OSD3DSetupScreen(Screen, ConfigListScreen): #class for configure 3D default settings 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["help"] = StaticText() self["actions"] = ActionMap(["SetupActions", "ColorActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "green": self.keyGo, "red": self.keyCancel, "0": self.keyZero, }, -2) # preparing setting items mode = config.plugins.OSD3DSetup.mode.value znorm = config.plugins.OSD3DSetup.znorm.value menuext = config.plugins.OSD3DSetup.menuext.value auto = config.plugins.OSD3DSetup.auto.value toggle = config.plugins.OSD3DSetup.toggle.value prompt = config.plugins.OSD3DSetup.prompt.value self.mode = ConfigSelection(choices = modelist, default = nz(mode, val_auto)) self.znorm = ConfigSlider(default = znorm + 50, increment = 1, limits = (0, 100)) self.menuext = ConfigSelection(choices = menulist, default = nz(menuext, "none")) self.auto = ConfigYesNo(default = nz(auto, False)) self.toggle = ConfigSelection(choices = togglelist, default = nz(toggle, val_sidebyside)) self.prompt = ConfigInteger(nz(prompt,10), limits=(0, 30)) # adding notifiers to immediatelly preview changed 3D settings self.mode.addNotifier(self.setPreviewSettings, initial_call = False) self.znorm.addNotifier(self.setPreviewSettings, initial_call = False) self.refresh() self.initHelpTexts() ConfigListScreen.__init__(self, self.list, session = self.session) self["config"].onSelectionChanged.append(self.updateHelp) def keyLeft(self): ConfigListScreen.keyLeft(self) self.reloadList() def keyRight(self): ConfigListScreen.keyRight(self) self.reloadList() def keyZero(self): cur = self["config"].getCurrent() if cur == getConfigListEntry(_("Depth"), self.znorm): self.znorm.value = 50 self.reloadList() else: ConfigListScreen.keyNumberGlobal(self, 0) def reloadList(self): self.refresh() self["config"].setList(self.list) def refresh(self): list = [] list.extend(( getConfigListEntry(_("3d mode"), self.mode), getConfigListEntry(_("Depth"), self.znorm), getConfigListEntry(_("Show in menu"), self.menuext), getConfigListEntry(_("Turn on automatically"), self.auto) )) # Only allow editing toggle mode when the 3d switch command is supposed to apear in menu or 3d should be turned on automatically if self.menuext.value is not "none" or self.auto.value: list.append(getConfigListEntry(_("Toggle mode"), self.toggle)) # Only allow editing user prompt when the 3d auto toggle is activated if self.auto.value: list.append(getConfigListEntry(_("Display 3D confirmation"), self.prompt)) self.list = list def initHelpTexts(self): self.helpDict = { self.mode: _("Choose 3D mode (Side by Side, Top And Bottom, Auto, Off)."), self.znorm: _("Set the depth of 3D effect. Press [0] for standard value."), self.menuext: _("Should quick toggle command be present in menu / extensions list?"), self.auto: _("Should the plugin turn on 3D mode automatically judging on the playing media title (3D in service or file name)?"), self.toggle: _("Define the mode to turn on 3D automatically or by quick toggle menu command [Side By Side] or [Top And Bottom]."), self.prompt: _("How long should 3D mode on confirmation be displayed (seconds). 0 for none."), } def updateHelp(self): cur = self["config"].getCurrent() if cur: self["help"].text = self.helpDict.get(cur[1], "") #channging mode or znorm is immediatelly previewed def setPreviewSettings(self, value): applySettings(self.mode.value, int(self.znorm.value) - 50) #setting are stored in enigma configuration file def keyGo(self): config.plugins.OSD3DSetup.mode.value = self.mode.value config.plugins.OSD3DSetup.znorm.value = int(self.znorm.value) - 50 config.plugins.OSD3DSetup.menuext.value = self.menuext.value config.plugins.OSD3DSetup.auto.value = self.auto.value config.plugins.OSD3DSetup.toggle.value = self.toggle.value config.plugins.OSD3DSetup.prompt.value = self.prompt.value config.plugins.OSD3DSetup.save() #refresh menus to reflect current settings plugins.readPluginList(resolveFilename(SCOPE_PLUGINS)) self.close() #roll-back changes - read settings from configuration def keyCancel(self): setConfiguredSettings() self.close()
class RecordPathsSettings(eRecordPathsSettings): def __init__(self, session): eRecordPathsSettings.__init__(self, session) self.onShown.append(self.__setWindowTitle) def __setWindowTitle(self): self.setTitle(_("Record Paths Settings")) def initConfigList(self): eRecordPathsSettings.initConfigList(self) tmp = config.movielist.videodirs.value default = config.AdvancedMovieSelection.movecopydirs.value if default not in tmp: tmp = tmp[:] tmp.append(default) print("MoveCopyPath: ", default, tmp) self.movecopy_dirname = ConfigSelection(default=default, choices=tmp) self.movecopy_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.movecopy_dirname.last_value = config.AdvancedMovieSelection.movecopydirs.value self.movecopy_entry = getConfigListEntry(_("Move/copy location:"), self.movecopy_dirname) self.list.append(self.movecopy_entry) self["config"].setList(self.list) if not self.selectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.selectionChanged) def selectionChanged(self): # Topfi: disabled three lines which causes GS #eRecordPathsSettings.selectionChanged(self) currentry = self["config"].getCurrent() #if currentry == self.movecopy_entry: # self["introduction"].setText(_("Please select the default move/copy location which is used for move/copy movies.")) def ok(self): eRecordPathsSettings.ok(self) currentry = self["config"].getCurrent() if currentry == self.movecopy_entry: self.entrydirname = self.movecopy_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Location for move/copy files"), preferredPath(self.movecopy_dirname.value) ) def dirnameSelected(self, res): eRecordPathsSettings.dirnameSelected(self, res) if res is not None: if config.AdvancedMovieSelection.movecopydirs.value != res: tmp = config.movielist.videodirs.value default = config.AdvancedMovieSelection.movecopydirs.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.movecopy_dirname.setChoices(tmp, default=default) def save(self): currentry = self["config"].getCurrent() if self.checkReadWriteDir(currentry[1]): config.AdvancedMovieSelection.movecopydirs.value = self.movecopy_dirname.value config.AdvancedMovieSelection.movecopydirs.save() eRecordPathsSettings.save(self)
class ServiceIPConfiguration(object): def __init__(self, service): self._service = service self.onChanged = [] self.onMethodChanged = [] method_choices_ip4 = { eNetworkService.METHOD_DHCP: "dhcp", eNetworkService.METHOD_MANUAL: _("manual"), eNetworkService.METHOD_OFF: _("off") } #IPv4 self._config_ip4_method = ConfigSelection( method_choices_ip4, default=eNetworkService.METHOD_DHCP) self._config_ip4_address = ConfigIP(default=[0, 0, 0, 0]) self._config_ip4_mask = ConfigIP(default=[0, 0, 0, 0]) self._config_ip4_gw = ConfigIP(default=[0, 0, 0, 0]) #IPv6 method_choices_ip6 = { eNetworkService.METHOD_AUTO: _("auto"), eNetworkService.METHOD_6TO4: "6to4", eNetworkService.METHOD_MANUAL: _("manual"), eNetworkService.METHOD_OFF: _("off") } choices_privacy_ip6 = { eNetworkService.IPV6_PRIVACY_DISABLED: _("Disabled"), eNetworkService.IPV6_PRIVACY_ENABLED: _("Enabled"), eNetworkService.IPV6_PRIVACY_PREFERRED: _("Preferred") } self._config_ip6_method = ConfigSelection( method_choices_ip6, default=eNetworkService.METHOD_DHCP) self._config_ip6_address = ConfigIP6() self._config_ip6_prefix_length = ConfigInteger(0, limits=(1, 128)) self._config_ip6_gw = ConfigIP6() self._config_ip6_privacy = ConfigSelection(choices_privacy_ip6, default="disabled") self._isReloading = False self._ipv4Changed = False self._ipv6Changed = False self._addNotifiers() self._service_conn = [ self._service.ipv4Changed.connect(self._serviceChanged), self._service.ipv6Changed.connect(self._serviceChanged), self._service.ipv4ConfigChanged.connect(self._serviceChanged), self._service.ipv6ConfigChanged.connect(self._serviceChanged), ] def _serviceChanged(self, *args): self.reload(force=False) def _addNotifiers(self): #Setup refresh self._config_ip4_method.addNotifier(self._methodChanged, initial_call=False) self._config_ip6_method.addNotifier(self._methodChanged, initial_call=False) #change tracking #ipv4 self._config_ip4_method.addNotifier(self._changedIP4, initial_call=False) self._config_ip4_address.addNotifier(self._changedIP4, initial_call=False) self._config_ip4_mask.addNotifier(self._changedIP4, initial_call=False) self._config_ip4_gw.addNotifier(self._changedIP4, initial_call=False) #ipv6 self._config_ip6_method.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_address.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_prefix_length.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_gw.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_privacy.addNotifier(self._changedIP6, initial_call=False) def _changedIP4(self, element): if not self._isReloading: self._ipv4Changed = True self._changed(element) def _changedIP6(self, element): if not self._isReloading: self._ipv6Changed = True self._changed(element) def _changed(self, element): if not self._isReloading: Log.i() for fnc in self.onChanged: fnc() def _methodChanged(self, element): if not self._isReloading: Log.i() for fnc in self.onMethodChanged: fnc() def reload(self, force=True): self._isReloading = True if force: self._ipv4Changed = False self._ipv6Changed = False if not self._ipv6Changed: ip4 = self._service.ipv4() if not dict(ip4): ip6 = self._service.ipv4Config() self._config_ip4_method.value = ip4.get(eNetworkService.KEY_METHOD, eNetworkService.METHOD_OFF) self._config_ip4_address.value = toIP4List( ip4.get("Address", "0.0.0.0")) self._config_ip4_mask.value = toIP4List( ip4.get(eNetworkService.KEY_NETMASK, "0.0.0.0")) self._config_ip4_gw.value = toIP4List( ip4.get(eNetworkService.KEY_GATEWAY, "0.0.0.0")) if not self._ipv6Changed: ip6 = self._service.ipv6() Log.i("%s / %s" % (dict(ip6), dict(self._service.ipv6Config()))) if not dict(ip6): ip6 = self._service.ipv6Config() self._config_ip6_method.value = ip6.get(eNetworkService.KEY_METHOD, eNetworkService.METHOD_OFF) self._config_ip6_address.value = ip6.get( eNetworkService.KEY_ADDRESS, "::") self._config_ip6_prefix_length.value = ord( ip6.get(eNetworkService.KEY_PREFIX_LENGTH, chr(1)) or chr(1)) self._config_ip6_gw.value = ip6.get(eNetworkService.KEY_GATEWAY, "::") self._config_ip6_privacy.value = ip6.get( eNetworkService.KEY_PRIVACY, eNetworkService.IPV6_PRIVACY_DISABLED) self._isReloading = False self._changed(None) def getList(self): if self._config_ip4_method.value == eNetworkService.METHOD_MANUAL: self._config_ip4_address.enabled = True self._config_ip4_mask.enabled = True self._config_ip4_gw.enabled = True else: self._config_ip4_address.enabled = False self._config_ip4_mask.enabled = False self._config_ip4_gw.enabled = False if self._config_ip6_method.value == eNetworkService.METHOD_MANUAL: self._config_ip6_address.enabled = True self._config_ip6_prefix_length.enabled = True self._config_ip6_gw.enabled = True else: self._config_ip6_address.enabled = False self._config_ip6_prefix_length.enabled = False self._config_ip6_gw.enabled = False l = [ getConfigListEntry(_("Method (IPv4)"), self._config_ip4_method), ] if self._config_ip4_method.value != eNetworkService.METHOD_OFF: l.extend([ getConfigListEntry(_("Address (IPv4)"), self._config_ip4_address), getConfigListEntry(_("Mask (IPv4)"), self._config_ip4_mask), getConfigListEntry(_("Gateway (IPv4)"), self._config_ip4_gw), ]) l.append( getConfigListEntry(_("Method (IPv6)"), self._config_ip6_method)) if self._config_ip6_method.value != eNetworkService.METHOD_OFF: l.extend([ getConfigListEntry(_("Address (IPv6)"), self._config_ip6_address), getConfigListEntry(_("Prefix length (IPv6)"), self._config_ip6_prefix_length), getConfigListEntry(_("Gateway (IPv6)"), self._config_ip6_gw), ]) if self._config_ip6_method.value in (eNetworkService.METHOD_AUTO, eNetworkService.METHOD_6TO4): l.append( getConfigListEntry(_("Privacy (IPv6)"), self._config_ip6_privacy)) return l def save(self): if self._ipv4Changed: Log.i("IPv4 Changed, saving!") if self._config_ip4_method.value == eNetworkService.METHOD_MANUAL: ip4_config = { eNetworkService.KEY_METHOD: self._config_ip4_method.value, eNetworkService.KEY_ADDRESS: toIP4String(self._config_ip4_address), eNetworkService.KEY_NETMASK: toIP4String(self._config_ip4_mask), eNetworkService.KEY_GATEWAY: toIP4String(self._config_ip4_gw), } else: ip4_config = { eNetworkService.KEY_METHOD: self._config_ip4_method.value } Log.i(ip4_config) self._service.setIpv4Config(ip4_config) if self._ipv6Changed: Log.i("IPv6 Changed, saving!") if self._config_ip6_method.value == eNetworkService.METHOD_MANUAL: ip6_config = { eNetworkService.KEY_METHOD: self._config_ip6_method.value, eNetworkService.KEY_ADDRESS: self._config_ip6_address.value, eNetworkService.KEY_PREFIX_LENGTH: self._config_ip6_prefix_length.value, eNetworkService.KEY_GATEWAY: self._config_ip6_gw.value, eNetworkService.KEY_PRIVACY: self._config_ip6_privacy.value, } else: val = self._config_ip6_method.value #avoid config element overhead here #one can not configure 6to4, it will automatically be applied by connman if applicable -> change it to auto if val == eNetworkService.METHOD_6TO4: val = eNetworkService.METHOD_AUTO ip6_config = {eNetworkService.KEY_METHOD: val} if val != eNetworkService.METHOD_OFF: ip6_config[eNetworkService. KEY_PRIVACY] = self._config_ip6_privacy.value Log.i(ip6_config) self._service.setIpv6Config(ip6_config)
class RecordPathsSettings(eRecordPathsSettings): def __init__(self, session): eRecordPathsSettings.__init__(self, session) self.onShown.append(self.__setWindowTitle) def __setWindowTitle(self): self.setTitle(_("Record Paths Settings")) def initConfigList(self): eRecordPathsSettings.initConfigList(self) tmp = config.movielist.videodirs.value default = config.AdvancedMovieSelection.movecopydirs.value if default not in tmp: tmp = tmp[:] tmp.append(default) print "MoveCopyPath: ", default, tmp self.movecopy_dirname = ConfigSelection(default=default, choices=tmp) self.movecopy_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False) self.movecopy_dirname.last_value = config.AdvancedMovieSelection.movecopydirs.value self.movecopy_entry = getConfigListEntry(_("Move/copy location:"), self.movecopy_dirname) self.list.append(self.movecopy_entry) self["config"].setList(self.list) if not self.selectionChanged in self["config"].onSelectionChanged: self["config"].onSelectionChanged.append(self.selectionChanged) def selectionChanged(self): # Topfi: disabled three lines which causes GS #eRecordPathsSettings.selectionChanged(self) currentry = self["config"].getCurrent() #if currentry == self.movecopy_entry: # self["introduction"].setText(_("Please select the default move/copy location which is used for move/copy movies.")) def ok(self): eRecordPathsSettings.ok(self) currentry = self["config"].getCurrent() if currentry == self.movecopy_entry: self.entrydirname = self.movecopy_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Location for move/copy files"), preferredPath(self.movecopy_dirname.value) ) def dirnameSelected(self, res): eRecordPathsSettings.dirnameSelected(self, res) if res is not None: if config.AdvancedMovieSelection.movecopydirs.value != res: tmp = config.movielist.videodirs.value default = config.AdvancedMovieSelection.movecopydirs.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.movecopy_dirname.setChoices(tmp, default=default) def save(self): currentry = self["config"].getCurrent() if self.checkReadWriteDir(currentry[1]): config.AdvancedMovieSelection.movecopydirs.value = self.movecopy_dirname.value config.AdvancedMovieSelection.movecopydirs.save() eRecordPathsSettings.save(self)
class MountSetup(Screen, ConfigListScreen): def __init__(self, session): Screen.__init__(self, session) self.skinName = ["Setup"] self.setTitle(_("PE Mount Manager Configuration")) self.Console = Console() self.list = [] self.swapdevice = [] self.device = GetDevices() self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Ok")) self["actions"] = ActionMap( ["OkCancelActions", "ColorActions"], { "cancel": self.Cancel, "ok": self.Ok, "green": self.Ok, "red": self.Cancel }, -2) self.Console.ePopen("sfdisk -l /dev/sd? | grep swap", self.CheckSwap) ConfigListScreen.__init__(self, self.list, session=session) def CheckSwap(self, result, retval, extra_args): if self.device: for line in result.splitlines(): if line and line[:4] == "/dev": swap = GetDeviceFromList(self.device, line[5:9]) if swap in self.device: self.device.remove(swap) self.swapdevice.append(swap) mounts = CheckMountDir(self.device) self.hdd = mounts[0] self.MountOnHdd = ConfigSelection(default = self.hdd, \ choices = [("nothing", _("nothing"))] + self.device) self.movie = mounts[1] self.MountOnMovie = ConfigSelection(default = self.movie, \ choices = [("nothing", _("nothing"))] + self.device) self.swap = "no" try: with open("/proc/swaps", "r") as f: for line in f.readlines(): if line[:19] == "/media/hdd/swapfile": self.swap = str( os.path.getsize("/media/hdd/swapfile") / 1024) else: for device in self.swapdevice: if device[:4] == line[5:9]: self.swap = device f.close() except IOError as ex: print("[MountManager] Failed to open /proc/swaps", ex) self.MountOnHdd.addNotifier(self.CreateList, initial_call=False) self.CreateList() def CreateList(self, configEntry=None): if self.device and self.MountOnHdd.value != "nothing": self.SwapFile = ConfigSelection(default = self.swap, \ choices = [("no", _("no")), ("65536", _("64MB")), ("131072", _("128MB")), ("262144", _("256MB")), ("524288", _("512MB"))] + self.swapdevice) else: if self.MountOnHdd.value == "nothing" \ and not self.swap[:2] == "sd": defaultswap = "no" else: defaultswap = self.swap self.SwapFile = ConfigSelection(default = defaultswap, \ choices = [("no", _("no"))] + self.swapdevice) self.list = [] self.list.append( getConfigListEntry(_("Mount All On Startup"), config.plugins.HddMount.MountOnStart)) self.list.append( getConfigListEntry(_("Mount On /media/hdd"), self.MountOnHdd)) self.list.append( getConfigListEntry(_("Mount On /media/hdd/movie"), self.MountOnMovie)) self.list.append( getConfigListEntry(_("Enable Swap On Startup"), config.plugins.HddMount.SwapOnStart)) self.list.append(getConfigListEntry(_("Enable Swap"), self.SwapFile)) self["config"].list = self.list self["config"].l.setList(self.list) def Ok(self): if self.list: config.plugins.HddMount.MountOnHdd.value = self.MountOnHdd.value if self.MountOnHdd.value != self.hdd: if self.hdd != "nothing": self.Console.ePopen("umount -f /media/hdd") if self.MountOnHdd.value != "nothing": mountdevice.Mount("/dev/" + self.MountOnHdd.value[:4], \ "/media/hdd") config.plugins.HddMount.MountOnMovie.value = self.MountOnMovie.value if self.MountOnMovie.value != self.movie: if self.movie != "nothing": self.Console.ePopen("umount -f /media/hdd/movie") if self.MountOnMovie.value != "nothing": mountdevice.Mount("/dev/" + self.MountOnMovie.value[:4], \ "/media/hdd/movie") config.plugins.HddMount.SwapFile.value = self.SwapFile.value if self.SwapFile.value != self.swap: if self.swap[:2] == "sd": self.Console.ePopen("swapoff /dev/%s" % self.swap[:4]) elif self.swap != "no": self.Console.ePopen("swapoff /media/hdd/swapfile") self.Console.ePopen("rm -rf /media/hdd/swapfile") if self.SwapFile.value != "no": self.mbox = None if not self.SwapFile.value[:2] == "sd": msg = _("Please Wait , Creating Swap File ...") self.mbox = self.session.open(MessageBox, msg, MessageBox.TYPE_INFO) self.CreateSwapFile() config.plugins.HddMount.save() self.close() def CreateSwapFile(self): if self.SwapFile.value[:2] == "sd": Console().ePopen("swapon /dev/%s" % self.SwapFile.value[:4]) else: Console().ePopen("dd if=/dev/zero of=/media/hdd/swapfile bs=1024 count=%s" \ % atoi(self.SwapFile.value), self.MakeSwapFile) def MakeSwapFile(self, result, retval, extra_args): Console().ePopen("mkswap /media/hdd/swapfile", self.EnableSwapFile) def EnableSwapFile(self, result, retval, extra_args): Console().ePopen("swapon /media/hdd/swapfile") if self.mbox: self.mbox.close() def Cancel(self): ConfigListScreen.keyCancel(self)
class ServiceIPConfiguration(object): def __init__(self, service): self._service = service self.onChanged = [] self.onMethodChanged = [] method_choices_ip4 = {eNetworkService.METHOD_DHCP : "dhcp", eNetworkService.METHOD_MANUAL : _("manual"), eNetworkService.METHOD_OFF : _("off")} #IPv4 self._config_ip4_method = ConfigSelection(method_choices_ip4, default=eNetworkService.METHOD_DHCP) self._config_ip4_address = ConfigIP(default=[0,0,0,0]) self._config_ip4_mask = ConfigIP(default=[0,0,0,0]) self._config_ip4_gw = ConfigIP(default=[0,0,0,0]) #IPv6 method_choices_ip6 = {eNetworkService.METHOD_AUTO : _("auto"), eNetworkService.METHOD_6TO4 : "6to4", eNetworkService.METHOD_MANUAL : _("manual"), eNetworkService.METHOD_OFF : _("off")} choices_privacy_ip6 = {eNetworkService.IPV6_PRIVACY_DISABLED : _("Disabled"), eNetworkService.IPV6_PRIVACY_ENABLED : _("Enabled"), eNetworkService.IPV6_PRIVACY_PREFERRED : _("Preferred")} self._config_ip6_method = ConfigSelection(method_choices_ip6, default=eNetworkService.METHOD_DHCP) self._config_ip6_address = ConfigIP6() self._config_ip6_prefix_length = ConfigInteger(0, limits=(1, 128)) self._config_ip6_gw = ConfigIP6() self._config_ip6_privacy = ConfigSelection(choices_privacy_ip6, default="disabled") self._isReloading = False self._ipv4Changed = False self._ipv6Changed = False self._addNotifiers() self._service_conn = [ self._service.ipv4Changed.connect(self._serviceChanged), self._service.ipv6Changed.connect(self._serviceChanged), self._service.ipv4ConfigChanged.connect(self._serviceChanged), self._service.ipv6ConfigChanged.connect(self._serviceChanged), ] def _serviceChanged(self, *args): self.reload(force=False) def _addNotifiers(self): #Setup refresh self._config_ip4_method.addNotifier(self._methodChanged, initial_call=False) self._config_ip6_method.addNotifier(self._methodChanged, initial_call=False) #change tracking #ipv4 self._config_ip4_method.addNotifier(self._changedIP4, initial_call=False) self._config_ip4_address.addNotifier(self._changedIP4, initial_call=False) self._config_ip4_mask.addNotifier(self._changedIP4, initial_call=False) self._config_ip4_gw.addNotifier(self._changedIP4, initial_call=False) #ipv6 self._config_ip6_method.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_address.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_prefix_length.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_gw.addNotifier(self._changedIP6, initial_call=False) self._config_ip6_privacy.addNotifier(self._changedIP6, initial_call=False) def _changedIP4(self, element): if not self._isReloading: self._ipv4Changed = True self._changed(element) def _changedIP6(self, element): if not self._isReloading: self._ipv6Changed = True self._changed(element) def _changed(self, element): if not self._isReloading: Log.i() for fnc in self.onChanged: fnc() def _methodChanged(self, element): if not self._isReloading: Log.i() for fnc in self.onMethodChanged: fnc() def reload(self, force=True): self._isReloading = True if force: self._ipv4Changed = False self._ipv6Changed = False if not self._ipv6Changed: ip4 = self._service.ipv4() if not dict(ip4): ip6 = self._service.ipv4Config() self._config_ip4_method.value = ip4.get(eNetworkService.KEY_METHOD, eNetworkService.METHOD_OFF) self._config_ip4_address.value = toIP4List( ip4.get("Address", "0.0.0.0") ) self._config_ip4_mask.value = toIP4List( ip4.get(eNetworkService.KEY_NETMASK, "0.0.0.0") ) self._config_ip4_gw.value = toIP4List( ip4.get(eNetworkService.KEY_GATEWAY, "0.0.0.0") ) if not self._ipv6Changed: ip6 = self._service.ipv6() Log.i("%s / %s" %(dict(ip6), dict(self._service.ipv6Config())) ) if not dict(ip6): ip6 = self._service.ipv6Config() self._config_ip6_method.value = ip6.get(eNetworkService.KEY_METHOD, eNetworkService.METHOD_OFF) self._config_ip6_address.value = ip6.get(eNetworkService.KEY_ADDRESS, "::") self._config_ip6_prefix_length.value = ord( ip6.get(eNetworkService.KEY_PREFIX_LENGTH, chr(1)) or chr(1) ) self._config_ip6_gw.value = ip6.get(eNetworkService.KEY_GATEWAY, "::") self._config_ip6_privacy.value = ip6.get(eNetworkService.KEY_PRIVACY, eNetworkService.IPV6_PRIVACY_DISABLED) self._isReloading = False self._changed(None) def getList(self): if self._config_ip4_method.value == eNetworkService.METHOD_MANUAL: self._config_ip4_address.enabled = True self._config_ip4_mask.enabled = True self._config_ip4_gw.enabled = True else: self._config_ip4_address.enabled = False self._config_ip4_mask.enabled = False self._config_ip4_gw.enabled = False if self._config_ip6_method.value == eNetworkService.METHOD_MANUAL: self._config_ip6_address.enabled = True self._config_ip6_prefix_length.enabled = True self._config_ip6_gw.enabled = True else: self._config_ip6_address.enabled = False self._config_ip6_prefix_length.enabled = False self._config_ip6_gw.enabled = False l = [ getConfigListEntry(_("Method (IPv4)"), self._config_ip4_method), ] if self._config_ip4_method.value != eNetworkService.METHOD_OFF: l.extend([ getConfigListEntry(_("Address (IPv4)"), self._config_ip4_address), getConfigListEntry(_("Mask (IPv4)"), self._config_ip4_mask), getConfigListEntry(_("Gateway (IPv4)"), self._config_ip4_gw), ]) l.append( getConfigListEntry(_("Method (IPv6)"), self._config_ip6_method)) if self._config_ip6_method.value != eNetworkService.METHOD_OFF: l.extend([ getConfigListEntry(_("Address (IPv6)"), self._config_ip6_address), getConfigListEntry(_("Prefix length (IPv6)"), self._config_ip6_prefix_length), getConfigListEntry(_("Gateway (IPv6)"), self._config_ip6_gw), ]) if self._config_ip6_method.value in (eNetworkService.METHOD_AUTO, eNetworkService.METHOD_6TO4): l.append( getConfigListEntry(_("Privacy (IPv6)"), self._config_ip6_privacy) ) return l def save(self): if self._ipv4Changed: Log.i("IPv4 Changed, saving!") if self._config_ip4_method.value == eNetworkService.METHOD_MANUAL: ip4_config = { eNetworkService.KEY_METHOD : self._config_ip4_method.value, eNetworkService.KEY_ADDRESS : toIP4String(self._config_ip4_address), eNetworkService.KEY_NETMASK : toIP4String(self._config_ip4_mask), eNetworkService.KEY_GATEWAY : toIP4String(self._config_ip4_gw), } else: ip4_config = { eNetworkService.KEY_METHOD : self._config_ip4_method.value } Log.i(ip4_config) self._service.setIpv4Config(ip4_config) if self._ipv6Changed: Log.i("IPv6 Changed, saving!") if self._config_ip6_method.value == eNetworkService.METHOD_MANUAL: ip6_config = { eNetworkService.KEY_METHOD : self._config_ip6_method.value, eNetworkService.KEY_ADDRESS : self._config_ip6_address.value, eNetworkService.KEY_PREFIX_LENGTH : self._config_ip6_prefix_length.value, eNetworkService.KEY_GATEWAY : self._config_ip6_gw.value, eNetworkService.KEY_PRIVACY : self._config_ip6_privacy.value, } else: val = self._config_ip6_method.value #avoid config element overhead here #one can not configure 6to4, it will automatically be applied by connman if applicable -> change it to auto if val == eNetworkService.METHOD_6TO4: val = eNetworkService.METHOD_AUTO ip6_config = { eNetworkService.KEY_METHOD : val } if val != eNetworkService.METHOD_OFF: ip6_config[eNetworkService.KEY_PRIVACY] = self._config_ip6_privacy.value Log.i(ip6_config) self._service.setIpv6Config(ip6_config)
class RecordingSettings(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): 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.value if configele.value in [x[0] for x in self.styles] or fileExists( configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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.value default = config.usage.default_path.value 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.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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.value: 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.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value self.lastautorecorddirs = config.usage.allowed_autorecord_paths.value 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.value)) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("New timers location"), preferredPath(self.timer_dirname.value)) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Instant recordings location"), preferredPath(self.instantrec_dirname.value)) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value 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.value and not item.value == "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 Satfinder(ScanSetup): 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 __init__(self, session, feid): self.initcomplete = False self.feid = feid self.oldref = None if not self.openFrontend(): self.oldref = session.nav.getCurrentlyPlayingServiceReference() session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if session.pipshown: # try to disable pip session.pipshown = False session.deleteDialog(session.pip) del session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen ScanSetup.__init__(self, session, 'S') self.tuner = Tuner(self.frontend) self["introduction"].setText("") self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100) self.initcomplete = True self.onClose.append(self.__onClose) def __onClose(self): self.session.nav.playService(self.oldref) def createSetup(self): self.plpidAutoEntry = None self.fecEntry = None self.systemEntry = None self.modulationEntry = None self.satelliteEntry = None self.enableMisEntry = None self.plsModeEntry = None self.tunerEntry = None self.list = [] self.typeOfScanEntry = getConfigListEntry(_('Tune'), self.tuning_type) self.list.append(self.typeOfScanEntry) self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat) self.list.append(self.satEntry) nim = nimmanager.nim_slots[self.feid] self.systemEntry = None if self.tuning_type.value == "manual_transponder": 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.value = eDVBFrontendParametersSatellite.System_DVB_S 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.value == eDVBFrontendParametersSatellite.System_DVB_S2: self.modulationEntry = getConfigListEntry(_('Modulation'), nim.can_modulation_auto and self.scan_sat.modulation_auto or self.scan_sat.modulation) mod = self.modulationEntry[1].value if mod == eDVBFrontendParametersSatellite.Modulation_8PSK: self.fecEntry = getConfigListEntry(_("FEC"), nim.can_auto_fec_s2 and self.scan_sat.fec_s2_8psk_auto or self.scan_sat.fec_s2_8psk) else: self.fecEntry = getConfigListEntry(_("FEC"), nim.can_auto_fec_s2 and self.scan_sat.fec_s2_qpsk_auto or self.scan_sat.fec_s2_qpsk) self.list.append(self.fecEntry) self.list.append(self.modulationEntry) self.list.append(getConfigListEntry(_('Roll-off'), self.scan_sat.rolloff)) self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) if nim.can_multistream_s2: self.enableMisEntry = getConfigListEntry(_('Multistream'), self.scan_sat.enable_mis) self.list.append(self.enableMisEntry) if self.scan_sat.enable_mis.value: self.list.append(getConfigListEntry(_('Stream ID'), self.scan_sat.is_id)) if nim.can_pls_s2: self.plsModeEntry = getConfigListEntry(_('PLS Mode'), self.scan_sat.pls_mode) self.list.append(self.plsModeEntry) if self.scan_sat.pls_mode.value != eDVBFrontendParametersSatellite.PLS_Unknown: self.list.append(getConfigListEntry(_('PLS Code'), self.scan_sat.pls_code)) else: self.fecEntry = getConfigListEntry(_("FEC"), self.scan_sat.fec) self.list.append(self.fecEntry) elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder": self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder)) self["config"].list = self.list self["config"].l.setList(self.list) def newConfig(self): cur = self["config"].getCurrent() if cur is None: pass elif cur == self.satEntry: self.updateSats() self.createSetup() else: ScanSetup.newConfig(self) if self.systemEntry and cur == self.systemEntry or \ cur == self.tuning_type: self.retune(None) def sat_changed(self, config_element): self.newConfig() self.retune(config_element) def retune(self, configElement): returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) satpos = int(self.tuning_sat.value) if self.tuning_type.value == "manual_transponder": if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.value mod = eDVBFrontendParametersSatellite.Modulation_QPSK else: mod = self.modulationEntry[1].value fec = self.fecEntry[1].value returnvalue = ( self.scan_sat.frequency.float, self.scan_sat.symbolrate.value, self.scan_sat.polarization.value, fec, self.scan_sat.inversion.value, satpos, self.scan_sat.system.value, mod, self.scan_sat.rolloff.value, self.scan_sat.pilot.value, self.scan_sat.is_id.value if self.scan_sat.enable_mis.value else -1, self.scan_sat.pls_mode.value, self.scan_sat.pls_code.value if self.scan_sat.pls_mode.value < eDVBFrontendParametersSatellite.PLS_Unknown else 0) self.tune(returnvalue) elif self.tuning_type.value == "predefined_transponder": tps = nimmanager.getTransponders(satpos) l = len(tps) if l > self.tuning_transponder.index: transponder = tps[self.tuning_transponder.index] returnvalue = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9]) self.tune(returnvalue) def createConfig(self, foo): self.tuning_transponder = None self.tuning_type = ConfigSelection(choices = [("manual_transponder", _("Manual transponder")), ("predefined_transponder", _("Predefined transponder"))]) self.tuning_sat = getConfigSatlist(192, nimmanager.getSatListForNim(self.feid)) ScanSetup.createConfig(self, None) self.updateSats() for x in (self.tuning_sat, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.fec_s2_8psk, self.scan_sat.fec_s2_8psk_auto, self.scan_sat.fec_s2_qpsk, self.scan_sat.fec_s2_qpsk_auto, self.scan_sat.modulation, self.scan_sat.modulation_auto, self.scan_sat.enable_mis, self.scan_sat.is_id, self.scan_sat.pls_mode, self.scan_sat.pls_code, self.scan_sat.pilot, self.scan_sat.rolloff): x.addNotifier(self.retune, initial_call = False) def updateSats(self): orb_pos = self.tuning_sat.orbital_position if orb_pos is not None: transponderlist = nimmanager.getTransponders(orb_pos) list = [] default = None index = 0 for x in transponderlist: if x[3] == 0: pol = "H" elif x[3] == 1: pol = "V" elif x[3] == 2: pol = "CL" elif x[3] == 3: pol = "CR" else: pol = "??" if x[4] == 0: fec = "FEC Auto" elif x[4] == 1: fec = "FEC 1/2" elif x[4] == 2: fec = "FEC 2/3" elif x[4] == 3: fec = "FEC 3/4" elif x[4] == 4: fec = "FEC 5/6" elif x[4] == 5: fec = "FEC 7/8" elif x[4] == 6: fec = "FEC 8/9" elif x[4] == 7: fec = "FEC 3/5" elif x[4] == 8: fec = "FEC 4/5" elif x[4] == 9: fec = "FEC 9/10" elif x[4] == 15: fec = "FEC None" else: fec = "FEC Unknown" e = str(x[1]) + "," + str(x[2]) + "," + pol + "," + fec if default is None: default = str(index) list.append((str(index), e)) index += 1 self.tuning_transponder = ConfigSelection(choices = list, default = default) self.tuning_transponder.addNotifier(self.retune, initial_call = False) def keyGo(self): self.retune(self.tuning_type) 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 satfinder?"), MessageBox.TYPE_YESNO) else: self.restartPrevService(False) def tune(self, transponder): if self.initcomplete: if transponder is not None: self.tuner.tune(transponder)
class NimSetup(Screen, ConfigListScreen, ServiceStopScreen): def createSimpleSetup(self, list, mode): nim = self.nimConfig if mode == "single": self.singleSatEntry = getConfigListEntry(_("Satellite"), nim.diseqcA) list.append(self.singleSatEntry) if nim.diseqcA.value in ("360", "560"): list.append(getConfigListEntry(_("Use circular LNB"), nim.simpleDiSEqCSetCircularLNB)) list.append(getConfigListEntry(_("Send DiSEqC"), nim.simpleSingleSendDiSEqC)) else: list.append(getConfigListEntry(_("Port A"), nim.diseqcA)) if mode in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"): list.append(getConfigListEntry(_("Port B"), nim.diseqcB)) if mode == "diseqc_a_b_c_d": list.append(getConfigListEntry(_("Port C"), nim.diseqcC)) list.append(getConfigListEntry(_("Port D"), nim.diseqcD)) if mode != "toneburst_a_b": list.append(getConfigListEntry(_("Set voltage and 22KHz"), nim.simpleDiSEqCSetVoltageTone)) list.append(getConfigListEntry(_("Send DiSEqC only on satellite change"), nim.simpleDiSEqCOnlyOnSatChange)) def createPositionerSetup(self, list): nim = self.nimConfig if nim.diseqcMode.value == "positioner_select": self.selectSatsEntry = getConfigListEntry(_("Press OK to select satellites"), self.nimConfig.pressOKtoList) list.append(self.selectSatsEntry) list.append(getConfigListEntry(_("Longitude"), nim.longitude)) list.append(getConfigListEntry(" ", nim.longitudeOrientation)) list.append(getConfigListEntry(_("Latitude"), nim.latitude)) list.append(getConfigListEntry(" ", nim.latitudeOrientation)) if SystemInfo["CanMeasureFrontendInputPower"]: self.advancedPowerMeasurement = getConfigListEntry(_("Use power measurement"), nim.powerMeasurement) list.append(self.advancedPowerMeasurement) if nim.powerMeasurement.value: list.append(getConfigListEntry(_("Power threshold in mA"), nim.powerThreshold)) self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), nim.turningSpeed) list.append(self.turningSpeed) if nim.turningSpeed.value == "fast epoch": self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), nim.fastTurningBegin) self.turnFastEpochEnd = getConfigListEntry(_("End time"), nim.fastTurningEnd) list.append(self.turnFastEpochBegin) list.append(self.turnFastEpochEnd) else: if nim.powerMeasurement.value: nim.powerMeasurement.value = False nim.powerMeasurement.save() if not hasattr(self, 'additionalMotorOptions'): self.additionalMotorOptions = NoSave(ConfigYesNo(False)) self.showAdditionalMotorOptions = getConfigListEntry(_("Extra motor options"), self.additionalMotorOptions) self.list.append(self.showAdditionalMotorOptions) if self.additionalMotorOptions.value: self.list.append(getConfigListEntry(" " + _("Horizontal turning speed") + " [" + chr(176) + "/sec]", nim.turningspeedH)) self.list.append(getConfigListEntry(" " + _("Vertical turning speed") + " [" + chr(176) + "/sec]", nim.turningspeedV)) self.list.append(getConfigListEntry(" " + _("Turning step size") + " [" + chr(176) + "]", nim.tuningstepsize)) self.list.append(getConfigListEntry(" " + _("Max memory positions"), nim.rotorPositions)) def createConfigMode(self): if self.nim.isCompatible("DVB-S"): choices = {"nothing": _("Not configured"), "simple": _("Simple"), "advanced": _("Advanced")} if len(nimmanager.canEqualTo(self.slotid)) > 0: choices["equal"] = _("Equal to") if len(nimmanager.canDependOn(self.slotid)) > 0: choices["satposdepends"] = _("Second cable of motorized LNB") if len(nimmanager.canConnectTo(self.slotid)) > 0: choices["loopthrough"] = _("Loop through from") if self.nim.isFBCLink(): choices = { "nothing": _("FBC automatic"), "advanced": _("FBC SCR (Unicable/JESS)")} self.nimConfig.configMode.setChoices(choices, self.nim.isFBCLink() and "nothing" or "simple") def createSetup(self): self.list = [ ] self.multiType = None self.configMode = None self.diseqcModeEntry = None self.advancedSatsEntry = None self.advancedLnbsEntry = None self.advancedDiseqcMode = None self.advancedUsalsEntry = None self.advancedLof = None self.advancedPowerMeasurement = None self.turningSpeed = None self.turnFastEpochBegin = None self.turnFastEpochEnd = None self.toneburst = None self.committedDiseqcCommand = None self.uncommittedDiseqcCommand = None self.commandOrder = None self.cableScanType = None self.cableConfigScanDetails = None self.have_advanced = False self.advancedUnicable = None self.advancedFormat = None self.advancedPosition = None self.advancedType = None self.advancedManufacturer = None self.advancedSCR = None self.advancedConnected = None self.showAdditionalMotorOptions = None self.selectSatsEntry = None self.advancedSelectSatsEntry = None self.singleSatEntry = None self.toneamplitude = None self.scpc = None self.forcelnbpower = None self.forcetoneburst = None self.terrestrialRegionsEntry = None self.cableRegionsEntry = None if not hasattr(self, "terrestrialCountriesEntry"): self.terrestrialCountriesEntry = None if not hasattr(self, "cableCountriesEntry"): self.cableCountriesEntry = None if self.nim.isMultiType(): multiType = self.nimConfig.multiType self.multiType = getConfigListEntry(_("Tuner type"), multiType) self.list.append(self.multiType) if self.nim.isCompatible("DVB-S"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) if self.nimConfig.configMode.value == "simple": #simple setup self.diseqcModeEntry = getConfigListEntry(pgettext("Satellite configuration mode", "Mode"), self.nimConfig.diseqcMode) self.list.append(self.diseqcModeEntry) if self.nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"): self.createSimpleSetup(self.list, self.nimConfig.diseqcMode.value) if self.nimConfig.diseqcMode.value in ("positioner", "positioner_select"): self.createPositionerSetup(self.list) elif self.nimConfig.configMode.value == "equal": choices = [] nimlist = nimmanager.canEqualTo(self.nim.slot) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo)) elif self.nimConfig.configMode.value == "satposdepends": choices = [] nimlist = nimmanager.canDependOn(self.nim.slot) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo)) elif self.nimConfig.configMode.value == "loopthrough": choices = [] print "connectable to:", nimmanager.canConnectTo(self.slotid) connectable = nimmanager.canConnectTo(self.slotid) for id in connectable: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Connected to"), self.nimConfig.connectedTo)) elif self.nimConfig.configMode.value == "nothing": pass elif self.nimConfig.configMode.value == "advanced": # advanced # SATs self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats) self.list.append(self.advancedSatsEntry) current_config_sats = self.nimConfig.advanced.sats.value if current_config_sats in ("3605", "3606"): self.advancedSelectSatsEntry = getConfigListEntry(_("Press OK to select satellites"), self.nimConfig.pressOKtoList) self.list.append(self.advancedSelectSatsEntry) self.fillListWithAdvancedSatEntrys(self.nimConfig.advanced.sat[int(current_config_sats)]) else: cur_orb_pos = self.nimConfig.advanced.sats.orbital_position satlist = self.nimConfig.advanced.sat.keys() if cur_orb_pos is not None: if cur_orb_pos not in satlist: cur_orb_pos = satlist[0] self.fillListWithAdvancedSatEntrys(self.nimConfig.advanced.sat[cur_orb_pos]) self.have_advanced = True if self.nimConfig.configMode.value != "nothing" and config.usage.setup_level.index >= 2: if fileExists("/proc/stb/frontend/%d/tone_amplitude" % self.nim.slot): self.toneamplitude = getConfigListEntry(_("Tone amplitude"), self.nimConfig.toneAmplitude) self.list.append(self.toneamplitude) if fileExists("/proc/stb/frontend/%d/use_scpc_optimized_search_range" % self.nim.slot): self.scpc = getConfigListEntry(_("SCPC optimized search range"), self.nimConfig.scpcSearchRange) self.list.append(self.scpc) if SystemInfo["HasForceLNBOn"] and self.nim.isFBCRoot(): self.forcelnbpower = getConfigListEntry(_("Force LNB Power"), config.misc.forceLnbPower) self.list.append(self.forcelnbpower) if SystemInfo["HasForceToneburst"] and self.nim.isFBCRoot(): self.forcetoneburst = getConfigListEntry(_("Force ToneBurst"), config.misc.forceToneBurst) self.list.append(self.forcetoneburst) elif self.nim.isCompatible("DVB-C"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) if self.nimConfig.configMode.value == "enabled": self.list.append(getConfigListEntry(_("Network ID"), self.nimConfig.cable.scan_networkid)) self.cableScanType=getConfigListEntry(_("Used service scan type"), self.nimConfig.cable.scan_type) self.list.append(self.cableScanType) if self.nimConfig.cable.scan_type.value == "provider": # country/region tier one if self.cableCountriesEntry is None: cablecountrycodelist = nimmanager.getCablesCountrycodeList() cablecountrycode = nimmanager.getCableCountrycode(self.slotid) default = cablecountrycode in cablecountrycodelist and cablecountrycode or None choices = [("all", _("All"))]+sorted([(x, self.countrycodeToCountry(x)) for x in cablecountrycodelist], key=lambda listItem: listItem[1]) self.cableCountries = ConfigSelection(default = default, choices = choices) self.cableCountriesEntry = getConfigListEntry(_("Country"), self.cableCountries) self.originalCableRegion = self.nimConfig.cable.scan_provider.value # country/region tier two if self.cableCountries.value == "all": cableNames = [x[0] for x in sorted(sorted(nimmanager.getCablesList(), key=lambda listItem: listItem[0]), key=lambda listItem: self.countrycodeToCountry(listItem[2]))] else: cableNames = sorted([x[0] for x in nimmanager.getCablesByCountrycode(self.cableCountries.value)]) default = self.nimConfig.cable.scan_provider.value in cableNames and self.nimConfig.cable.scan_provider.value or None self.cableRegions = ConfigSelection(default = default, choices = cableNames) def updateCableProvider(configEntry): self.nimConfig.cable.scan_provider.value = configEntry.value self.nimConfig.cable.scan_provider.save() self.cableRegions.addNotifier(updateCableProvider) self.cableRegionsEntry = getConfigListEntry(_("Region"), self.cableRegions) self.list.append(self.cableCountriesEntry) self.list.append(self.cableRegionsEntry) else: self.cableConfigScanDetails = getConfigListEntry(_("Config Scan Details"), self.nimConfig.cable.config_scan_details) self.list.append(self.cableConfigScanDetails) if self.nimConfig.cable.config_scan_details.value: if self.nimConfig.cable.scan_type.value == "bands": # TRANSLATORS: option name, indicating which type of (DVB-C) band should be scanned. The name of the band is printed in '%s'. E.g.: 'Scan EU MID band' self.list.append(getConfigListEntry(_("Scan %s band") % ("EU VHF I"), self.nimConfig.cable.scan_band_EU_VHF_I)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU MID"), self.nimConfig.cable.scan_band_EU_MID)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU VHF III"), self.nimConfig.cable.scan_band_EU_VHF_III)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU UHF IV"), self.nimConfig.cable.scan_band_EU_UHF_IV)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU UHF V"), self.nimConfig.cable.scan_band_EU_UHF_V)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU SUPER"), self.nimConfig.cable.scan_band_EU_SUPER)) self.list.append(getConfigListEntry(_("Scan %s band") % ("EU HYPER"), self.nimConfig.cable.scan_band_EU_HYPER)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US LOW"), self.nimConfig.cable.scan_band_US_LOW)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US MID"), self.nimConfig.cable.scan_band_US_MID)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US HIGH"), self.nimConfig.cable.scan_band_US_HIGH)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US SUPER"), self.nimConfig.cable.scan_band_US_SUPER)) self.list.append(getConfigListEntry(_("Scan %s band") % ("US HYPER"), self.nimConfig.cable.scan_band_US_HYPER)) else: self.list.append(getConfigListEntry(_("Frequency scan step size(khz)"), self.nimConfig.cable.scan_frequency_steps)) # TRANSLATORS: option name, indicating which type of (DVB-C) modulation should be scanned. The modulation type is printed in '%s'. E.g.: 'Scan QAM16' self.list.append(getConfigListEntry(_("Scan %s") % ("QAM16"), self.nimConfig.cable.scan_mod_qam16)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM32"), self.nimConfig.cable.scan_mod_qam32)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM64"), self.nimConfig.cable.scan_mod_qam64)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM128"), self.nimConfig.cable.scan_mod_qam128)) self.list.append(getConfigListEntry(_("Scan %s") % ("QAM256"), self.nimConfig.cable.scan_mod_qam256)) self.list.append(getConfigListEntry(_("Scan %s") % ("SR6900"), self.nimConfig.cable.scan_sr_6900)) self.list.append(getConfigListEntry(_("Scan %s") % ("SR6875"), self.nimConfig.cable.scan_sr_6875)) self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext1)) self.list.append(getConfigListEntry(_("Scan additional SR"), self.nimConfig.cable.scan_sr_ext2)) self.have_advanced = False elif self.nim.isCompatible("DVB-T"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) self.have_advanced = False if self.nimConfig.configMode.value == "enabled": # country/region tier one if self.terrestrialCountriesEntry is None: terrestrialcountrycodelist = nimmanager.getTerrestrialsCountrycodeList() terrestrialcountrycode = nimmanager.getTerrestrialCountrycode(self.slotid) default = terrestrialcountrycode in terrestrialcountrycodelist and terrestrialcountrycode or None choices = [("all", _("All"))]+sorted([(x, self.countrycodeToCountry(x)) for x in terrestrialcountrycodelist], key=lambda listItem: listItem[1]) self.terrestrialCountries = ConfigSelection(default = default, choices = choices) self.terrestrialCountriesEntry = getConfigListEntry(_("Country"), self.terrestrialCountries) self.originalTerrestrialRegion = self.nimConfig.terrestrial.value # country/region tier two if self.terrestrialCountries.value == "all": terrstrialNames = [x[0] for x in sorted(sorted(nimmanager.getTerrestrialsList(), key=lambda listItem: listItem[0]), key=lambda listItem: self.countrycodeToCountry(listItem[2]))] else: terrstrialNames = sorted([x[0] for x in nimmanager.getTerrestrialsByCountrycode(self.terrestrialCountries.value)]) default = self.nimConfig.terrestrial.value in terrstrialNames and self.nimConfig.terrestrial.value or None self.terrestrialRegions = ConfigSelection(default = default, choices = terrstrialNames) def updateTerrestrialProvider(configEntry): self.nimConfig.terrestrial.value = configEntry.value self.nimConfig.terrestrial.save() self.terrestrialRegions.addNotifier(updateTerrestrialProvider) self.terrestrialRegionsEntry = getConfigListEntry(_("Region"), self.terrestrialRegions) self.list.append(self.terrestrialCountriesEntry) self.list.append(self.terrestrialRegionsEntry) self.list.append(getConfigListEntry(_("Enable 5V for active antenna"), self.nimConfig.terrestrial_5V)) elif self.nim.isCompatible("ATSC"): self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) if self.nimConfig.configMode.value == "enabled": self.list.append(getConfigListEntry(_("ATSC provider"), self.nimConfig.atsc)) self.have_advanced = False else: self.have_advanced = False self["config"].list = self.list self["config"].l.setList(self.list) self.setTextKeyYellow() def newConfig(self): self.setTextKeyBlue() if self["config"].getCurrent() == self.multiType: update_slots = [self.slotid] from Components.NimManager import InitNimManager InitNimManager(nimmanager, update_slots) self.nim = nimmanager.nim_slots[self.slotid] self.nimConfig = self.nim.config if self["config"].getCurrent() in (self.configMode, self.diseqcModeEntry, self.advancedSatsEntry, self.advancedLnbsEntry, self.advancedDiseqcMode, self.advancedUsalsEntry,\ self.advancedLof, self.advancedPowerMeasurement, self.turningSpeed, self.advancedType, self.advancedSCR, self.advancedPosition, self.advancedFormat, self.advancedManufacturer,\ self.advancedUnicable, self.advancedConnected, self.toneburst, self.committedDiseqcCommand, self.uncommittedDiseqcCommand, self.singleSatEntry, self.commandOrder,\ self.showAdditionalMotorOptions, self.cableScanType, self.multiType, self.cableConfigScanDetails, self.terrestrialCountriesEntry, self.cableCountriesEntry, \ self.toneamplitude, self.scpc, self.forcelnbpower, self.forcetoneburst): self.createSetup() def run(self): if self.nimConfig.configMode.value == "simple": autodiseqc_ports = 0 if self.nimConfig.diseqcMode.value == "single": if self.nimConfig.diseqcA.orbital_position == 3600: autodiseqc_ports = 1 elif self.nimConfig.diseqcMode.value == "diseqc_a_b": if self.nimConfig.diseqcA.orbital_position == 3600 or self.nimConfig.diseqcB.orbital_position == 3600: autodiseqc_ports = 2 elif self.nimConfig.diseqcMode.value == "diseqc_a_b_c_d": if self.nimConfig.diseqcA.orbital_position == 3600 or self.nimConfig.diseqcB.orbital_position == 3600 or self.nimConfig.diseqcC.orbital_position == 3600 or self.nimConfig.diseqcD.orbital_position == 3600: autodiseqc_ports = 4 if autodiseqc_ports: self.autoDiseqcRun(autodiseqc_ports) return False if self.have_advanced and self.nim.config_mode == "advanced": self.fillAdvancedList() for x in self.list: if x in (self.turnFastEpochBegin, self.turnFastEpochEnd): # workaround for storing only hour*3600+min*60 value in configfile # not really needed.. just for cosmetics.. tm = localtime(x[1].value) dt = datetime(1970, 1, 1, tm.tm_hour, tm.tm_min) x[1].value = int(mktime(dt.timetuple())) x[1].save() nimmanager.sec.update() self.saveAll() return True def autoDiseqcRun(self, ports): self.stopService() self.session.openWithCallback(self.autoDiseqcCallback, AutoDiseqc, self.slotid, ports, self.nimConfig.simpleDiSEqCSetVoltageTone, self.nimConfig.simpleDiSEqCOnlyOnSatChange) def autoDiseqcCallback(self, result): from Screens.Wizard import Wizard if Wizard.instance is not None: Wizard.instance.back() else: self.restartPrevService(close=False) self.createSetup() def fillListWithAdvancedSatEntrys(self, Sat): lnbnum = int(Sat.lnb.value) currLnb = self.nimConfig.advanced.lnb[lnbnum] if isinstance(currLnb, ConfigNothing): currLnb = None # LNBs self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb) self.list.append(self.advancedLnbsEntry) if currLnb: if self.nim.isFBCLink(): currLnb.lof.value = "unicable" self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) self.advancedLof = getConfigListEntry("LOF", currLnb.lof) self.list.append(self.advancedLof) if currLnb.lof.value == "user_defined": self.list.append(getConfigListEntry("LOF/L", currLnb.lofl)) self.list.append(getConfigListEntry("LOF/H", currLnb.lofh)) self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) if currLnb.lof.value == "unicable": self.advancedUnicable = getConfigListEntry("SCR (Unicable/JESS) "+_("type"), currLnb.unicable) self.list.append(self.advancedUnicable) if currLnb.unicable.value == "unicable_user": self.advancedFormat = getConfigListEntry(_("Format"), currLnb.format) self.advancedPosition = getConfigListEntry(_("Position"), currLnb.positionNumber) self.advancedSCR = getConfigListEntry(_("Channel"), currLnb.scrList) self.list.append(self.advancedFormat) self.list.append(self.advancedPosition) self.list.append(self.advancedSCR) self.list.append(getConfigListEntry(_("Frequency"), currLnb.scrfrequency)) self.list.append(getConfigListEntry("LOF/L", currLnb.lofl)) self.list.append(getConfigListEntry("LOF/H", currLnb.lofh)) self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) else: self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableManufacturer) self.advancedType = getConfigListEntry(_("Model"), currLnb.unicableProduct) self.advancedSCR = getConfigListEntry(_("Channel"), currLnb.scrList) self.advancedPosition = getConfigListEntry(_("Position"), currLnb.positionNumber) self.list.append(self.advancedManufacturer) self.list.append(self.advancedType) if currLnb.positions.value > 1: self.list.append(self.advancedPosition) self.list.append(self.advancedSCR) choices = [] connectable = nimmanager.canConnectTo(self.slotid) for id in connectable: choices.append((str(id), nimmanager.getNimDescription(id))) if len(choices): if self.nim.isFBCLink(): if self.nimConfig.advanced.unicableconnected.value != True: self.nimConfig.advanced.unicableconnected.value = True self.advancedConnected = getConfigListEntry(_("connected"), self.nimConfig.advanced.unicableconnected) self.list.append(self.advancedConnected) if self.nimConfig.advanced.unicableconnected.value == True: self.nimConfig.advanced.unicableconnectedTo.setChoices(choices) self.list.append(getConfigListEntry(_("Connected to"),self.nimConfig.advanced.unicableconnectedTo)) else: #kein Unicable self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage)) self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode)) if lnbnum < 65: self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode) self.list.append(self.advancedDiseqcMode) if currLnb.diseqcMode.value != "none": self.list.append(getConfigListEntry(_("Fast DiSEqC"), currLnb.fastDiseqc)) self.toneburst = getConfigListEntry(_("Toneburst"), currLnb.toneburst) self.list.append(self.toneburst) self.committedDiseqcCommand = getConfigListEntry(_("DiSEqC 1.0 command"), currLnb.commitedDiseqcCommand) self.list.append(self.committedDiseqcCommand) if currLnb.diseqcMode.value == "1_0": if currLnb.toneburst.index and currLnb.commitedDiseqcCommand.index: self.list.append(getConfigListEntry(_("Command order"), currLnb.commandOrder1_0)) else: self.uncommittedDiseqcCommand = getConfigListEntry(_("DiSEqC 1.1 command"), currLnb.uncommittedDiseqcCommand) self.list.append(self.uncommittedDiseqcCommand) if currLnb.uncommittedDiseqcCommand.index: if currLnb.commandOrder.value == "ct": currLnb.commandOrder.value = "cut" elif currLnb.commandOrder.value == "tc": currLnb.commandOrder.value = "tcu" else: if currLnb.commandOrder.index & 1: currLnb.commandOrder.value = "tc" else: currLnb.commandOrder.value = "ct" self.commandOrder = getConfigListEntry(_("Command order"), currLnb.commandOrder) if 1 < ((1 if currLnb.uncommittedDiseqcCommand.index else 0) + (1 if currLnb.commitedDiseqcCommand.index else 0) + (1 if currLnb.toneburst.index else 0)): self.list.append(self.commandOrder) if currLnb.uncommittedDiseqcCommand.index: self.list.append(getConfigListEntry(_("DiSEqC 1.1 repeats"), currLnb.diseqcRepeats)) self.list.append(getConfigListEntry(_("Sequence repeat"), currLnb.sequenceRepeat)) if currLnb.diseqcMode.value == "1_2": if SystemInfo["CanMeasureFrontendInputPower"]: self.advancedPowerMeasurement = getConfigListEntry(_("Use power measurement"), currLnb.powerMeasurement) self.list.append(self.advancedPowerMeasurement) if currLnb.powerMeasurement.value: self.list.append(getConfigListEntry(_("Power threshold in mA"), currLnb.powerThreshold)) self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), currLnb.turningSpeed) self.list.append(self.turningSpeed) if currLnb.turningSpeed.value == "fast epoch": self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), currLnb.fastTurningBegin) self.turnFastEpochEnd = getConfigListEntry(_("End time"), currLnb.fastTurningEnd) self.list.append(self.turnFastEpochBegin) self.list.append(self.turnFastEpochEnd) else: if currLnb.powerMeasurement.value: currLnb.powerMeasurement.value = False currLnb.powerMeasurement.save() self.advancedUsalsEntry = getConfigListEntry(_("Use USALS for this sat"), Sat.usals) if lnbnum < 65: self.list.append(self.advancedUsalsEntry) if Sat.usals.value: self.list.append(getConfigListEntry(_("Longitude"), currLnb.longitude)) self.list.append(getConfigListEntry(" ", currLnb.longitudeOrientation)) self.list.append(getConfigListEntry(_("Latitude"), currLnb.latitude)) self.list.append(getConfigListEntry(" ", currLnb.latitudeOrientation)) else: self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition)) if not hasattr(self, 'additionalMotorOptions'): self.additionalMotorOptions = NoSave(ConfigYesNo(False)) self.showAdditionalMotorOptions = getConfigListEntry(_("Extra motor options"), self.additionalMotorOptions) self.list.append(self.showAdditionalMotorOptions) if self.additionalMotorOptions.value: self.list.append(getConfigListEntry(" " + _("Horizontal turning speed") + " [" + chr(176) + "/sec]", currLnb.turningspeedH)) self.list.append(getConfigListEntry(" " + _("Vertical turning speed") + " [" + chr(176) + "/sec]", currLnb.turningspeedV)) self.list.append(getConfigListEntry(" " + _("Turning step size") + " [" + chr(176) + "]", currLnb.tuningstepsize)) self.list.append(getConfigListEntry(" " + _("Max memory positions"), currLnb.rotorPositions)) def fillAdvancedList(self): self.list = [ ] self.configMode = getConfigListEntry(_("Configuration mode"), self.nimConfig.configMode) self.list.append(self.configMode) self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats) self.list.append(self.advancedSatsEntry) for x in self.nimConfig.advanced.sat.keys(): Sat = self.nimConfig.advanced.sat[x] self.fillListWithAdvancedSatEntrys(Sat) self["config"].list = self.list def keyOk(self): if self.isChanged(): self.stopService() if self["config"].getCurrent() == self.advancedSelectSatsEntry: conf = self.nimConfig.advanced.sat[int(self.nimConfig.advanced.sats.value)].userSatellitesList self.session.openWithCallback(boundFunction(self.updateConfUserSatellitesList, conf), SelectSatsEntryScreen, userSatlist=conf.value) elif self["config"].getCurrent() == self.selectSatsEntry: conf = self.nimConfig.userSatellitesList self.session.openWithCallback(boundFunction(self.updateConfUserSatellitesList, conf), SelectSatsEntryScreen, userSatlist=conf.value) else: self.keySave() def updateConfUserSatellitesList(self, conf, val=None): if val is not None: conf.value = val conf.save() def keySave(self): if self.isChanged(): self.stopService() old_configured_sats = nimmanager.getConfiguredSats() if not self.run(): return new_configured_sats = nimmanager.getConfiguredSats() self.unconfed_sats = old_configured_sats - new_configured_sats self.satpos_to_remove = None self.deleteConfirmed((None, "no")) def deleteConfirmed(self, confirmed): if confirmed is None: confirmed = (None, "no") if confirmed[1] == "yes" or confirmed[1] == "yestoall": eDVBDB.getInstance().removeServices(-1, -1, -1, self.satpos_to_remove) if self.satpos_to_remove is not None: self.unconfed_sats.remove(self.satpos_to_remove) self.satpos_to_remove = None for orbpos in self.unconfed_sats: self.satpos_to_remove = orbpos orbpos = self.satpos_to_remove try: # why we need this cast? sat_name = str(nimmanager.getSatDescription(orbpos)) except: if orbpos > 1800: # west orbpos = 3600 - orbpos h = _("W") else: h = _("E") sat_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10) if confirmed[1] == "yes" or confirmed[1] == "no": # TRANSLATORS: The satellite with name '%s' is no longer used after a configuration change. The user is asked whether or not the satellite should be deleted. self.session.openWithCallback(self.deleteConfirmed, ChoiceBox, _("%s is no longer used. Should it be deleted?") % sat_name, [(_("Yes"), "yes"), (_("No"), "no"), (_("Yes to all"), "yestoall"), (_("No to all"), "notoall")], None, 1) if confirmed[1] == "yestoall" or confirmed[1] == "notoall": self.deleteConfirmed(confirmed) break else: self.restartPrevService() def __init__(self, session, slotid): Screen.__init__(self, session) self.list = [ ] ServiceStopScreen.__init__(self) ConfigListScreen.__init__(self, self.list) self["key_red"] = Label(_("Cancel")) self["key_green"] = Label(_("Save")) self["key_yellow"] = Label() self["key_blue"] = Label() self["actions"] = ActionMap(["SetupActions", "SatlistShortcutAction"], { "ok": self.keyOk, "save": self.keySave, "cancel": self.keyCancel, "changetype": self.changeConfigurationMode, "nothingconnected": self.nothingConnectedShortcut }, -2) self.slotid = slotid self.nim = nimmanager.nim_slots[slotid] self.nimConfig = self.nim.config self.createConfigMode() self.createSetup() self.setTitle(_("Setup") + " " + self.nim.friendly_full_description) def keyLeft(self): if self.nim.isFBCLink() and self["config"].getCurrent() in (self.advancedLof, self.advancedConnected): return ConfigListScreen.keyLeft(self) if self["config"].getCurrent() in (self.advancedSelectSatsEntry, self.selectSatsEntry): self.keyOk() else: self.newConfig() def setTextKeyYellow(self): self["key_yellow"].setText(self.nimConfig.configMode.value == "simple" and _("Auto Diseqc") or _("Configuration mode")) def setTextKeyBlue(self): self["key_blue"].setText(self.isChanged() and _("Set default") or "") def keyRight(self): if self.nim.isFBCLink() and self["config"].getCurrent() in (self.advancedLof, self.advancedConnected): return ConfigListScreen.keyRight(self) if self["config"].getCurrent() in (self.advancedSelectSatsEntry, self.selectSatsEntry): self.keyOk() else: self.newConfig() def handleKeyFileCallback(self, answer): ConfigListScreen.handleKeyFileCallback(self, answer) self.newConfig() def keyCancel(self): if self.isChanged(): self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?")) else: self.restartPrevService() def isChanged(self): is_changed = False for x in self["config"].list: if x == self.showAdditionalMotorOptions: continue is_changed |= x[1].isChanged() return is_changed def saveAll(self): if self.nim.isCompatible("DVB-S"): # reset connectedTo to all choices to properly store the default value choices = [] nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid) for id in nimlist: choices.append((str(id), nimmanager.getNimDescription(id))) self.nimConfig.connectedTo.setChoices(choices) # sanity check for empty sat list if self.nimConfig.configMode.value != "satposdepends" and len(nimmanager.getSatListForNim(self.slotid)) < 1: self.nimConfig.configMode.value = "nothing" if self.nim.isFBCRoot(): if SystemInfo["HasForceLNBOn"]: config.misc.forceLnbPower.save() if SystemInfo["HasForceToneburst"]: config.misc.forceToneBurst.save() if self.isChanged(): for x in self["config"].list: x[1].save() configfile.save() def cancelConfirm(self, result): if not result: return for x in self["config"].list: x[1].cancel() if hasattr(self, "originalTerrestrialRegion"): self.nimConfig.terrestrial.value = self.originalTerrestrialRegion self.nimConfig.terrestrial.save() if hasattr(self, "originalCableRegion"): self.nimConfig.cable.scan_provider.value = self.originalCableRegion self.nimConfig.cable.scan_provider.save() # we need to call saveAll to reset the connectedTo choices self.saveAll() self.restartPrevService() def changeConfigurationMode(self): if self.nimConfig.configMode.value == "simple": self.autoDiseqcRun(self.nimConfig.diseqcMode.value == "diseqc_a_b_c_d" and 4 or self.nimConfig.diseqcMode.value == "diseqc_a_b" and 2 or 1) elif self.configMode: self.nimConfig.configMode.selectNext() self["config"].invalidate(self.configMode) self.setTextKeyBlue() self.createSetup() def nothingConnectedShortcut(self): if self.isChanged(): for x in self["config"].list: x[1].cancel() self.setTextKeyBlue() self.createSetup() def countrycodeToCountry(self, cc): if not hasattr(self, 'countrycodes'): self.countrycodes = {} from Tools.CountryCodes import ISO3166 for country in ISO3166: self.countrycodes[country[2]] = country[0] if cc.upper() in self.countrycodes: return self.countrycodes[cc.upper()] return cc
class SetupFallbacktuner(ConfigListScreen, Screen): def __init__(self, session): Screen.__init__(self, session) Screen.setTitle(self, _("Fallback tuner setup")) self.skinName = ["FallbackTunerSetup", "Setup"] self.onChangedEntry = [] self.session = session ConfigListScreen.__init__(self, [], session = session, on_change = self.changedEntry) self["actions2"] = ActionMap(["SetupActions"], { "ok": self.run, "menu": self.keyCancel, "cancel": self.keyCancel, "save": self.run, }, -2) self["key_red"] = StaticText(_("Exit")) self["key_green"] = StaticText(_("Save")) self["description"] = Label("") self["VKeyIcon"] = Boolean(False) self["HelpWindow"] = Pixmap() self["HelpWindow"].hide() self.force_update_list = False self.createConfig() self.createSetup() self.remote_fallback_prev = config.usage.remote_fallback_import.value self["config"].onSelectionChanged.append(self.selectionChanged) self.selectionChanged() def createConfig(self): def set_avahiselect_seperate(configElement): if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value != config.usage.remote_fallback.value: peerDefault_sepearate = config.usage.remote_fallback_import_url.value else: peerDefault_sepearate = "same" config.usage.remote_fallback_import_url.value = config.usage.remote_fallback.value self.seperateBoxes = [("same", _("Same as stream"))] + self.peerStreamingBoxes if configElement.value not in ("url", "ip") and configElement.value in self.seperateBoxes: self.seperateBoxes.remove(configElement.value) self.avahiselect_seperate = ConfigSelection(default=peerDefault_sepearate, choices=self.seperateBoxes) self.peerStreamingBoxes = getPeerStreamingBoxes() + [("ip", _("Enter IP address")), ("url", _("Enter URL"))] peerDefault = peerDefault_sepearate = None if config.usage.remote_fallback.value: peerDefault = peerDefault_sepearate = config.usage.remote_fallback.value if config.usage.remote_fallback.value and config.usage.remote_fallback.value not in self.peerStreamingBoxes: self.peerStreamingBoxes = [config.usage.remote_fallback.value] + self.peerStreamingBoxes if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value not in self.peerStreamingBoxes: self.peerStreamingBoxes = [config.usage.remote_fallback_import_url.value] + self.peerStreamingBoxes self.avahiselect = ConfigSelection(default=peerDefault, choices=self.peerStreamingBoxes) self.avahiselect.addNotifier(set_avahiselect_seperate) try: ipDefault = [int(x) for x in config.usage.remote_fallback.value.split(":")[1][2:].split(".")] portDefault = int( config.usage.remote_fallback.value.split(":")[2]) except: ipDefault = [0, 0, 0, 0] portDefault = 8001 self.ip = ConfigIP(default=ipDefault, auto_jump=True) self.port = ConfigInteger(default=portDefault, limits=(1,65535)) self.ip_seperate = ConfigIP( default=ipDefault, auto_jump=True) self.port_seperate = ConfigInteger(default=portDefault, limits=(1,65535)) def createSetup(self): self.list = [] self.list.append(getConfigListEntry(_("Enable fallback remote receiver"), config.usage.remote_fallback_enabled, _("Enable remote enigma2 receiver to be tried to tune into services that cannot be tuned into locally (e.g. tuner is occupied or service type is unavailable on the local tuner. Specify complete URL including http:// and port number (normally ...:8001), e.g. http://second_box:8001."))) self.list.append(getConfigListEntry(_("Import from remote receiver URL"), config.usage.remote_fallback_import, _("Import channels and/or EPG from remote receiver URL when receiver is booted"))) if config.usage.remote_fallback_enabled.value or config.usage.remote_fallback_import.value: self.list.append(getConfigListEntry(_("Enable import timer from fallback tuner"), config.usage.remote_fallback_external_timer, _("When enabled the timer from the fallback tuner is imported"))) self.list.append(getConfigListEntry(_("Fallback remote receiver"), self.avahiselect, _("Destination of fallback remote receiver"))) if self.avahiselect.value == "ip": self.list.append(getConfigListEntry(_("Fallback remote receiver IP"), self.ip, _("IP of fallback remote receiver"))) self.list.append(getConfigListEntry(_("Fallback remote receiver Port"), self.port, _("Port of fallback remote receiver"))) if self.avahiselect.value == "url": self.list.append(getConfigListEntry(_("Fallback remote receiver URL"), config.usage.remote_fallback, _("URL of fallback remote receiver"))) if config.usage.remote_fallback_enabled.value and config.usage.remote_fallback_import.value and config.usage.remote_fallback.value: self.list.append(getConfigListEntry(_("Import remote receiver URL"), self.avahiselect_seperate, _("URL of fallback remote receiver"))) if self.avahiselect_seperate.value == "ip": self.list.append(getConfigListEntry(_("Fallback remote receiver IP"), self.ip_seperate, _("IP of fallback remote receiver"))) self.list.append(getConfigListEntry(_("Fallback remote receiver Port"), self.port_seperate, _("Port of fallback remote receiver"))) if self.avahiselect_seperate.value == "url": self.list.append(getConfigListEntry(_("Fallback remote receiver URL"), config.usage.remote_fallback_import_url, _("URL of fallback remote receiver"))) if config.usage.remote_fallback_enabled.value and config.usage.remote_fallback_import.value: self.list.append(getConfigListEntry(_("Also import at reboot/restart enigma2"), config.usage.remote_fallback_import_restart, _("Import channels and/or EPG from remote receiver URL when receiver or enigma2 is restarted"))) self.list.append(getConfigListEntry(_("Also import when box is leaving standby"), config.usage.remote_fallback_import_standby, _("Import channels and/or EPG from remote receiver URL also when the receiver is getting out of standby"))) self.list.append(getConfigListEntry(_("Also import from the extension menu"), config.usage.remote_fallback_extension_menu, _("Make it possible to manually initiate the channels import and/or EPG via the extension menu"))) self.list.append(getConfigListEntry(_("Show notification when import channels was successful"), config.usage.remote_fallback_ok, _("Show notification when import channels and/or EPG from remote receiver URL is completed"))) self.list.append(getConfigListEntry(_("Show notification when import channels was not successful"), config.usage.remote_fallback_nok, _("Show notification when import channels and/or EPG from remote receiver URL did not complete"))) self.list.append(getConfigListEntry(_("Customize OpenWebIF settings for fallback tuner"), config.usage.remote_fallback_openwebif_customize, _("When enabled you can customize the OpenWebIf settings for the fallback tuner"))) if config.usage.remote_fallback_openwebif_customize.value: self.list.append(getConfigListEntry(_("User ID"), config.usage.remote_fallback_openwebif_userid, _("Set the User ID of the OpenWebif from your fallback tuner"))) self.list.append(getConfigListEntry(_("Password"), config.usage.remote_fallback_openwebif_password, _("Set the password of the OpenWebif from your fallback tuner"))) self.list.append(getConfigListEntry(_("Port"), config.usage.remote_fallback_openwebif_port, _("Set the port of the OpenWebif from your fallback tuner"))) self["config"].list = self.list self["config"].l.setList(self.list) def selectionChanged(self): if self.force_update_list: self["config"].onSelectionChanged.remove(self.selectionChanged) self.createSetup() self["config"].onSelectionChanged.append(self.selectionChanged) self.force_update_list = False if not (isinstance(self["config"].getCurrent()[1], ConfigBoolean) or isinstance(self["config"].getCurrent()[1], ConfigSelection)): self.force_update_list = True self["description"].setText(self.getCurrentDescription()) def changedEntry(self): if isinstance(self["config"].getCurrent()[1], ConfigBoolean) or isinstance(self["config"].getCurrent()[1], ConfigSelection): self.createSetup() def run(self): if self.avahiselect.value == "ip": config.usage.remote_fallback.value = "http://%d.%d.%d.%d:%d" % (tuple(self.ip.value) + (self.port.value,)) elif self.avahiselect.value != "url": config.usage.remote_fallback.value = self.avahiselect.value if self.avahiselect_seperate.value == "ip": config.usage.remote_fallback_import_url.value = "http://%d.%d.%d.%d:%d" % (tuple(self.ip_seperate.value) + (self.port_seperate.value,)) elif self.avahiselect_seperate.value == "same": config.usage.remote_fallback_import_url.value = "" elif self.avahiselect_seperate.value != "url": config.usage.remote_fallback_import_url.value = self.avahiselect_seperate.value if config.usage.remote_fallback_import_url.value == config.usage.remote_fallback.value: config.usage.remote_fallback_import_url.value = "" config.usage.remote_fallback_enabled.save() config.usage.remote_fallback_import.save() config.usage.remote_fallback_import_url.save() config.usage.remote_fallback_import_restart.save() config.usage.remote_fallback_import_standby.save() config.usage.remote_fallback_extension_menu.save() config.usage.remote_fallback_ok.save() config.usage.remote_fallback_nok.save() config.usage.remote_fallback.save() config.usage.remote_fallback_external_timer.save() config.usage.remote_fallback_openwebif_customize.save() config.usage.remote_fallback_openwebif_userid.save() config.usage.remote_fallback_openwebif_password.save() config.usage.remote_fallback_openwebif_port.save() configfile.save() if not self.remote_fallback_prev and config.usage.remote_fallback_import.value: ImportChannels() self.close(False)
class ConfigUI(ConfigListScreen, Screen): skin = """ <screen name="ConfigUI" position="center,center" size="560,400" title="AutoBackup Configuration" > <ePixmap name="red" position="0,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/red.png" transparent="1" alphatest="on" /> <ePixmap name="green" position="140,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/green.png" transparent="1" alphatest="on" /> <ePixmap name="blue" position="420,0" zPosition="2" size="140,40" pixmap="skin_default/buttons/blue.png" transparent="1" alphatest="on" /> <widget name="key_red" position="0,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_green" position="140,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="key_blue" position="420,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" font="Regular;20" transparent="1" shadowColor="background" shadowOffset="-2,-2" /> <widget name="config" position="10,40" size="540,200" scrollbarMode="showOnDemand" /> <widget name="status" position="10,250" size="540,130" font="Regular;16" /> <ePixmap alphatest="on" pixmap="skin_default/icons/clock.png" position="480,383" size="14,14" zPosition="3"/> <widget font="Regular;18" halign="left" position="505,380" render="Label" size="55,20" source="global.CurrentTime" transparent="1" valign="center" zPosition="3"> <convert type="ClockToText">Default</convert> </widget> <widget name="statusbar" position="10,380" size="470,20" font="Regular;18" /> </screen>""" def __init__(self, session, args=0): self.session = session self.setup_title = _("AutoBackup Configuration") config.plugins.configurationbackup = ConfigSubsection() config.plugins.configurationbackup.enabled = ConfigEnableDisable( default=False) config.plugins.configurationbackup.maxbackup = ConfigInteger( default=99, limits=(0, 99)) config.plugins.configurationbackup.backuplocation = ConfigText( default='/media/hdd/', visible_width=50, fixed_size=False) config.plugins.configurationbackup.wakeup = ConfigClock( default=((3 * 60) + 0) * 60) # 3:00 config.plugins.configurationbackup.backupdirs = ConfigLocations( default=[ eEnv.resolve( '${sysconfdir}/enigma2/'), '/etc/network/interfaces', '/etc/wpa_supplicant.conf', '/etc/wpa_supplicant.ath0.conf', '/etc/wpa_supplicant.wlan0.conf', '/etc/resolv.conf', '/etc/default_gw', '/etc/hostname' ]) Screen.__init__(self, session) cfg = config.plugins.configurationbackup choices = getLocationChoices() self.setTitle(_("AutoBackup Configuration")) if choices: currentwhere = cfg.backuplocation.value defaultchoice = choices[0][0] for k, v in choices: if k == currentwhere: defaultchoice = k break else: defaultchoice = "" choices = [("", _("Nowhere"))] self.cfgwhere = ConfigSelection(default=defaultchoice, choices=choices) configList = [ getConfigListEntry(_("Backup location"), self.cfgwhere), getConfigListEntry(_("Daily automatic backup"), config.plugins.configurationbackup.enabled), getConfigListEntry(_("Automatic start time"), config.plugins.configurationbackup.wakeup), getConfigListEntry(_("Max. saved backup"), config.plugins.configurationbackup.maxbackup), ] ConfigListScreen.__init__(self, configList, session=session, on_change=self.changedEntry) self["key_red"] = Button(_("Cancel")) self["key_green"] = Button(_("Ok")) self["key_blue"] = Button("") self["statusbar"] = Label() self["status"] = Label() self["setupActions"] = ActionMap( ["SetupActions", "ColorActions", "MenuActions"], { "red": self.cancel, "green": self.save, "blue": self.disable, "save": self.save, "cancel": self.cancel, "ok": self.save, }, -2) self.onChangedEntry = [] self.data = '' self.container = enigma.eConsoleAppContainer() self.container.appClosed.append(self.appClosed) self.container.dataAvail.append(self.dataAvail) self.cfgwhere.addNotifier(self.changedWhere) self.onClose.append(self.__onClose) # 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 def changedWhere(self, cfg): self.isActive = False if not cfg.value: self["status"].setText( _("No suitable media found, insert USB stick, flash card or harddisk." )) self.isActive = False else: config.plugins.configurationbackup.backuplocation.value = cfg.value path = os.path.join(cfg.value, 'backup') if not os.path.exists(path): self["status"].setText(_("No backup present")) else: self.isActive = True if self.isActive: self["key_blue"].setText(_("Disable")) else: self["key_blue"].setText("") def disable(self): cfg = self.cfgwhere if not cfg.value: return self.changedWhere(cfg) def __onClose(self): self.cfgwhere.notifiers.remove(self.changedWhere) def save(self): config.plugins.configurationbackup.backuplocation.value = self.cfgwhere.value config.plugins.configurationbackup.backuplocation.save() self.saveAll() self.close(True, self.session) def cancel(self): for x in self["config"].list: x[1].cancel() self.close(False, self.session) def showOutput(self): self["status"].setText(self.data) def appClosed(self, retval): print("[AutoBackup] done:", retval) if retval: txt = _("Failed") else: txt = _("Done") self.showOutput() self.data = '' self["statusbar"].setText(txt) self.changedWhere(self.cfgwhere) def dataAvail(self, s): self.data += s print("[AutoBackup]", s.strip()) self.showOutput()
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) 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', 'cifs')) 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.value) ) + '/' in locations or Components.Harddisk.findMountPoint( os.path.realpath(configele.value)) in locations: if fileExists(configele.value, 'w'): configele.last_value = configele.value return True else: dir = configele.value 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.value configele.value = configele.last_value self.session.open( MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.' ) % dir, type=MessageBox.TYPE_ERROR) return False else: dir = configele.value configele.value = configele.last_value self.session.open( MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.' ) % dir, type=MessageBox.TYPE_ERROR) return False def createSetup(self): default = config.usage.timeshift_path.value cooldefault = config.usage.autorecord_path.value tmp = config.usage.allowed_timeshift_paths.value cooltmp = config.usage.allowed_autorecord_paths.value if default not in tmp: tmp = tmp[:] tmp.append(default) if cooldefault not in cooltmp: cooltmp = cooltmp[:] cooltmp.append(cooldefault) 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.value: self['config'].list.sort() def layoutFinished(self): self.setTitle(_(self.setup_title)) def ok(self): currentry = self['config'].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value self.lastautorecorddirs = config.usage.allowed_autorecord_paths.value if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value self.session.openWithCallback(self.dirnameSelected, TimeshiftLocationBox) if currentry == self.autorecord_entry: self.entrydirname = self.autorecord_dirname config.usage.autorecord_path.value = self.autorecord_dirname.value 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', 'cifs')) 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.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.timeshift_dirname.value 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.value != self.lastautorecorddirs: tmp = config.usage.allowed_autorecord_paths.value default = self.autorecord_dirname.value 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, NFS or CIFS 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, NFS or CIFS 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() def keySave(self): import os.path import Components.Harddisk supported_filesystems = frozenset( ('ext4', 'ext3', 'ext2', 'nfs', 'cifs')) 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.value) ) + '/' in locations or Components.Harddisk.findMountPoint( os.path.realpath( config.usage.timeshift_path.value)) in locations: config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.timeshift_path.save() self.saveAll() self.close() elif int(config.timeshift.startdelay.value) > 0: self.session.open( MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.' ) % config.usage.timeshift_path.value, type=MessageBox.TYPE_ERROR) else: config.timeshift.startdelay.setValue(0) self.saveAll() self.close() elif int(config.timeshift.startdelay.value) > 0: self.session.open( MessageBox, _('The directory %s is not a EXT2, EXT3, EXT4, NFS or CIFS partition.\nMake sure you select a valid partition type.' ) % config.usage.timeshift_path.value, 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 self.levelChanged not 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.value and not item.value == '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 item = b if not isinstance(item, ConfigNothing): list.append((item_text, item, item_description))
class RecordPathsSettings(Screen, ConfigListScreen): skin = """ <screen name="RecordPathsSettings" position="160,150" size="450,200" title="Recording paths"> <ePixmap pixmap="buttons/red.png" position="10,0" size="140,40" alphatest="on" /> <ePixmap pixmap="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["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) ConfigListScreen.__init__(self, []) self.initConfigList() self["setupActions"] = ActionMap( ["SetupActions", "ColorActions"], { "green": self.save, "red": self.cancel, "cancel": self.cancel, "ok": self.ok, }, -2) def checkReadWriteDir(self, configele): value = configele.value print "checkReadWrite: ", configele.value if not value or value in [x[0] for x in self.styles] or fileExists( value, "w"): configele.last_value = value return True else: configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead." ) % value, type=MessageBox.TYPE_ERROR) return False def initConfigList(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.value default = config.usage.default_path.value if default and default not in tmp: tmp = tmp[:] tmp.append(default) print "DefaultPath: ", default, tmp self.default_dirname = ConfigSelection( default=default, choices=[("", _("<Default movie location>"))] + tmp) tmp = config.movielist.videodirs.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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) default = config.usage.timeshift_path.value tmp = config.usage.allowed_timeshift_paths.value if default not in tmp: tmp = tmp[:] tmp.append(default) print "TimeshiftPath: ", default, tmp self.timeshift_dirname = ConfigSelection(default=default, choices=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.timeshift_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) self.list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer record location"), self.timer_dirname) self.list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry( _("Instant record location"), self.instantrec_dirname) self.list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname) self.list.append(self.default_entry) self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname) self.list.append(self.timeshift_entry) self["config"].setList(self.list) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value 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.value)) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Initial location in new timers"), preferredPath(self.timer_dirname.value)) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Location for instant recordings"), preferredPath(self.instantrec_dirname.value)) elif currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value self.session.openWithCallback(self.dirnameSelected, TimeshiftLocationBox) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default and default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices( [("", _("<Default movie location>"))] + tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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 config.usage.allowed_timeshift_paths.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.instantrec_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if self.entrydirname.last_value != res: self.checkReadWriteDir(self.entrydirname) def save(self): currentry = self["config"].getCurrent() if self.checkReadWriteDir(currentry[1]): config.usage.default_path.value = self.default_dirname.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.default_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() config.usage.timeshift_path.save() self.close() def cancel(self): 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 __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.value if configele.value in [x[0] for x in self.styles] or fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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.value default = config.usage.default_path.value 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.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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, _("Itmes in trashcan will be deleted if less then the set space is available."))) if config.usage.setup_level.index >= 2: self.list.append(getConfigListEntry(_("Recording data sync size"), config.misc.flush_size, _("Only change for debugging; default is 'Off'."))) 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.value: 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.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value 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.value) ) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("New timers location"), preferredPath(self.timer_dirname.value) ) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Instant recordings location"), preferredPath(self.instantrec_dirname.value) ) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value 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 RecordPathsSettings(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["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("Save")) self.setTitle(_("Recording paths")) ConfigListScreen.__init__(self, []) config.movielist.videodirs.load() self.initConfigList() self["setupActions"] = ActionMap(["SetupActions", "ColorActions", "MenuActions"], { "green": self.save, "red": self.keyCancel, "cancel": self.keyCancel, "ok": self.ok, "menu": self.closeRecursive, }, -2) def checkReadWriteDir(self, configele): value = configele.value print "checkReadWrite: ", value if not value or value in [x[0] for x in self.styles] or fileExists(value, "w"): configele.last_value = value return True else: configele.value = configele.last_value self.session.open( MessageBox, _("The directory %s is not writable.\nMake sure you select a writable directory instead.") % value, type = MessageBox.TYPE_ERROR ) return False def initConfigList(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.value default = config.usage.default_path.value if default and default not in tmp: tmp = tmp[:] tmp.append(default) print "DefaultPath: ", default, tmp self.default_dirname = ConfigSelection(default = default, choices = [("", _("<Default movie location>"))] + tmp) tmp = config.movielist.videodirs.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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) default = config.usage.timeshift_path.value tmp = config.usage.allowed_timeshift_paths.value if default not in tmp: tmp = tmp[:] tmp.append(default) print "TimeshiftPath: ", default, tmp self.timeshift_dirname = ConfigSelection(default = default, choices = 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.timeshift_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) self.list.append(self.default_entry) self.timer_entry = getConfigListEntry(_("Timer recording location"), self.timer_dirname) self.list.append(self.timer_entry) self.instantrec_entry = getConfigListEntry(_("Instant recording location"), self.instantrec_dirname) self.list.append(self.instantrec_entry) else: self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname) self.list.append(self.default_entry) self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname) self.list.append(self.timeshift_entry) self["config"].setList(self.list) def ok(self): currentry = self["config"].getCurrent() self.lastvideodirs = config.movielist.videodirs.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value 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.value) ) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Initial location in new timers"), preferredPath(self.timer_dirname.value) ) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Location for instant recordings"), preferredPath(self.instantrec_dirname.value) ) elif currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value self.session.openWithCallback( self.dirnameSelected, TimeshiftLocationBox ) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default and default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices([("", _("<Default movie location>"))] + tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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 config.usage.allowed_timeshift_paths.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.instantrec_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.timeshift_dirname.setChoices(tmp, default=default) self.entrydirname.value = res if self.entrydirname.last_value != res: self.checkReadWriteDir(self.entrydirname) def save(self): currentry = self["config"].getCurrent() if self.checkReadWriteDir(currentry[1]): config.usage.default_path.value = self.default_dirname.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value config.usage.timeshift_path.value = self.timeshift_dirname.value config.usage.default_path.save() config.usage.timer_path.save() config.usage.instantrec_path.save() config.usage.timeshift_path.save() self.close()
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 = _("Timshift 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"): 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.value))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(configele.value)) in locations: if fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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.value 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.value 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.value tmp = config.usage.allowed_timeshift_paths.value 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(_("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.value: 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. Thois 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.value: 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.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value if currentry == self.timeshift_entry: self.entrydirname = self.timeshift_dirname config.usage.timeshift_path.value = self.timeshift_dirname.value 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.value != self.lasttimeshiftdirs: tmp = config.usage.allowed_timeshift_paths.value default = self.timeshift_dirname.value 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.value))+'/' in locations or Components.Harddisk.findMountPoint(os.path.realpath(config.usage.timeshift_path.value)) in locations: config.usage.timeshift_path.value = self.timeshift_dirname.value 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.value, 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.value, 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 OSD3DSetupScreen(Screen, ConfigListScreen): #class for configure 3D default settings 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["help"] = StaticText() self["actions"] = ActionMap(["SetupActions", "ColorActions"], { "ok": self.keyGo, "save": self.keyGo, "cancel": self.keyCancel, "green": self.keyGo, "red": self.keyCancel, "0": self.keyZero, }, -2) # preparing setting items mode = config.plugins.OSD3DSetup.mode.value znorm = config.plugins.OSD3DSetup.znorm.value menuext = config.plugins.OSD3DSetup.menuext.value auto = config.plugins.OSD3DSetup.auto.value toggle = config.plugins.OSD3DSetup.toggle.value prompt = config.plugins.OSD3DSetup.prompt.value self.mode = ConfigSelection(choices=modelist, default=nz(mode, val_auto)) self.znorm = ConfigSlider(default=znorm + 50, increment=1, limits=(0, 100)) self.menuext = ConfigSelection(choices=menulist, default=nz(menuext, "none")) self.auto = ConfigYesNo(default=nz(auto, False)) self.toggle = ConfigSelection(choices=togglelist, default=nz(toggle, val_sidebyside)) self.prompt = ConfigInteger(nz(prompt, 10), limits=(0, 30)) # adding notifiers to immediatelly preview changed 3D settings self.mode.addNotifier(self.setPreviewSettings, initial_call=False) self.znorm.addNotifier(self.setPreviewSettings, initial_call=False) self.refresh() self.initHelpTexts() ConfigListScreen.__init__(self, self.list, session=self.session) self["config"].onSelectionChanged.append(self.updateHelp) def keyLeft(self): ConfigListScreen.keyLeft(self) self.reloadList() def keyRight(self): ConfigListScreen.keyRight(self) self.reloadList() def keyZero(self): cur = self["config"].getCurrent() if cur == getConfigListEntry(_("Depth"), self.znorm): self.znorm.value = 50 self.reloadList() else: ConfigListScreen.keyNumberGlobal(self, 0) def reloadList(self): self.refresh() self["config"].setList(self.list) def refresh(self): list = [] list.extend(( getConfigListEntry(_("3d mode"), self.mode), getConfigListEntry(_("Depth"), self.znorm), getConfigListEntry(_("Show in menu"), self.menuext), getConfigListEntry(_("Turn on automatically"), self.auto) )) # Only allow editing toggle mode when the 3d switch command is supposed to apear in menu or 3d should be turned on automatically if self.menuext.value != "none" or self.auto.value: list.append(getConfigListEntry(_("Toggle mode"), self.toggle)) # Only allow editing user prompt when the 3d auto toggle is activated if self.auto.value: list.append(getConfigListEntry(_("Display 3D confirmation"), self.prompt)) self.list = list def initHelpTexts(self): self.helpDict = { self.mode: _("Choose 3D mode (Side by Side, Top And Bottom, Auto, Off)."), self.znorm: _("Set the depth of 3D effect. Press [0] for standard value."), self.menuext: _("Should quick toggle command be present in menu / extensions list?"), self.auto: _("Should the plugin turn on 3D mode automatically judging on the playing media title (3D in service or file name)?"), self.toggle: _("Define the mode to turn on 3D automatically or by quick toggle menu command [Side By Side] or [Top And Bottom]."), self.prompt: _("How long should 3D mode on confirmation be displayed (seconds). 0 for none."), } def updateHelp(self): cur = self["config"].getCurrent() if cur: self["help"].text = self.helpDict.get(cur[1], "") #channging mode or znorm is immediatelly previewed def setPreviewSettings(self, value): applySettings(self.mode.value, int(self.znorm.value) - 50) #setting are stored in enigma configuration file def keyGo(self): config.plugins.OSD3DSetup.mode.value = self.mode.value config.plugins.OSD3DSetup.znorm.value = int(self.znorm.value) - 50 config.plugins.OSD3DSetup.menuext.value = self.menuext.value config.plugins.OSD3DSetup.auto.value = self.auto.value config.plugins.OSD3DSetup.toggle.value = self.toggle.value config.plugins.OSD3DSetup.prompt.value = self.prompt.value config.plugins.OSD3DSetup.save() #refresh menus to reflect current settings plugins.readPluginList(resolveFilename(SCOPE_PLUGINS)) self.close() #roll-back changes - read settings from configuration def keyCancel(self): setConfiguredSettings() self.close()
class SimpleSatScan(ConfigListScreen, Screen): skin = """ <screen position="center,center" size="520,480" title="Simple Satellite Scan"> <!-- little tune status --> <eLabel name="pos" text="Current position:" position="10,10" size="210,20" font="Regular;19" halign="right" transparent="1" /> <widget name="status" position="230,10" size="260,20" font="Console;19" valign="center" foregroundColor="#f8f711" transparent="1" /> <!-- dB --> <!--widget source="Frontend" render="Label" position="190,10" zPosition="2" size="260,20" font="Regular;19" foregroundColor="#02f408" halign="center" valign="center" transparent="1"--> <widget source="Frontend" render="Label" position="190,35" zPosition="2" size="260,20" font="Regular;19" halign="center" valign="center" transparent="1"> <convert type="FrontendInfo">SNRdB</convert> </widget> <!-- SNR --> <eLabel name="snr" text="SNR:" position="120,35" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Progress" position="190,35" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc"> <convert type="FrontendInfo">SNR</convert> </widget> <widget source="Frontend" render="Label" position="460,35" size="60,22" font="Regular;21"> <convert type="FrontendInfo">SNR</convert> </widget> <!-- Lock --> <eLabel name="lock" text="LOCK:" position="10,35" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_on.png" position="80,32" zPosition="1" size="38,31" alphatest="on"> <convert type="FrontendInfo">LOCK</convert> <convert type="ConditionalShowHide" /> </widget> <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_off.png" position="80,32" zPosition="1" size="38,31" alphatest="on"> <convert type="FrontendInfo">LOCK</convert> <convert type="ConditionalShowHide">Invert</convert> </widget> <!-- AGC --> <eLabel name="agc" text="AGC:" position="120,60" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Progress" position="190,60" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc"> <convert type="FrontendInfo">AGC</convert> </widget> <widget source="Frontend" render="Label" position="460,60" size="60,22" font="Regular;21"> <convert type="FrontendInfo">AGC</convert> </widget> <!-- BER --> <eLabel name="ber" text="BER:" position="120,85" size="60,22" font="Regular;21" halign="right" transparent="1" /> <widget source="Frontend" render="Progress" position="190,85" size="260,20" pixmap="skin_default/bar_ber.png" borderWidth="2" borderColor="#cccccc"> <convert type="FrontendInfo">BER</convert> </widget> <widget source="Frontend" render="Label" position="460,85" size="60,22" font="Regular;21"> <convert type="FrontendInfo">BER</convert> </widget> <!-- config --> <widget name="config" position="10,120" size="500,320" scrollbarMode="showOnDemand" transparent="1" /> <widget name="introduction" position="10,450" size="500,25" font="Regular;20" halign="center" valign="center" /> </screen>""" def __init__(self, session): self.skin = SimpleSatScan.skin Screen.__init__(self, session) self.initcomplete = False self.frontend = None self.prev_ref = False self.oldref = None self.updateSatList() self.service = session.nav.getCurrentService() self.feinfo = None 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["actions"] = NumberActionMap(["SetupActions"], { "ok": self.keyGo, "cancel": self.keyCancel, }, -2) self.list = [] self.tpslist = [] self.tpslist_idx = 0 self.tuneTimer = eTimer() self.tuneTimer.callback.append(self.updateTuneStatus) ConfigListScreen.__init__(self, self.list) if not self.scan_nims.value == "": self.createSetup() self.feid = int(self.scan_nims.value) orbpos = "??" if len(self.satList) > self.feid and len( self.scan_satselection) > self.feid and len( self.satList[self.feid]): orbpos = self.OrbToStr(self.satList[self.feid][ self.scan_satselection[self.feid].index][0]) self["status"] = Label( orbpos + ": " + str(self.scan_sat.frequency.value) + " " + self.PolToStr(self.scan_sat.polarization.value)) 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." )) self["status"] = Label("") self.feid = None self.initFrontend() self.initcomplete = self.feid != None 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 return False def initFrontend(self): if self.oldref is None: self.oldref = self.session.nav.getCurrentlyPlayingServiceReference( ) if not self.openFrontend(): self.prev_ref = True self.session.nav.stopService() # try to disable foreground service if not self.openFrontend(): if self.session.pipshown: # try to disable pip self.session.pipshown = False del self.session.pip if not self.openFrontend(): self.frontend = None # in normal case this should not happen try: self.tuner = Tuner(self.frontend) self["Frontend"] = FrontendStatus( frontend_source=lambda: self.frontend, update_interval=100) except: pass def deInitFrontend(self): if self.frontend: self.frontend = None del self.raw_channel def updateTuneStatus(self): if not self.frontend: return stop = False dict = {} self.frontend.getFrontendStatus(dict) if dict["tuner_state"] == "TUNING": self.tuneTimer.start(100, True) else: if dict["tuner_state"] == "LOSTLOCK" or dict[ "tuner_state"] == "FAILED": self.tpslist_idx += 1 if self.tpslist_idx >= len(self.tpslist): stop = True self["status"].setText("search failed!") self.tpslist_idx = 0 elif dict["tuner_state"] == "LOCKED": stop = True if not stop: self["status"].setText( self.OrbToStr(self.tpslist[self.tpslist_idx][5]) + ": " + str(self.tpslist[self.tpslist_idx][0]) + " " + self.PolToStr(self.tpslist[self.tpslist_idx][2])) self.tune(self.tpslist[self.tpslist_idx]) self.tuneTimer.start(100, True) def tune(self, transponder): if self.initcomplete: if transponder is not None and self.tuner is not None: self.tuner.tune(transponder) def retune(self, configElement): self.tuneTimer.stop() if self.scan_nims == []: return if self.scan_nims.value == "": return self.tpslist_idx = 0 tpslist = [] status_text = "" multi_tune = False index_to_scan = int(self.scan_nims.value) if len(self.satList) <= index_to_scan: return if len(self.scan_satselection) <= index_to_scan: return nim = nimmanager.nim_slots[index_to_scan] if not nim.isCompatible("DVB-S"): return nimsats = self.satList[index_to_scan] selsatidx = self.scan_satselection[index_to_scan].index if self.scan_type.value == "single_transponder": if len(nimsats): orbpos = nimsats[selsatidx][0] if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.value else: fec = self.scan_sat.fec_s2.value tpslist.append( (self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, self.scan_sat.polarization.value, fec, self.scan_sat.inversion.value, orbpos, self.scan_sat.system.value, self.scan_sat.modulation.value, self.scan_sat.rolloff.value, self.scan_sat.pilot.value)) elif self.scan_type.value == "predefined_transponder": if len(nimsats): orbpos = nimsats[selsatidx][0] index = self.scan_transponders.index if configElement and configElement._value == str(orbpos): index = 0 tps = nimmanager.getTransponders(orbpos) if len(tps) > index: x = tps[index] tpslist.append((x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], orbpos, x[5], x[6], x[8], x[9])) #else: # status_text = "tpslist for %d empty! %d" % (sat[0], index) elif self.scan_type.value == "single_satellite": if len(nimsats): multi_tune = True orbpos = nimsats[selsatidx][0] tps = nimmanager.getTransponders(orbpos) for x in tps: if x[0] == 0: #SAT tpslist.append((x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], orbpos, x[5], x[6], x[8], x[9])) elif self.scan_type.value == "multisat": if len(self.multiscanlist): for sat in self.multiscanlist: if sat[1].value or len(tpslist) == 0: if len(tpslist): del tpslist[:] tps = nimmanager.getTransponders(sat[0]) for x in tps: if x[0] == 0: #SAT tpslist.append( (x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], sat[0], x[5], x[6], x[8], x[9])) if sat[1].value: multi_tune = True break else: status_text = "multiscanlist empty!" SatList = nimmanager.getSatListForNim(index_to_scan) for sat in SatList: tps = nimmanager.getTransponders(sat[0]) for x in tps: if x[0] == 0: #SAT tpslist.append( (x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], sat[0], x[5], x[6], x[8], x[9])) if len(tpslist): break self.tpslist = tpslist if len(self.tpslist): status_text = self.OrbToStr( self.tpslist[self.tpslist_idx][5]) + ": " + str( self.tpslist[self.tpslist_idx][0]) + " " + self.PolToStr( self.tpslist[self.tpslist_idx][2]) self.tune(self.tpslist[self.tpslist_idx]) if multi_tune: self.tuneTimer.start(100, True) self["status"].setText(status_text) def OrbToStr(self, orbpos=-1): if orbpos == -1 or orbpos > 3600: return "??" if orbpos > 1800: return "%d.%dW" % ((3600 - orbpos) / 10, (3600 - orbpos) % 10) else: return "%d.%dE" % (orbpos / 10, orbpos % 10) def PolToStr(self, pol): return (pol == 0 and "H") or (pol == 1 and "V") or ( pol == 2 and "L") or (pol == 3 and "R") or "??" def FecToStr(self, fec): return (fec == 0 and "Auto") or (fec == 1 and "1/2") or (fec == 2 and "2/3") or (fec == 3 and "3/4") or \ (fec == 4 and "5/6") or (fec == 5 and "7/8") or (fec == 6 and "8/9") or (fec == 7 and "3/5") or \ (fec == 8 and "4/5") or (fec == 9 and "9/10") or (fec == 15 and "None") or "Unknown" def updateTranspondersList(self, orbpos): if orbpos is not None: index = 0 list = [] tps = nimmanager.getTransponders(orbpos) for x in tps: if x[0] == 0: #SAT s = str(x[1] / 1000) + " " + self.PolToStr( x[3]) + " / " + str( x[2] / 1000) + " / " + self.FecToStr(x[4]) list.append((str(index), s)) index += 1 self.scan_transponders = ConfigSelection(choices=list, default="0") self.scan_transponders.addNotifier(self.retune, initial_call=False) 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.tuneTimer.stop() self.list = [] self.multiscanlist = [] index_to_scan = int(self.scan_nims.value) self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims) self.list.append(self.tunerEntry) if self.scan_nims == []: return self.typeOfScanEntry = None self.systemEntry = None self.satelliteEntry = None self.modulationEntry = None self.scan_networkScan.value = False 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) if self.scan_type.value == "single_transponder": self.updateSatList() sat = self.satList[index_to_scan][ self.scan_satselection[index_to_scan].index] self.updateTranspondersList(sat[0]) if nim.isCompatible("DVB-S2"): self.systemEntry = getConfigListEntry( _('System'), self.scan_sat.system) self.list.append(self.systemEntry) else: self.scan_sat.system.value = 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(_("Polarity"), self.scan_sat.polarization)) if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append( getConfigListEntry(_("FEC"), self.scan_sat.fec)) elif self.scan_sat.system.value == 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(_('Rolloff'), self.scan_sat.rolloff)) self.list.append( getConfigListEntry(_('Pilot'), self.scan_sat.pilot)) elif self.scan_type.value == "predefined_transponder": self.updateSatList() self.satelliteEntry = getConfigListEntry( _('Satellite'), self.scan_satselection[index_to_scan]) self.list.append(self.satelliteEntry) sat = self.satList[index_to_scan][ self.scan_satselection[index_to_scan].index] self.updateTranspondersList(sat[0]) self.list.append( getConfigListEntry(_('Transponder'), self.scan_transponders)) elif self.scan_type.value == "single_satellite": self.updateSatList() sat = self.satList[index_to_scan][ self.scan_satselection[index_to_scan].index] self.updateTranspondersList(sat[0]) print self.scan_satselection[index_to_scan] self.list.append( getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan])) self.scan_networkScan.value = True elif self.scan_type.value == "multisat": 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.value.find("_yes") != -1 and True or False) configEntry = getConfigListEntry( nimmanager.getSatDescription(x[0]), sat) self.list.append(configEntry) self.multiscanlist.append((x[0], sat)) sat.addNotifier(self.retune, initial_call=False) self.scan_networkScan.value = True 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() if cur == self.typeOfScanEntry or \ cur == self.tunerEntry or \ cur == self.systemEntry or \ cur == self.satelliteEntry or \ (self.modulationEntry and self.systemEntry[1].value == 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 } 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) self.scan_sat = ConfigSubsection() self.scan_type = ConfigSelection( default="single_transponder", choices=[("single_transponder", _("Single transponder")), ("predefined_transponder", _("Predefined transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat"))]) self.scan_transponders = None 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 = [] 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.value)) if n.type == nimmanager.nim_slots[root_id].type: continue if n.isCompatible("DVB-S"): nim_list.append((str(n.slot), n.friendly_full_description)) self.scan_nims = ConfigSelection(choices=nim_list) 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") ]) 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")) ]) self.scan_scansat = {} for sat in nimmanager.satList: self.scan_scansat[sat[0]] = ConfigYesNo(default=False) self.scan_satselection = [] for slot in nimmanager.nim_slots: if slot.isCompatible("DVB-S"): x = getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]) x.addNotifier(self.retune, initial_call=False) self.scan_satselection.append(x) else: self.scan_satselection.append(None) for x in (self.scan_nims, self.scan_type, self.scan_sat.frequency, self.scan_sat.inversion, self.scan_sat.symbolrate, self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot, self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation, self.scan_sat.rolloff, self.scan_sat.system): x.addNotifier(self.retune, initial_call=False) return True def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() 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 getInitialTransponderList(self, tlist, pos): list = nimmanager.getTransponders(pos) for x in list: if x[0] == 0: #SAT parm = eDVBFrontendParametersSatellite() parm.frequency = x[1] parm.symbol_rate = x[2] parm.polarisation = x[3] parm.fec = x[4] parm.inversion = x[7] parm.orbital_position = pos parm.system = x[5] parm.modulation = x[6] parm.rolloff = x[8] parm.pilot = x[9] tlist.append(parm) def keyGo(self): if self.scan_nims.value == "": return self.tuneTimer.stop() self.deInitFrontend() index_to_scan = int(self.scan_nims.value) self.feid = index_to_scan tlist = [] flags = None startScan = True removeAll = True self.prev_ref = True 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] if not nim.isCompatible("DVB-S"): return #if self.scan_type.value == "single_transponder": if self.scan_type.value.find("_transponder") != -1: 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 if len(nimsats): orbpos = nimsats[selsatidx][0] if self.scan_type.value == "single_transponder": if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.value else: fec = self.scan_sat.fec_s2.value self.addSatTransponder(tlist, self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, self.scan_sat.polarization.value, fec, self.scan_sat.inversion.value, orbpos, self.scan_sat.system.value, self.scan_sat.modulation.value, self.scan_sat.rolloff.value, self.scan_sat.pilot.value) elif self.scan_type.value == "predefined_transponder": tps = nimmanager.getTransponders(orbpos) if len(tps) > self.scan_transponders.index: x = tps[self.scan_transponders.index] self.addSatTransponder(tlist, x[1] / 1000, x[2] / 1000, x[3], x[4], x[7], orbpos, x[5], x[6], x[8], x[9]) removeAll = False elif self.scan_type.value == "single_satellite": sat = self.satList[index_to_scan][ self.scan_satselection[index_to_scan].index] self.getInitialTransponderList(tlist, sat[0]) elif self.scan_type.value.find("multisat") != -1: SatList = nimmanager.getSatListForNim(index_to_scan) for x in self.multiscanlist: if x[1].value: print " " + str(x[0]) self.getInitialTransponderList(tlist, x[0]) flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0 tmp = self.scan_clearallservices.value 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.value: flags |= eComponentScan.scanOnlyFree for x in self["config"].list: x[1].save() if startScan: self.startScan(tlist, flags, index_to_scan) def keyCancel(self): for x in self["config"].list: x[1].cancel() if self.oldref and self.prev_ref: self.session.openWithCallback( self.restartPrevService, MessageBox, _("Zap back to service before a service scan?"), MessageBox.TYPE_YESNO, timeout=5) else: self.close() def restartPrevService(self, answer): if answer: self.tuneTimer.stop() self.deInitFrontend() if self.oldref: self.session.nav.playService(self.oldref) self.close() def startScan(self, tlist, flags, feid): if len(tlist): self.session.openWithCallback(self.serviceScanFinished, ServiceScan, [{ "transponders": tlist, "feid": feid, "flags": flags }]) else: self.session.open( MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan." ), MessageBox.TYPE_ERROR) self.keyCancel() def serviceScanFinished(self): self.session.openWithCallback( self.restartSimpleSatScan, MessageBox, _("Do you want to scan another transponder/satellite?"), MessageBox.TYPE_YESNO, timeout=10) def restartSimpleSatScan(self, answer): if answer: # reinit FrontendStatus... self.frontend = None self.initFrontend() self.retune(None) else: self.keyCancel()
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, menu_path=""): Screen.__init__(self, session) self.skinName = "Setup" self.menu_path = menu_path self["menu_path_compressed"] = 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["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.value if configele.value in [x[0] for x in self.styles] or fileExists(configele.value, "w"): configele.last_value = configele.value return True else: dir = configele.value 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.value default = config.usage.default_path.value 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.value default = config.usage.timer_path.value 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.value default = config.usage.instantrec_path.value 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.value: self["config"].list.sort() def layoutFinished(self): if config.usage.show_menupath.value == 'large' and self.menu_path: title = self.menu_path + _(self.setup_title) self["menu_path_compressed"].setText("") elif config.usage.show_menupath.value == 'small': title = _(self.setup_title) self["menu_path_compressed"].setText(self.menu_path + " >" if not self.menu_path.endswith(' / ') else self.menu_path[:-3] + " >" or "") else: title = _(self.setup_title) self["menu_path_compressed"].setText("") self.setup_title = title self.setTitle(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.value self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value 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.value) ) elif currentry == self.timer_entry: self.entrydirname = self.timer_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("New timers location"), preferredPath(self.timer_dirname.value) ) elif currentry == self.instantrec_entry: self.entrydirname = self.instantrec_dirname self.session.openWithCallback( self.dirnameSelected, MovieLocationBox, _("Instant recordings location"), preferredPath(self.instantrec_dirname.value) ) def dirnameSelected(self, res): if res is not None: self.entrydirname.value = res if config.movielist.videodirs.value != self.lastvideodirs: styles_keys = [x[0] for x in self.styles] tmp = config.movielist.videodirs.value default = self.default_dirname.value if default not in tmp: tmp = tmp[:] tmp.append(default) self.default_dirname.setChoices(tmp, default=default) tmp = config.movielist.videodirs.value default = self.timer_dirname.value 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.value default = self.instantrec_dirname.value 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.value config.usage.timer_path.value = self.timer_dirname.value config.usage.instantrec_path.value = self.instantrec_dirname.value 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.value and not item.value == "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 VcsProfileSetup(ConfigListScreen, Screen): skin = """ <screen name="VcsProfileSetup" position="center,center" size="550,350" title="%s" backgroundColor="transparent" flags="wfNoBorder" > <widget source="header" render="Label" position="0,0" zPosition="1" size="550,80" halign="center" valign="center" noWrap="1" font="Regular;26" foregroundColor="red" backgroundColor="background" shadowColor="black" shadowOffset="-2,-2" transparent="1"/> <widget name="config" position="0,100" size="550,200" scrollbarMode="showOnDemand" zPosition="1" foregroundColor="white" backgroundColor="transparent" /> <ePixmap pixmap="skin_default/buttons/red.png" position="135,310" size="140,40" alphatest="on" /> <ePixmap pixmap="skin_default/buttons/green.png" position="275,310" size="140,40" alphatest="on" /> <widget source="key_red" render="Label" position="135,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" /> <widget source="key_green" render="Label" position="275,310" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" /> </screen>""" % (_('%s: Profile Setup') % (PLUGIN_NAME)) def __init__(self, session, profile): Screen.__init__(self, session) self["header"] = StaticText("") self["key_red"] = StaticText(_("Cancel")) self["key_green"] = StaticText(_("OK")) self["setupActions"] = ActionMap( ["SetupActions", "ColorActions"], { "red": self.cancel, "green": self.save, "save": self.save, "cancel": self.cancel, "ok": self.keyOk, }, -2) self.pf_saved_value = profile.saved_value self.prev_stretch = getStretch() self.prev_aspect = getAspect() self.prev_cliprect = getClipRect() self.initConfig(profile) ConfigListScreen.__init__(self, []) self.createSetup() self.onClose.append(self.__onClose) def __onClose(self): setStretch(self.prev_stretch) setAspect(self.prev_aspect) setClipRect(self.prev_cliprect) def keyLeft(self): ConfigListScreen.keyLeft(self) self.newConfig() def keyRight(self): ConfigListScreen.keyRight(self) self.newConfig() def keyOk(self): cur = self["config"].getCurrent() if cur[1] in (self.clip.X, self.clip.Y, self.clip.W, self.clip.H): from Components.Input import Input from Screens.InputBox import InputBox from Tools.BoundFunction import boundFunction self.session.openWithCallback(boundFunction( self.setSliderStep, cur[1]), InputBox, title=_("Set slider step (1 - 20):"), text=str(cur[1].increment), type=Input.NUMBER) def setSliderStep(self, slider, step): if step and (0 < int(step) < 21): slider.increment = int(step) self["config"].instance.invalidate() def initConfig(self, pf): self.profile = pf self.clip = ConfigSubsection() self.clip.X = ConfigSlider(default=pf.cliprect.value[0], increment=5, limits=(0, 719)) self.clip.Y = ConfigSlider(default=pf.cliprect.value[1], increment=5, limits=(0, 575)) self.clip.W = ConfigSlider(default=pf.cliprect.value[2], increment=5, limits=(0, 720)) self.clip.H = ConfigSlider(default=pf.cliprect.value[3], increment=5, limits=(0, 576)) self.pf_stretch = ConfigSelection([("0", _("no")), ("1", _("yes"))], default=pf.stretch.value) self.pf_aspect = ConfigSelection([(0, _("4:3 Letterbox")), (1, _("4:3 PanScan")), (2, _("16:9")), (3, _("16:9 always")), (4, _("16:10 Letterbox")), (5, _("16:10 PanScan")), (6, _("16:9 Letterbox"))], default=pf.aspect.value) self.pf_aspect.addNotifier(self.aspectSettingChanged) self.pf_stretch.addNotifier(self.stretchSettingChanged) for elem in [self.clip.X, self.clip.Y, self.clip.W, self.clip.H]: elem.addNotifier(self.videoSettingChanged) def newConfig(self): pass def createSetup(self): list = [] list.append(getConfigListEntry(_("Profile Name"), self.profile.name)) list.append( getConfigListEntry(_("Enable Profile"), self.profile.enabled)) list.append( getConfigListEntry(_("Use Video Stretch (3D content)"), self.pf_stretch)) list.append(getConfigListEntry(_("Aspect Ratio"), self.pf_aspect)) list.append(getConfigListEntry(_("Video Left"), self.clip.X)) list.append(getConfigListEntry(_("Video Width"), self.clip.W)) list.append(getConfigListEntry(_("Video Top"), self.clip.Y)) list.append(getConfigListEntry(_("Video Height"), self.clip.H)) self["config"].list = list self["config"].l.setList(list) def save(self): self.profile.cliprect.value = [ self.clip.X.value, self.clip.Y.value, self.clip.W.value, self.clip.H.value ] self.profile.stretch.value = self.pf_stretch.value self.profile.aspect.value = self.pf_aspect.value self.profile.save() self.close(True, self.profile) def cancel(self): for x in self["config"].list: x[1].cancel() if self.pf_saved_value: self.profile.saved_value = self.pf_saved_value self.close(False, self.profile) def stretchSettingChanged(self, elem): setStretch(int(elem.value)) def aspectSettingChanged(self, elem): setAspect(int(elem.value)) self.updateHeaderText() def videoSettingChanged(self, elem): if self.clip.X.value + self.clip.W.value > 720: self.clip.W.value = 720 - self.clip.X.value if self.clip.Y.value + self.clip.H.value > 576: self.clip.H.value = 576 - self.clip.Y.value if "config" in self: self["config"].instance.invalidate() setClipRect([ self.clip.X.value, self.clip.Y.value, self.clip.W.value, self.clip.H.value ]) self.updateHeaderText() def updateHeaderText(self): if "header" in self: self["header"].setText( "%s\n[%d, %d, %d, %d]" % (getAspectString(self.pf_aspect.value), self.clip.X.value, self.clip.Y.value, self.clip.W.value, self.clip.H.value))