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))
