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