class NetworkConfigGlobal(Screen, ConfigListScreen):
skin = """
<screen name="NetworkConfigGlobal" position="center,center" size="520,50" title="Network: General configuration">
<widget name="config" position="10,10" size="500,30" scrollbarMode="showOnDemand"/>
</screen>"""
def __init__(self, session):
Screen.__init__(self, session)
ConfigListScreen.__init__(self, [], session=session)
self["setupActions"] = ActionMap(["SetupActions", "ColorActions"],
{
"save": self.close,
"cancel": self.close,
"ok" : self.close,
}, -2)
self._nm = eNetworkManager.getInstance();
choices_timeupdates = { eNetworkManager.TIME_UPDATES_AUTO : _("auto"), eNetworkManager.TIME_UPDATES_MANUAL : _("manual") }
self._config_timeupdates = ConfigSelection(choices_timeupdates, default=self._nm.timeUpdates())
self._config_timeupdates.addNotifier(self._config_changed, initial_call=False)
self._createSetup()
self.onLayoutFinish.append(self._layoutFinished)
def _layoutFinished(self):
self.setTitle(_("Network: General configuration"))
def _config_changed(self, element):
self._nm.setTimeUpdates(self._config_timeupdates.value)
self._createSetup()
def _createSetup(self):
lst = [getConfigListEntry(_("NTP Time Updates"), self._config_timeupdates)]
self["config"].list = lst
def __init__(self, default="#00149baf"):
ConfigSelection.__init__(
self,
default=default,
choices=[
("#00F0A30A", _("Amber")),
("#00ffffff", _("White")),
("#00825A2C", _("Brown")),
("#000050EF", _("Cobalt")),
("#00911d10", _("Crimson")),
("#001BA1E2", _("Cyan")),
("#00a61d4d", _("Magenta")),
("#00A4C400", _("Lime")),
("#006A00FF", _("Indigo")),
("#0070ad11", _("Green")),
("#00008A00", _("Emerald")),
("#0076608A", _("Mauve")),
("#006D8764", _("Olive")),
("#00c3461b", _("Orange")),
("#00F472D0", _("Pink")),
("#00E51400", _("Red")),
("#007A3B3F", _("Sienna")),
("#00647687", _("Steel")),
("#00149baf", _("Teal")),
("#006c0aab", _("Violet")),
("#00bf9217", _("Yellow")),
],
)
def __init__(self, service):
self._service = service
self.onChanged = []
self.onMethodChanged = []
method_choices_ip4 = {eNetworkService.METHOD_DHCP : "dhcp", eNetworkService.METHOD_MANUAL : _("manual"), eNetworkService.METHOD_OFF : _("off")}
#IPv4
self._config_ip4_method = ConfigSelection(method_choices_ip4, default=eNetworkService.METHOD_DHCP)
self._config_ip4_address = ConfigIP(default=[0,0,0,0])
self._config_ip4_mask = ConfigIP(default=[0,0,0,0])
self._config_ip4_gw = ConfigIP(default=[0,0,0,0])
#IPv6
method_choices_ip6 = {eNetworkService.METHOD_AUTO : _("auto"), eNetworkService.METHOD_6TO4 : "6to4", eNetworkService.METHOD_MANUAL : _("manual"), eNetworkService.METHOD_OFF : _("off")}
choices_privacy_ip6 = {eNetworkService.IPV6_PRIVACY_DISABLED : _("Disabled"), eNetworkService.IPV6_PRIVACY_ENABLED : _("Enabled"), eNetworkService.IPV6_PRIVACY_PREFERRED : _("Preferred")}
self._config_ip6_method = ConfigSelection(method_choices_ip6, default=eNetworkService.METHOD_DHCP)
self._config_ip6_address = ConfigIP6()
self._config_ip6_prefix_length = ConfigInteger(0, limits=(1, 128))
self._config_ip6_gw = ConfigIP6()
self._config_ip6_privacy = ConfigSelection(choices_privacy_ip6, default="disabled")
self._isReloading = False
self._ipv4Changed = False
self._ipv6Changed = False
self._addNotifiers()
self._service_conn = [
self._service.ipv4Changed.connect(self._serviceChanged),
self._service.ipv6Changed.connect(self._serviceChanged),
self._service.ipv4ConfigChanged.connect(self._serviceChanged),
self._service.ipv6ConfigChanged.connect(self._serviceChanged),
]
def __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 handleKey(self, key):
if key == KEY_OK:
debug("[SwitchWidget] KEY_OK pressed")
self.selectNext()
self.send_command()
else:
ConfigSelection.handleKey(self, key)
def createSetup(self):
default = config.usage.timeshift_path.value
cooldefault = config.usage.autorecord_path.value
tmp = config.usage.allowed_timeshift_paths.value
cooltmp = config.usage.allowed_autorecord_paths.value
if default not in tmp:
tmp = tmp[:]
tmp.append(default)
if cooldefault not in cooltmp:
cooltmp = cooltmp[:]
cooltmp.append(cooldefault)
# 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.value:
self["config"].list.sort()
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 handleKey(self, key):
debug("[ShutterWidget] key pressed: " + str(key))
if key == KEY_OK:
self.send_command("STOP")
elif key == KEY_LEFT:
self.send_command("UP")
elif key == KEY_RIGHT:
self.send_command("DOWN")
else:
ConfigSelection.handleKey(self, key)
def initConfigList(self):
self.styles = [ ("<default>", _("<Default movie location>")), ("<current>", _("<Current movielist location>")), ("<timer>", _("<Last timer location>")) ]
styles_keys = [x[0] for x in self.styles]
tmp = config.movielist.videodirs.value
default = config.usage.default_path.value
if default not in tmp:
tmp = tmp[:]
tmp.append(default)
print "DefaultPath: ", default, tmp
self.default_dirname = ConfigSelection(default = default, choices = tmp)
tmp = config.movielist.videodirs.value
default = config.usage.timer_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
print "TimerPath: ", default, tmp
self.timer_dirname = ConfigSelection(default = default, choices = self.styles+tmp)
tmp = config.movielist.videodirs.value
default = config.usage.instantrec_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
print "InstantrecPath: ", default, tmp
self.instantrec_dirname = ConfigSelection(default = default, choices = self.styles+tmp)
default = config.usage.timeshift_path.value
tmp = config.usage.allowed_timeshift_paths.value
if default not in tmp:
tmp = tmp[:]
tmp.append(default)
print "TimeshiftPath: ", default, tmp
self.timeshift_dirname = ConfigSelection(default = default, choices = tmp)
self.timeshift_dirname.last_value = self.timeshift_dirname.value
self.default_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False)
self.default_dirname.last_value = self.default_dirname.value
self.timer_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False)
self.timer_dirname.last_value = self.timer_dirname.value
self.instantrec_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False)
self.instantrec_dirname.last_value = self.instantrec_dirname.value
self.timeshift_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False)
self.timeshift_dirname.last_value = self.timeshift_dirname.value
self.list = []
if config.usage.setup_level.index >= 2:
self.default_entry = getConfigListEntry(_("Default movie location"), self.default_dirname)
self.list.append(self.default_entry)
self.timer_entry = getConfigListEntry(_("Timer record location"), self.timer_dirname)
self.list.append(self.timer_entry)
self.instantrec_entry = getConfigListEntry(_("Instant record location"), self.instantrec_dirname)
self.list.append(self.instantrec_entry)
else:
self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname)
self.list.append(self.default_entry)
self.timeshift_entry = getConfigListEntry(_("Timeshift location"), self.timeshift_dirname)
self.list.append(self.timeshift_entry)
self["config"].setList(self.list)
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()
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 initConfig(self, pf):
self.profile = pf
self.clip = ConfigSubsection()
self.clip.X = ConfigSlider(default = pf.cliprect.value[0], increment = 5, limits = (0, 719))
self.clip.Y = ConfigSlider(default = pf.cliprect.value[1], increment = 5, limits = (0, 575))
self.clip.W = ConfigSlider(default = pf.cliprect.value[2], increment = 5, limits = (0, 720))
self.clip.H = ConfigSlider(default = pf.cliprect.value[3], increment = 5, limits = (0, 576))
self.pf_stretch = ConfigSelection([("0",_("no")), ("1", _("yes"))], default = pf.stretch.value)
self.pf_aspect = ConfigSelection([(0, _("4:3 Letterbox")), (1, _("4:3 PanScan")), (2, _("16:9")), (3, _("16:9 always")), (4, _("16:10 Letterbox")), (5, _("16:10 PanScan")), (6, _("16:9 Letterbox"))], default = pf.aspect.value)
self.pf_aspect.addNotifier(self.aspectSettingChanged)
self.pf_stretch.addNotifier(self.stretchSettingChanged)
for elem in [self.clip.X,self.clip.Y,self.clip.W,self.clip.H]:
elem.addNotifier(self.videoSettingChanged)
def __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 __init__(self, session, nimList):
Screen.__init__(self, session)
self["actions"] = ActionMap(["SetupActions", "MenuActions"],
{
"ok": self.keyGo,
"save": self.keySave,
"cancel": self.keyCancel,
"menu": self.closeRecursive,
}, -2)
providerList = list(x[0] for x in self.providers)
lastConfiguration = eval(config.misc.fastscan.last_configuration.value)
if not lastConfiguration or not tuple(x for x in self.providers if x[0] == lastConfiguration[1]):
lastConfiguration = (nimList[0][0], providerList[0], True, True, False, 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.scan_create_radio_bouquet = ConfigYesNo(default = len(lastConfiguration) > 5 and lastConfiguration[5])
self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
self.scanProvider = getConfigListEntry(_("Provider"), self.scan_provider)
self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd)
self.config_autoproviders = {}
auto_providers = config.misc.fastscan.autoproviders.value.split(",")
for provider in self.providers:
self.config_autoproviders[provider[0]] = ConfigYesNo(default=provider[0] in auto_providers )
self.list = []
ConfigListScreen.__init__(self, self.list)
self.createSetup()
self.finished_cb = None
self["introduction"] = Label(_("Select your provider, and press OK to start the scan"))
def __init__(self, session):
Screen.__init__(self, session)
for btn in ("red","green","yellow","blue"):
self["key_" + btn] = Button(" ")
ConfigListScreen.__init__(self, [])
self.defprofile = ConfigSelection([])
self.updateConfigList()
self.pfsList = []
self["profiles"] = List(self.pfsList)
self.updateProfileList()
self["actions"] = ActionMap(["OkCancelActions", "ColorActions", "DirectionActions", "ChannelSelectEPGActions"],
{
"cancel": self.keyExit,
"ok": self.keyOk,
"showEPGList": self.showExamples,
"red": self.keyRed,
"green": self.keyGreen,
"yellow": boundFunction(self.moveEntry, -1),
"blue": boundFunction(self.moveEntry, +1),
"up": self.keyUp,
"down": self.keyDown,
}, -1)
self.onClose.append(self.__closed)
self.onLayoutFinish.append(self.__layoutFinished)
self.onShown.append(self.updateButtonState)
self.prev_ext_menu = config.plugins.VCS.ext_menu.value
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()
def __init__(self, session):
Screen.__init__(self, session)
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.value))
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 = False)
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 __init__(self, session):
self.session = session
Screen.__init__(self, self.session)
self.skinName = ['Setup']
self.setTitle(_('Spark7162 select tuner mode'))
self['actions'] = ActionMap(['SetupActions', 'ColorActions'], {'cancel': self.cancel,
'ok': self.ok,
'green': self.ok,
'red': self.cancel}, -2)
t = None
if os_path.exists(filename):
settings = open(filename)
while True:
s = settings.readline().strip()
if s == '':
break
if s.startswith(option):
try:
t = s[len(option)]
except IndexError:
print '[UnionTunerType] bad format in modprobe config'
break
settings.close()
if t is None:
t = 't'
self.tunerconfig = ConfigSelection(default=t, choices=[('t', _('terrestrial')), ('c', _('cable'))])
conf = []
conf.append(getConfigListEntry(_('UnionTunerType'), self.tunerconfig))
ConfigListScreen.__init__(self, conf, session=self.session)
self['key_red'] = StaticText(_('Cancel'))
self['key_green'] = StaticText(_('OK'))
def createConfig(self):
def set_avahiselect_seperate(configElement):
if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value != config.usage.remote_fallback.value:
peerDefault_sepearate = config.usage.remote_fallback_import_url.value
else:
peerDefault_sepearate = "same"
config.usage.remote_fallback_import_url.value = config.usage.remote_fallback.value
self.seperateBoxes = [("same", _("Same as stream"))] + self.peerStreamingBoxes
if configElement.value not in ("url", "ip") and configElement.value in self.seperateBoxes:
self.seperateBoxes.remove(configElement.value)
self.avahiselect_seperate = ConfigSelection(default=peerDefault_sepearate, choices=self.seperateBoxes)
self.peerStreamingBoxes = getPeerStreamingBoxes() + [("ip", _("Enter IP address")), ("url", _("Enter URL"))]
peerDefault = peerDefault_sepearate = None
if config.usage.remote_fallback.value:
peerDefault = peerDefault_sepearate = config.usage.remote_fallback.value
if config.usage.remote_fallback.value and config.usage.remote_fallback.value not in self.peerStreamingBoxes:
self.peerStreamingBoxes = [config.usage.remote_fallback.value] + self.peerStreamingBoxes
if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value not in self.peerStreamingBoxes:
self.peerStreamingBoxes = [config.usage.remote_fallback_import_url.value] + self.peerStreamingBoxes
self.avahiselect = ConfigSelection(default=peerDefault, choices=self.peerStreamingBoxes)
self.avahiselect.addNotifier(set_avahiselect_seperate)
try:
ipDefault = [int(x) for x in config.usage.remote_fallback.value.split(":")[1][2:].split(".")]
portDefault = int( config.usage.remote_fallback.value.split(":")[2])
except:
ipDefault = [0, 0, 0, 0]
portDefault = 8001
self.ip = ConfigIP(default=ipDefault, auto_jump=True)
self.port = ConfigInteger(default=portDefault, limits=(1,65535))
self.ip_seperate = ConfigIP( default=ipDefault, auto_jump=True)
self.port_seperate = ConfigInteger(default=portDefault, limits=(1,65535))
def setToggleSubsFilterKey(self, arg=None):
if self.settings.menupage.getValue() == PAGE_SUBTITLES:
cur = self["streams"].getCurrent()
sel_sub = cur and isinstance(cur[0], SelectionTrackinfoEntry) and cur[0].info
conflist = self["config"].list
if sel_sub and (sel_sub.getType() == iSt.DVD or sel_sub.getType() == iSt.GST and sel_sub.getGstSubtype() in [iGSt.stPGS, iGSt.stVOB]):
forcefilter = str(sel_sub.getFilter())
choicelist = [(str(iSubtitleFilterType_ENUMS.SUB_FILTER_SHOW_FORCED_ONLY), "forced only"), (str(iSubtitleFilterType_ENUMS.SUB_FILTER_SHOW_ALL), "show all")]
togglesubsfilter = ConfigSelection(choices = choicelist, default = forcefilter)
togglesubsfilter.addNotifier(boundFunction(self.toggleSubsFilter, cur[0]), initial_call = False)
self["key_green"].setBoolean(True)
conflist[1] = getConfigListEntry(_("Toggle Subtitle Filter"), togglesubsfilter)
else:
self["key_green"].setBoolean(False)
togglesubsfilter = None
conflist[1] = (('',))
self["config"].l.setList(conflist)
def createSetup(self):
self.styles = [ ("<default>", _("<Default movie location>")), ("<current>", _("<Current movielist location>")), ("<timer>", _("<Last timer location>")) ]
styles_keys = [x[0] for x in self.styles]
tmp = config.movielist.videodirs.value
default = config.usage.default_path.value
if default not in tmp:
tmp = tmp[:]
tmp.append(default)
# print "DefaultPath: ", default, tmp
self.default_dirname = ConfigSelection(default = default, choices = tmp)
tmp = config.movielist.videodirs.value
default = config.usage.timer_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
# print "TimerPath: ", default, tmp
self.timer_dirname = ConfigSelection(default = default, choices = self.styles+tmp)
tmp = config.movielist.videodirs.value
default = config.usage.instantrec_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
# print "InstantrecPath: ", default, tmp
self.instantrec_dirname = ConfigSelection(default = default, choices = self.styles+tmp)
self.default_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False)
self.timer_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False)
self.instantrec_dirname.addNotifier(self.checkReadWriteDir, initial_call=False, immediate_feedback=False)
list = []
if config.usage.setup_level.index >= 2:
self.default_entry = getConfigListEntry(_("Default movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location."))
list.append(self.default_entry)
self.timer_entry = getConfigListEntry(_("Timer recording location"), self.timer_dirname, _("Set the default location for your timers. Press 'OK' to add new locations, select left/right to select an existing location."))
list.append(self.timer_entry)
self.instantrec_entry = getConfigListEntry(_("Instant recording location"), self.instantrec_dirname, _("Set the default location for your instant recordings. Press 'OK' to add new locations, select left/right to select an existing location."))
list.append(self.instantrec_entry)
else:
self.default_entry = getConfigListEntry(_("Movie location"), self.default_dirname, _("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location."))
list.append(self.default_entry)
self.timer_entry = self.instantrec_entry = None
self.refill(list)
self["config"].setList(list)
if config.usage.sort_settings.value:
self["config"].list.sort()
def __init__(self, default = "#00000000"):
ConfigSelection.__init__(self, default=default, choices = BASIC_COLORS+[
("CUSTOM", _("CUSTOM")),
("#00000000", _("Black")),
("#00111111", _("PreBlack")),
("#00444444", _("Darkgrey")),
("#00bbbbbb", _("Lightgrey")),
("#00999999", _("Grey")),
("#006f0000", _("Darkred")),
("#00295c00", _("Darkgreen")),
("#006b3500", _("Darkbrown")),
("#00446b00", _("Darklime")),
("#00006b5b", _("Darkteal")),
("#00004c6b", _("Darkcyan")),
("#0000236b", _("Darkcobalt")),
("#0030006b", _("Darkpurple")),
("#006b003f", _("Darkmagenta")),
("#0065006b", _("Darkpink"))])
def __init__(self, default="#00000000"):
ConfigSelection.__init__(
self,
default=default,
choices=[
("CUSTOM", _("CUSTOM")),
("#00000000", _("Black")),
("#00111111", _("PreBlack")),
("#00ffffff", _("White")),
("#00444444", _("Darkgrey")),
("#00bbbbbb", _("Lightgrey")),
("#00999999", _("Grey")),
("#006f0000", _("Darkred")),
("#00295c00", _("Darkgreen")),
("#006b3500", _("Darkbrown")),
("#00446b00", _("Darklime")),
("#00006b5b", _("Darkteal")),
("#00004c6b", _("Darkcyan")),
("#0000236b", _("Darkcobalt")),
("#0030006b", _("Darkpurple")),
("#006b003f", _("Darkmagenta")),
("#0065006b", _("Darkpink")),
("#00F0A30A", _("Amber")),
("#00825A2C", _("Brown")),
("#000050EF", _("Cobalt")),
("#00911d10", _("Crimson")),
("#001BA1E2", _("Cyan")),
("#00a61d4d", _("Magenta")),
("#00A4C400", _("Lime")),
("#006A00FF", _("Indigo")),
("#0070ad11", _("Green")),
("#00008A00", _("Emerald")),
("#0076608A", _("Mauve")),
("#006D8764", _("Olive")),
("#00c3461b", _("Orange")),
("#00F472D0", _("Pink")),
("#00E51400", _("Red")),
("#007A3B3F", _("Sienna")),
("#00647687", _("Steel")),
("#00149baf", _("Teal")),
("#006c0aab", _("Violet")),
("#00bf9217", _("Yellow")),
],
)
def createConfig(self, foo):
self.tuning_type = ConfigSelection(default = "predefined_transponder", choices = [("single_transponder", _("User defined transponder")), ("predefined_transponder", _("Predefined transponder"))])
self.orbital_position = 192
if self.frontendData and self.frontendData.has_key('orbital_position'):
self.orbital_position = self.frontendData['orbital_position']
ScanSetup.createConfig(self, self.frontendData)
for x in (self.scan_sat.frequency,
self.scan_sat.inversion, self.scan_sat.symbolrate,
self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
self.scan_sat.rolloff, self.scan_sat.system,
self.scan_ter.channel, self.scan_ter.frequency, self.scan_ter.inversion,
self.scan_ter.bandwidth, self.scan_ter.fechigh, self.scan_ter.feclow,
self.scan_ter.modulation, self.scan_ter.transmission,
self.scan_ter.guard, self.scan_ter.hierarchy, self.scan_ter.plp_id,
self.scan_cab.frequency, self.scan_cab.inversion, self.scan_cab.symbolrate,
self.scan_cab.modulation, self.scan_cab.fec):
x.addNotifier(self.retune, initial_call = False)
satfinder_nim_list = []
for n in nimmanager.nim_slots:
if not (n.isCompatible("DVB-S") or n.isCompatible("DVB-T") or n.isCompatible("DVB-C")):
continue
if n.config_mode in ("loopthrough", "satposdepends", "nothing"):
continue
if n.isCompatible("DVB-S") and len(nimmanager.getSatListForNim(n.slot)) < 1:
continue
if n.isCompatible("DVB-S") and n.isFBCTuner() and not n.isFBCRoot():
continue
satfinder_nim_list.append((str(n.slot), n.friendly_full_description))
self.satfinder_scan_nims = ConfigSelection(choices = satfinder_nim_list)
if self.frontendData is not None and len(satfinder_nim_list) > 0: # open the plugin with the currently active NIM as default
active_nim = self.frontendData.get("tuner_number", int(satfinder_nim_list[0][0]))
if not nimmanager.nim_slots[active_nim].isFBCLink():
self.satfinder_scan_nims.setValue(str(active_nim))
self.feid = int(self.satfinder_scan_nims.value)
self.satList = []
self.scan_satselection = []
for slot in nimmanager.nim_slots:
if slot.isCompatible("DVB-S"):
self.satList.append(nimmanager.getSatListForNim(slot.slot))
self.scan_satselection.append(getConfigSatlist(self.orbital_position, self.satList[slot.slot]))
else:
self.satList.append(None)
if self.frontendData:
ttype = self.frontendData.get("tuner_type", "UNKNOWN")
if ttype == "DVB-S" and self.predefinedTranspondersList(self.getSelectedSatIndex(self.feid)) is None and len(nimmanager.getTransponders(self.getSelectedSatIndex(self.feid))) > 0:
self.tuning_type.value = "single_transponder"
elif ttype == "DVB-T" and self.predefinedTerrTranspondersList() is None and len(nimmanager.getTranspondersTerrestrial(nimmanager.getTerrestrialDescription(self.feid))) > 0:
self.tuning_type.value = "single_transponder"
elif ttype == "DVB-C" and self.predefinedCabTranspondersList() is None and len(nimmanager.getTranspondersCable(self.feid)) > 0:
self.tuning_type.value = "single_transponder"
class UnionTunerType(Screen, ConfigListScreen):
def __init__(self, session):
self.session = session
Screen.__init__(self, self.session)
self.skinName = ["Setup"]
self.setTitle(_("Amiko alien2 select tuner mode"))
self["actions"] = ActionMap(["SetupActions", "ColorActions"],
{
"cancel": self.cancel,
"ok": self.ok,
"green": self.ok,
"red": self.cancel,
}, -2)
t = None
if os_path.exists(filename):
settings = open(filename)
while True:
s = settings.readline().strip()
if s == '':
break
if s.startswith(option):
try:
t = s[len(option)]
except IndexError:
print '[UnionTunerType] bad format in modprobe config'
break
settings.close()
if t is None:
t = 't'
self.tunerconfig = ConfigSelection(default = t, choices = [ ('t', _("terrestrial")) , ('c', _("cable")) ])
conf = []
conf.append(getConfigListEntry(_("UnionTunerType"), self.tunerconfig))
ConfigListScreen.__init__(self, conf, session = self.session)
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("OK"))
def settingsWrite(self, result):
if result is not None and result:
settings = open(filename, 'w')
settings.write(option + self.tunerconfig.value + '\n')
settings.close()
self.session.open(TryQuitMainloop,retvalue=2)
self.close()
def ok(self):
if self.tunerconfig.isChanged():
self.session.openWithCallback(self.settingsWrite, MessageBox,
(_("Are you sure to save the current configuration and reboot your receiver?\n\n") ))
else:
self.close()
def cancel(self):
self.close()
def __init__(self, item, sub_page, mapping=None):
SitemapWidget.__init__(self, item, sub_page)
if mapping:
if not isinstance(mapping, list):
mapping = [mapping]
choices = map(lambda mi: (mi["command"], mi["label"]), mapping)
if len(mapping) == 1:
# button mode
if mapping[0]["command"] == item["state"]:
# disabled: empty text
choices = [(item["state"], "")]
else:
# add ability to send mapped command
choices.append((item["state"], mapping[0]["label"]))
else:
choices = [("ON", _("on")), ("OFF", _("off"))]
ConfigSelection.__init__(self, choices=choices, default=item["state"])
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 __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 not self.selectionChanged in self["config"].onSelectionChanged:
self["config"].onSelectionChanged.append(self.selectionChanged)
self.selectionChanged()
class UnionTunerType(Screen, ConfigListScreen):
def __init__(self, session):
self.session = session
Screen.__init__(self, self.session)
self.skinName = ['Setup']
self.setTitle(_('Spark7162 select tuner mode'))
self['actions'] = ActionMap(['SetupActions', 'ColorActions'], {'cancel': self.cancel,
'ok': self.ok,
'green': self.ok,
'red': self.cancel}, -2)
t = None
if os_path.exists(filename):
settings = open(filename)
while True:
s = settings.readline().strip()
if s == '':
break
if s.startswith(option):
try:
t = s[len(option)]
except IndexError:
print '[UnionTunerType] bad format in modprobe config'
break
settings.close()
if t is None:
t = 't'
self.tunerconfig = ConfigSelection(default=t, choices=[('t', _('terrestrial')), ('c', _('cable'))])
conf = []
conf.append(getConfigListEntry(_('UnionTunerType'), self.tunerconfig))
ConfigListScreen.__init__(self, conf, session=self.session)
self['key_red'] = StaticText(_('Cancel'))
self['key_green'] = StaticText(_('OK'))
def settingsWrite(self, result):
if result is not None and result:
for line in fileinput.input(filename, inplace = 1):
if line.startswith(option):
print option + self.tunerconfig.value
else:
print line,
fileinput.close()
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def ok(self):
if self.tunerconfig.isChanged():
self.session.openWithCallback(self.settingsWrite, MessageBox, _('Are you sure to save the current configuration and reboot your receiver?\n\n'))
else:
self.close()
def cancel(self):
self.close()
def updateTranspondersList(self, orbpos): if orbpos is not None: index = 0 list = [] tps = nimmanager.getTransponders(orbpos) for x in tps: if x[0] == 0: #SAT s = str(x[1]/1000) + " " + self.PolToStr(x[3]) + " / " + str(x[2]/1000) + " / " + self.FecToStr(x[4]) list.append((str(index), s)) index += 1 self.scan_transponders = ConfigSelection(choices = list, default = "0") self.scan_transponders.addNotifier(self.retune, initial_call = False)
PACKAGE_PATH = os.path.dirname(str((globals())["__file__"]))
KEYMAPPINGS = {
"green": os.path.join(PACKAGE_PATH, "keymap-green.xml"),
"help": os.path.join(PACKAGE_PATH, "keymap-help.xml"),
"text": os.path.join(PACKAGE_PATH, "keymap-text.xml"),
"red": os.path.join(PACKAGE_PATH, "keymap-red.xml"),
"yellow": os.path.join(PACKAGE_PATH, "keymap-yellow.xml")
}
config.plugins.SoftcamMenu = ConfigSubsection()
config.plugins.SoftcamMenu.MenuExt = ConfigYesNo(default=True)
config.plugins.SoftcamMenu.quickButton = ConfigEnableDisable(default=False)
config.plugins.SoftcamMenu.keymapBut = ConfigSelection(
[("green", _("Green key")),
("help", _("Help key")), ("text", _("TEXT key")), ("red", _("RED key")),
("yellow", _("YELLOW key"))],
default="help")
config.plugins.SoftcamMenu.RestartChoice = ConfigSelection(
[("1", _("restart softcam")), ("2", _("restart cardserver")),
("3", _("restart both"))],
default="1")
config.plugins.SoftcamMenu.showEcm = ConfigYesNo(default=False)
config.plugins.SoftcamMenu.CloseOnRestart = ConfigYesNo(default=True)
quick_softcam_setup = None
class ConfigAction(ConfigElement):
def __init__(self, action, *args):
ConfigElement.__init__(self)
class FastScanScreen(ConfigListScreen, Screen):
skin = """
<screen position="100,115" size="520,290" title="Fast Scan">
<widget name="config" position="10,10" size="500,250" scrollbarMode="showOnDemand" />
<widget name="introduction" position="10,265" size="500,25" font="Regular;20" halign="center" />
</screen>"""
providers = [('Canal Digitaal', (1, 900, True)),
('TV Vlaanderen', (1, 910, True)),
('TéléSAT', (0, 920, True)), ('HD Austria', (0, 950, False)),
('Fast Scan Deutschland', (0, 960, False)),
('Skylink Czech Republic', (1, 30, False)),
('Skylink Slovak Republic', (1, 31, False)),
('TéléSAT Astra3', (1, 920, True)),
('HD Austria Astra3', (1, 950, False)),
('Fast Scan Deutschland Astra3', (1, 960, False)),
('Canal Digitaal Astra 1', (0, 900, True)),
('TV Vlaanderen Astra 1', (0, 910, True))]
transponders = ((12515000, 22000000,
eDVBFrontendParametersSatellite.FEC_5_6, 192,
eDVBFrontendParametersSatellite.Polarisation_Horizontal,
eDVBFrontendParametersSatellite.Inversion_Unknown,
eDVBFrontendParametersSatellite.System_DVB_S,
eDVBFrontendParametersSatellite.Modulation_QPSK,
eDVBFrontendParametersSatellite.RollOff_alpha_0_35,
eDVBFrontendParametersSatellite.Pilot_Off),
(12070000, 27500000,
eDVBFrontendParametersSatellite.FEC_3_4, 235,
eDVBFrontendParametersSatellite.Polarisation_Horizontal,
eDVBFrontendParametersSatellite.Inversion_Unknown,
eDVBFrontendParametersSatellite.System_DVB_S,
eDVBFrontendParametersSatellite.Modulation_QPSK,
eDVBFrontendParametersSatellite.RollOff_alpha_0_35,
eDVBFrontendParametersSatellite.Pilot_Off))
def __init__(self, session, nimList):
Screen.__init__(self, session)
self.setTitle(_("Fast Scan"))
self["actions"] = ActionMap(
["SetupActions", "MenuActions"], {
"ok": self.keyGo,
"save": self.keySave,
"cancel": self.keyCancel,
"menu": self.closeRecursive,
}, -2)
providerList = list(x[0] for x in self.providers)
lastConfiguration = eval(config.misc.fastscan.last_configuration.value)
if not lastConfiguration or not tuple(
x for x in self.providers if x[0] == lastConfiguration[1]):
lastConfiguration = (nimList[0][0], providerList[0], True, True,
False, 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.scan_create_radio_bouquet = ConfigYesNo(
default=len(lastConfiguration) > 5 and lastConfiguration[5])
self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
self.scanProvider = getConfigListEntry(_("Provider"),
self.scan_provider)
self.scanHD = getConfigListEntry(_("HD list"), self.scan_hd)
self.config_autoproviders = {}
auto_providers = config.misc.fastscan.autoproviders.value.split(",")
for provider in self.providers:
self.config_autoproviders[provider[0]] = ConfigYesNo(
default=provider[0] in auto_providers)
self.list = []
ConfigListScreen.__init__(self, self.list)
self.createSetup()
self.finished_cb = None
self["introduction"] = Label(
_("Select your provider, and press OK to start the scan"))
def createSetup(self):
self.list = []
self.list.append(self.tunerEntry)
self.list.append(self.scanProvider)
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))
self.list.append(
getConfigListEntry(_("Create seperate radio userbouquet"),
self.scan_create_radio_bouquet))
self.list.append(
getConfigListEntry(_("Enable auto fast scan"),
config.misc.fastscan.auto))
if config.misc.fastscan.auto.value == "multi":
for provider in self.providers:
self.list.append(
getConfigListEntry(
_("Enable auto fast scan for %s") % provider[0],
self.config_autoproviders[provider[0]]))
self["config"].list = self.list
self["config"].l.setList(self.list)
def keyLeft(self):
ConfigListScreen.keyLeft(self)
self.createSetup()
def keyRight(self):
ConfigListScreen.keyRight(self)
self.createSetup()
def saveConfiguration(self):
config.misc.fastscan.last_configuration.value = ` (
self.scan_nims.value, self.scan_provider.value, self.scan_hd.value,
self.scan_keepnumbering.value, self.scan_keepsettings.value,
self.scan_create_radio_bouquet.value) `
auto_providers = []
for provider in self.providers:
if self.config_autoproviders[provider[0]].value:
auto_providers.append(provider[0])
config.misc.fastscan.autoproviders.value = ",".join(auto_providers)
config.misc.fastscan.save()
def keySave(self):
self.saveConfiguration()
self.close()
def keyGo(self):
self.saveConfiguration()
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]
transponderParameters.is_id = 0 #-1
transponderParameters.pls_mode = eDVBFrontendParametersSatellite.PLS_Root
transponderParameters.pls_code = 1
return transponderParameters
def startScan(self):
parameters = tuple(x[1] for x in self.providers
if x[0] == self.scan_provider.value)[0]
pid = parameters[1]
if self.scan_hd.value and parameters[2]:
pid += 1
if self.scan_nims.value:
self.session.open(
FastScanStatus,
scanTuner=int(self.scan_nims.value),
transponderParameters=self.getTransponderParameters(
parameters[0]),
scanPid=pid,
keepNumbers=self.scan_keepnumbering.value,
keepSettings=self.scan_keepsettings.value,
createRadioBouquet=self.scan_create_radio_bouquet.value,
providerName=self.scan_provider.getText())
def keyCancel(self):
self.close()
from Components.ConfigList import ConfigListScreen
from Components.NimManager import nimmanager
from Components.Label import Label
from Components.Pixmap import Pixmap
from Components.ProgressBar import ProgressBar
from Components.ServiceList import refreshServiceList
from Components.ActionMap import ActionMap
from enigma import eFastScan, eDVBFrontendParametersSatellite, eTimer
import os
config.misc.fastscan = ConfigSubsection()
config.misc.fastscan.last_configuration = ConfigText(default="()")
config.misc.fastscan.auto = ConfigSelection(default="true",
choices=[("true", _("yes")),
("false", _("no")),
("multi", _("multi"))])
config.misc.fastscan.autoproviders = ConfigText(default="()")
class FastScanStatus(Screen):
skin = """
<screen position="150,115" size="420,180" title="Fast Scan">
<widget name="frontend" pixmap="icons/scan-s.png" position="5,5" size="64,64" transparent="1" alphatest="on" />
<widget name="scan_state" position="10,120" zPosition="2" size="400,30" font="Regular;18" />
<widget name="scan_progress" position="10,155" size="400,15" pixmap="progress_big.png" borderWidth="2" borderColor="#cccccc" />
</screen>"""
def __init__(self,
session,
scanTuner=0,
from urlparse import urljoin
from Components.config import config, ConfigSelection, ConfigText, getConfigListEntry
###################################################
###################################################
# E2 GUI COMMPONENTS
###################################################
from Screens.MessageBox import MessageBox
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer.movieshdco_sortby = ConfigSelection(
default="date",
choices=[("date", _("Lastest")), ("views", _("Most viewed")),
("duree", _("Longest")), ("rate", _("Top rated")),
("random", _("Random"))])
config.plugins.iptvplayer.cartoonhd_login = ConfigText(default="",
fixed_size=False)
config.plugins.iptvplayer.cartoonhd_password = ConfigText(default="",
fixed_size=False)
def GetConfigList():
optionList = []
optionList.append(
getConfigListEntry(
_("login") + ":", config.plugins.iptvplayer.cartoonhd_login))
optionList.append(
getConfigListEntry(
def InitTimeZones():
config.timezone = ConfigSubsection()
config.timezone.area = ConfigSelection(
default=DEFAULT_AREA, choices=timezones.getTimezoneAreaList())
config.timezone.val = ConfigSelection(default=DEFAULT_ZONE,
choices=timezones.getTimezoneList())
if config.misc.firstrun.value:
proxy = geolocation.get("proxy", False)
tz = geolocation.get("timezone", None)
if proxy is True or tz is None:
msg = " - proxy in use" if proxy else ""
print(
"[Timezones] Warning: Geolocation not available%s! (area='%s', zone='%s')"
% (msg, config.timezone.area.value, config.timezone.val.value))
else:
area, zone = tz.split("/", 1)
if area != DEFAULT_AREA:
config.timezone.area.value = area
choices = timezones.getTimezoneList(area=area)
config.timezone.val.setChoices(
choices,
default=timezones.getTimezoneDefault(area, choices))
config.timezone.val.value = zone
config.timezone.save()
print(
"[Timezones] Initial time zone set by geolocation tz='%s'. (area='%s', zone='%s')"
% (tz, area, zone))
else:
if not config.timezone.area.value and config.timezone.val.value.find(
"/") == -1:
config.timezone.area.value = "Generic"
try:
tzLink = path.realpath("/etc/localtime")[20:]
msgs = []
if config.timezone.area.value == "Classic":
if config.timezone.val.value != tzLink:
msgs.append("time zone '%s' != '%s'" %
(config.timezone.val.value, tzLink))
else:
tzSplit = tzLink.find("/")
if tzSplit == -1:
tzArea = "Generic"
tzVal = tzLink
else:
tzArea = tzLink[:tzSplit]
tzVal = tzLink[tzSplit + 1:]
if config.timezone.area.value != tzArea:
msgs.append("area '%s' != '%s'" %
(config.timezone.area.value, tzArea))
if config.timezone.val.value != tzVal:
msgs.append("zone '%s' != '%s'" %
(config.timezone.val.value, tzVal))
if len(msgs):
print(
"[Timezones] Warning: Enigma2 time zone does not match system time zone (%s), setting system to Enigma2 time zone!"
% ",".join(msgs))
except (IOError, OSError):
pass
def timezoneAreaChoices(configElement):
choices = timezones.getTimezoneList(area=configElement.value)
config.timezone.val.setChoices(choices=choices,
default=timezones.getTimezoneDefault(
area=configElement.value,
choices=choices))
if config.timezone.val.saved_value and config.timezone.val.saved_value in [
x[0] for x in choices
]:
config.timezone.val.value = config.timezone.val.saved_value
def timezoneNotifier(configElement):
timezones.activateTimezone(configElement.value,
config.timezone.area.value)
config.timezone.area.addNotifier(timezoneAreaChoices,
initial_call=False,
immediate_feedback=True)
config.timezone.val.addNotifier(timezoneNotifier,
initial_call=True,
immediate_feedback=True)
config.timezone.val.callNotifiersOnSaveAndCancel = True
def createConfig(self, frontendData):
satlist = nimmanager.getRotorSatListForNim(self.feid)
orb_pos = self.fe_data.get("orbital_position", None)
orb_pos_str = str(orb_pos)
self.tuning = ConfigSubsection()
self.tuning.type = ConfigSelection(
default = "manual_transponder",
choices = { "manual_transponder" : _("Manual transponder"),
"predefined_transponder" : _("Predefined transponder") } )
self.tuning.sat = ConfigSatlist(list = satlist)
if orb_pos is not None:
for sat in satlist:
if sat[0] == orb_pos and self.tuning.sat.value != orb_pos_str:
self.tuning.sat.value = orb_pos_str
self.updateTransponders()
defaultSat = {
"orbpos": 192,
"system": eDVBFrontendParametersSatellite.System_DVB_S,
"frequency": 11836,
"inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
"symbolrate": 27500,
"polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
"fec": eDVBFrontendParametersSatellite.FEC_Auto,
"fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
"modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
if frontendData is not None:
ttype = frontendData.get("tuner_type", "UNKNOWN")
defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
else:
defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
self.scan_sat = ConfigSubsection()
self.scan_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"),
(eDVBFrontendParametersSatellite.Modulation_16APSK, "16APSK"),
(eDVBFrontendParametersSatellite.Modulation_32APSK, "32APSK")])
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"))])
def createConfig(self, *args): hw_type = HardwareInfo().get_device_name() has_hdmi = HardwareInfo().has_hdmi() lst = [] config.av.videorate = ConfigSelection(choices = self.rates)
def createSetup(self):
self.styles = [("<default>", _("<Default movie location>")),
("<current>", _("<Current movielist location>")),
("<timer>", _("<Last timer location>"))]
styles_keys = [x[0] for x in self.styles]
tmp = config.movielist.videodirs.value
default = config.usage.default_path.value
if default not in tmp:
tmp = tmp[:]
tmp.append(default)
# print "DefaultPath: ", default, tmp
self.default_dirname = ConfigSelection(default=default, choices=tmp)
tmp = config.movielist.videodirs.value
default = config.usage.timer_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
# print "TimerPath: ", default, tmp
self.timer_dirname = ConfigSelection(default=default,
choices=self.styles + tmp)
tmp = config.movielist.videodirs.value
default = config.usage.instantrec_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
# print "InstantrecPath: ", default, tmp
self.instantrec_dirname = ConfigSelection(default=default,
choices=self.styles + tmp)
self.default_dirname.addNotifier(self.checkReadWriteDir,
initial_call=False,
immediate_feedback=False)
self.timer_dirname.addNotifier(self.checkReadWriteDir,
initial_call=False,
immediate_feedback=False)
self.instantrec_dirname.addNotifier(self.checkReadWriteDir,
initial_call=False,
immediate_feedback=False)
list = []
if config.usage.setup_level.index >= 2:
self.default_entry = getConfigListEntry(
_("Default movie location"), self.default_dirname,
_("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.default_entry)
self.timer_entry = getConfigListEntry(
_("Timer recording location"), self.timer_dirname,
_("Set the default location for your timers. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.timer_entry)
self.instantrec_entry = getConfigListEntry(
_("Instant recording location"), self.instantrec_dirname,
_("Set the default location for your instant recordings. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.instantrec_entry)
else:
self.default_entry = getConfigListEntry(
_("Movie location"), self.default_dirname,
_("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.default_entry)
self.refill(list)
self["config"].setList(list)
if config.usage.sort_settings.value:
self["config"].list.sort()
p), lambda: True), None))
return list
def showMovies(self):
pass
###################################################
config.plugins.Podcast = ConfigSubsection()
config.plugins.Podcast.buffer = ConfigYesNo(default=True)
config.plugins.Podcast.bufferDevice = ConfigText(default="/media/hdd/",
fixed_size=False)
config.plugins.Podcast.keepStored = ConfigSelection(choices={
"delete": _("delete"),
"keep": _("keep on device"),
"ask": _("ask me")
},
default="delete")
###################################################
def encodeUrl(url):
url = url.replace("&", "&")
url = url.replace("<", "<")
url = url.replace(">", ">")
url = url.replace("'", "'")
url = url.replace(""", '"')
url = url.replace("*", "*")
url = url.replace("|", "|")
url = url.replace("'", "'")
from Components.config import config, configfile, ConfigSubsection, getConfigListEntry, ConfigSelection
from Components.ConfigList import ConfigListScreen
from enigma import iPlayableService, eServiceCenter, eTimer, eActionMap
from Components.ServiceEventTracker import ServiceEventTracker
from Components.ServiceList import ServiceList
from Screens.InfoBar import InfoBar
import Screens.Standby
from time import localtime, time
from Tools.Directories import fileExists
import Screens.Standby
config.plugins.SEG = ConfigSubsection()
config.plugins.SEG.showClock = ConfigSelection(
default="True_Switch",
choices=[("False", _("Channelnumber in Standby off")),
("True", _("Channelnumber in Standby Clock")),
("True_Switch", _("Channelnumber/Clock in Standby Clock")),
("True_All", _("Clock always")), ("Off", _("Always off"))])
config.plugins.SEG.showCHnumber = ConfigSelection(default="15",
choices=[("15", _("15 sec")),
("30", _("30 sec")),
("45", _("45 sec")),
("60", _("60 sec"))
])
config.plugins.SEG.timeMode = ConfigSelection(default="24h",
choices=[("12h"), ("24h")])
def display_write(text):
open("/dev/dbox/oled0", "w").write(text)
class RecordingSettings(Screen, ConfigListScreen):
def removeNotifier(self):
config.usage.setup_level.notifiers.remove(self.levelChanged)
def levelChanged(self, configElement):
list = []
self.refill(list)
self["config"].setList(list)
def refill(self, list):
xmldata = setupdom().getroot()
for x in xmldata.findall("setup"):
if x.get("key") != self.setup:
continue
self.addItems(list, x)
self.setup_title = x.get("title", "").encode("UTF-8")
self.seperation = int(x.get('separation', '0'))
def __init__(self, session, menu_path=""):
Screen.__init__(self, session)
self.skinName = "Setup"
self.menu_path = menu_path
self["menu_path_compressed"] = StaticText()
self['footnote'] = Label()
self["key_red"] = StaticText(_("Cancel"))
self["key_green"] = StaticText(_("Save"))
self["description"] = Label("")
self.onChangedEntry = []
self.setup = "recording"
list = []
ConfigListScreen.__init__(self,
list,
session=session,
on_change=self.changedEntry)
self.createSetup()
self["setupActions"] = ActionMap(
["SetupActions", "ColorActions", "MenuActions"], {
"green": self.keySave,
"red": self.keyCancel,
"cancel": self.keyCancel,
"ok": self.ok,
"menu": self.closeRecursive,
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def checkReadWriteDir(self, configele):
# print "checkReadWrite: ", configele.value
if configele.value in [x[0] for x in self.styles] or fileExists(
configele.value, "w"):
configele.last_value = configele.value
return True
else:
dir = configele.value
configele.value = configele.last_value
self.session.open(
MessageBox,
_("The directory %s is not writable.\nMake sure you select a writable directory instead."
) % dir,
type=MessageBox.TYPE_ERROR)
return False
def createSetup(self):
self.styles = [("<default>", _("<Default movie location>")),
("<current>", _("<Current movielist location>")),
("<timer>", _("<Last timer location>"))]
styles_keys = [x[0] for x in self.styles]
tmp = config.movielist.videodirs.value
default = config.usage.default_path.value
if default not in tmp:
tmp = tmp[:]
tmp.append(default)
# print "DefaultPath: ", default, tmp
self.default_dirname = ConfigSelection(default=default, choices=tmp)
tmp = config.movielist.videodirs.value
default = config.usage.timer_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
# print "TimerPath: ", default, tmp
self.timer_dirname = ConfigSelection(default=default,
choices=self.styles + tmp)
tmp = config.movielist.videodirs.value
default = config.usage.instantrec_path.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
# print "InstantrecPath: ", default, tmp
self.instantrec_dirname = ConfigSelection(default=default,
choices=self.styles + tmp)
self.default_dirname.addNotifier(self.checkReadWriteDir,
initial_call=False,
immediate_feedback=False)
self.timer_dirname.addNotifier(self.checkReadWriteDir,
initial_call=False,
immediate_feedback=False)
self.instantrec_dirname.addNotifier(self.checkReadWriteDir,
initial_call=False,
immediate_feedback=False)
list = []
if config.usage.setup_level.index >= 2:
self.default_entry = getConfigListEntry(
_("Default movie location"), self.default_dirname,
_("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.default_entry)
self.timer_entry = getConfigListEntry(
_("Timer recording location"), self.timer_dirname,
_("Set the default location for your timers. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.timer_entry)
self.instantrec_entry = getConfigListEntry(
_("Instant recording location"), self.instantrec_dirname,
_("Set the default location for your instant recordings. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.instantrec_entry)
else:
self.default_entry = getConfigListEntry(
_("Movie location"), self.default_dirname,
_("Set the default location for your recordings. Press 'OK' to add new locations, select left/right to select an existing location."
))
list.append(self.default_entry)
self.refill(list)
self["config"].setList(list)
if config.usage.sort_settings.value:
self["config"].list.sort()
def layoutFinished(self):
if config.usage.show_menupath.value == 'large' and self.menu_path:
title = self.menu_path + _(self.setup_title)
self["menu_path_compressed"].setText("")
elif config.usage.show_menupath.value == 'small':
title = _(self.setup_title)
self["menu_path_compressed"].setText(
self.menu_path + " >" if not self.menu_path.endswith(' / ')
else self.menu_path[:-3] + " >" or "")
else:
title = _(self.setup_title)
self["menu_path_compressed"].setText("")
self.setup_title = title
self.setTitle(title)
def changedEntry(self):
if self["config"].getCurrent()[0] in (_("Default movie location"),
_("Timer record location"),
_("Instant record location"),
_("Movie location")):
self.checkReadWriteDir(self["config"].getCurrent()[1])
def ok(self):
currentry = self["config"].getCurrent()
self.lastvideodirs = config.movielist.videodirs.value
self.lasttimeshiftdirs = config.usage.allowed_timeshift_paths.value
if config.usage.setup_level.index >= 2:
txt = _("Default movie location")
else:
txt = _("Movie location")
if currentry == self.default_entry:
self.entrydirname = self.default_dirname
self.session.openWithCallback(
self.dirnameSelected, MovieLocationBox, txt,
preferredPath(self.default_dirname.value))
elif currentry == self.timer_entry:
self.entrydirname = self.timer_dirname
self.session.openWithCallback(
self.dirnameSelected, MovieLocationBox,
_("New timers location"),
preferredPath(self.timer_dirname.value))
elif currentry == self.instantrec_entry:
self.entrydirname = self.instantrec_dirname
self.session.openWithCallback(
self.dirnameSelected, MovieLocationBox,
_("Instant recordings location"),
preferredPath(self.instantrec_dirname.value))
def dirnameSelected(self, res):
if res is not None:
self.entrydirname.value = res
if config.movielist.videodirs.value != self.lastvideodirs:
styles_keys = [x[0] for x in self.styles]
tmp = config.movielist.videodirs.value
default = self.default_dirname.value
if default not in tmp:
tmp = tmp[:]
tmp.append(default)
self.default_dirname.setChoices(tmp, default=default)
tmp = config.movielist.videodirs.value
default = self.timer_dirname.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
self.timer_dirname.setChoices(self.styles + tmp,
default=default)
tmp = config.movielist.videodirs.value
default = self.instantrec_dirname.value
if default not in tmp and default not in styles_keys:
tmp = tmp[:]
tmp.append(default)
self.instantrec_dirname.setChoices(self.styles + tmp,
default=default)
self.entrydirname.value = res
if self.entrydirname.last_value != res:
self.checkReadWriteDir(self.entrydirname)
def saveAll(self):
currentry = self["config"].getCurrent()
config.usage.default_path.value = self.default_dirname.value
config.usage.timer_path.value = self.timer_dirname.value
config.usage.instantrec_path.value = self.instantrec_dirname.value
config.usage.default_path.save()
config.usage.timer_path.save()
config.usage.instantrec_path.save()
ConfigListScreen.saveAll(self)
def createSummary(self):
return SetupSummary
def addItems(self, list, parentNode):
for x in parentNode:
if not x.tag:
continue
if x.tag == 'item':
item_level = int(x.get("level", 0))
if not self.levelChanged in config.usage.setup_level.notifiers:
config.usage.setup_level.notifiers.append(
self.levelChanged)
self.onClose.append(self.removeNotifier)
if item_level > config.usage.setup_level.index:
continue
requires = x.get("requires")
if requires and requires.startswith('config.'):
item = eval(requires or "")
if item.value and not item.value == "0":
SystemInfo[requires] = True
else:
SystemInfo[requires] = False
if requires and not SystemInfo.get(requires, False):
continue
item_text = _(x.get("text", "??").encode("UTF-8"))
item_description = _(x.get("description", " ").encode("UTF-8"))
b = eval(x.text or "")
if b == "":
continue
#add to configlist
item = b
# the first b is the item itself, ignored by the configList.
# the second one is converted to string.
if not isinstance(item, ConfigNothing):
list.append((item_text, item, item_description))
# FOREIGN import
###################################################
from Components.config import config, ConfigSelection, ConfigYesNo, getConfigListEntry
import re
import urllib
import random
try:
import simplejson as json
except Exception:
import json
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer.playpuls_defaultformat = ConfigSelection(
default="999999",
choices=[("0", "najgorsza"), ("600", "średnia"), ("800", "dobra"),
("999999", "najlepsza")])
config.plugins.iptvplayer.playpuls_usedf = ConfigYesNo(default=False)
config.plugins.iptvplayer.playpuls_defaultproto = ConfigSelection(
default="hls", choices=[("rtmp", "dash (mpd)"), ("hls", "hls (m3u8)")])
config.plugins.iptvplayer.playpuls_proxy = ConfigYesNo(default=False)
def GetConfigList():
optionList = []
optionList.append(
getConfigListEntry("Preferowany protokół:",
config.plugins.iptvplayer.playpuls_defaultproto))
optionList.append(
getConfigListEntry("Domyślny jakość video:",
config.plugins.iptvplayer.playpuls_defaultformat))
"EncryptedChannelSetup", "%s%s" %
(resolveFilename(SCOPE_PLUGINS), "Extensions/EncryptedChannel/locale/"))
def _(txt):
t = gettext.dgettext("EncryptedChannelSetup", txt)
if t == txt:
t = gettext.gettext(txt)
return t
pluginversion = "1.3"
config.plugins.EncryptedChannel = ConfigSubsection()
config.plugins.EncryptedChannel.enabled = ConfigYesNo(default=False)
config.plugins.EncryptedChannel.mesmode = ConfigSelection(
default="2",
choices=[("1", _("Encrypted channel")), ("2", _("Encoded channel")),
("3", _("Encrypted channel!")), ("4", _("Encoded channel!"))])
config.plugins.EncryptedChannel.timemode = ConfigSelection(
default="1",
choices=[("1", _("1 second")), ("2", _("2 seconds")),
("3", _("3 seconds")), ("4", _("4 seconds")),
("5", _("5 seconds"))])
config.plugins.EncryptedChannel.minsnrmode = ConfigSelection(default="34",
choices=[
("5", "5"),
("6", "6"),
("7", "7"),
("8", "8"),
("9", "9"),
("10", "10"),
("12", "12"),
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer = ConfigSubsection()
from Plugins.Extensions.IPTVPlayer.components.configextmovieplayer import ConfigExtMoviePlayer
config.plugins.iptvplayer.hlsdl_download = ConfigYesNo(default=True)
config.plugins.iptvplayer.set_curr_title = ConfigYesNo(default=False)
config.plugins.iptvplayer.curr_title_file = ConfigText(default="", fixed_size=False)
config.plugins.iptvplayer.showcover = ConfigYesNo(default=True)
config.plugins.iptvplayer.deleteIcons = ConfigSelection(default="3", choices=[("0", _("after closing")), ("1", _("after day")), ("3", _("after three days")), ("7", _("after a week"))])
config.plugins.iptvplayer.allowedcoverformats = ConfigSelection(default="jpeg,png", choices=[("jpeg,png,gif", _("jpeg,png,gif")), ("jpeg,png", _("jpeg,png")), ("jpeg", _("jpeg")), ("all", _("all"))])
config.plugins.iptvplayer.showinextensions = ConfigYesNo(default=True)
config.plugins.iptvplayer.showinMainMenu = ConfigYesNo(default=False)
config.plugins.iptvplayer.ListaGraficzna = ConfigYesNo(default=True)
config.plugins.iptvplayer.group_hosts = ConfigYesNo(default=True)
config.plugins.iptvplayer.NaszaSciezka = ConfigDirectory(default="/hdd/movie/") #, fixed_size = False)
config.plugins.iptvplayer.bufferingPath = ConfigDirectory(default=config.plugins.iptvplayer.NaszaSciezka.value) #, fixed_size = False)
config.plugins.iptvplayer.buforowanie = ConfigYesNo(default=False)
config.plugins.iptvplayer.buforowanie_m3u8 = ConfigYesNo(default=True)
config.plugins.iptvplayer.buforowanie_rtmp = ConfigYesNo(default=False)
config.plugins.iptvplayer.requestedBuffSize = ConfigInteger(2, (1, 120))
config.plugins.iptvplayer.requestedAudioBuffSize = ConfigInteger(256, (1, 10240))
config.plugins.iptvplayer.IPTVDMRunAtStart = ConfigYesNo(default=False)
config.plugins.iptvplayer.IPTVDMShowAfterAdd = ConfigYesNo(default=True)
profile("config.misc")
config.misc.boxtype = ConfigText(default=boxtype)
config.misc.blackradiopic = ConfigText(
default=resolveFilename(SCOPE_ACTIVE_SKIN, "black.mvi"))
radiopic = resolveFilename(SCOPE_ACTIVE_SKIN, "radio.mvi")
if os.path.exists(resolveFilename(SCOPE_CONFIG, "radio.mvi")):
radiopic = resolveFilename(SCOPE_CONFIG, "radio.mvi")
config.misc.radiopic = ConfigText(default=radiopic)
#config.misc.isNextRecordTimerAfterEventActionAuto = ConfigYesNo(default=False)
#config.misc.isNextPowerTimerAfterEventActionAuto = ConfigYesNo(default=False)
config.misc.nextWakeup = ConfigText(
default="-1,-1,-1,0,0,-1,0"
) #last shutdown time, wakeup time, timer begins, set by (0=rectimer,1=zaptimer, 2=powertimer or 3=plugin), go in standby, next rectimer, force rectimer
config.misc.SyncTimeUsing = ConfigSelection(default="0",
choices=[("0",
_("Transponder Time")),
("1", _("NTP"))])
config.misc.NTPserver = ConfigText(default='pool.ntp.org', fixed_size=False)
config.misc.startCounter = ConfigInteger(default=0) # number of e2 starts...
config.misc.standbyCounter = NoSave(
ConfigInteger(default=0)) # number of standby
config.misc.DeepStandby = NoSave(
ConfigYesNo(default=False)) # detect deepstandby
#demo code for use of standby enter leave callbacks
#def leaveStandby():
# print "!!!!!!!!!!!!!!!!!leave standby"
#def standbyCountChanged(configelement):
# print "!!!!!!!!!!!!!!!!!enter standby num", configelement.value
# Config
from Components.config import config, ConfigSubsection, ConfigEnableDisable, \
ConfigNumber, ConfigSelection, ConfigYesNo
# Plugin
from Components.PluginComponent import plugins
from Plugins.Plugin import PluginDescriptor
# Initialize Configuration
config.plugins.autotimer = ConfigSubsection()
config.plugins.autotimer.autopoll = ConfigEnableDisable(default=False)
config.plugins.autotimer.interval = ConfigNumber(default=3)
config.plugins.autotimer.refresh = ConfigSelection(choices=[
("none", _("None")),
("auto", _("Only AutoTimers created during this session")),
("all", _("All non-repeating timers"))
],
default="none")
config.plugins.autotimer.try_guessing = ConfigEnableDisable(default=True)
config.plugins.autotimer.editor = ConfigSelection(choices=[
("plain", _("Classic")), ("wizard", _("Wizard"))
],
default="wizard")
config.plugins.autotimer.addsimilar_on_conflict = ConfigEnableDisable(
default=False)
config.plugins.autotimer.disabled_on_conflict = ConfigEnableDisable(
default=False)
config.plugins.autotimer.show_in_extensionsmenu = ConfigYesNo(default=False)
config.plugins.autotimer.fastscan = ConfigYesNo(default=False)
config.plugins.autotimer.notifconflict = ConfigYesNo(default=True)
config.plugins.autotimer.notifsimilar = ConfigYesNo(default=True)
from Components.ActionMap import ActionMap
from Components.Sources.StaticText import StaticText
from Components.FileList import FileList
from Components.AVSwitch import AVSwitch
from Components.Sources.List import List
from Components.ConfigList import ConfigListScreen
from Components.config import config, ConfigSubsection, ConfigInteger, ConfigSelection, ConfigText, ConfigYesNo, getConfigListEntry
import skin
def getScale():
return AVSwitch().getFramebufferScale()
config.pic = ConfigSubsection()
config.pic.framesize = ConfigInteger(default=30, limits=(5, 99))
config.pic.slidetime = ConfigInteger(default=10, limits=(1, 60))
config.pic.resize = ConfigSelection(default="1", choices = [("0", _("simple")), ("1", _("better"))])
config.pic.cache = ConfigYesNo(default=True)
config.pic.lastDir = ConfigText(default=resolveFilename(SCOPE_MEDIA))
config.pic.infoline = ConfigYesNo(default=True)
config.pic.loop = ConfigYesNo(default=True)
config.pic.bgcolor = ConfigSelection(default="#00000000", choices = [("#00000000", _("black")), ("#009eb9ff", _("blue")), ("#00ff5a51", _("red")), ("#00ffe875", _("yellow")), ("#0038FF48", _("green"))])
config.pic.textcolor = ConfigSelection(default="#0038FF48", choices = [("#00000000", _("black")), ("#009eb9ff", _("blue")), ("#00ff5a51", _("red")), ("#00ffe875", _("yellow")), ("#0038FF48", _("green"))])
class picshow(Screen):
skin = """
<screen name="picshow" position="center,center" size="560,440" title="Picture player" >
<ePixmap pixmap="buttons/red.png" position="0,0" size="140,40" alphatest="on" />
<ePixmap pixmap="buttons/green.png" position="140,0" size="140,40" alphatest="on" />
<ePixmap pixmap="buttons/yellow.png" position="280,0" size="140,40" alphatest="on" />
<widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" />
<widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
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.value
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.value
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.value != _(
'no cam') or config.softcam.actCam.value != _(
"no CAM 1 active"):
self.list.append(
getConfigListEntry(_("Select Cam 2"), self.cam2sel))
if self.cam2sel.value != _('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.value == "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.value == self.cam2sel.value:
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.value == "0":
self.Stopcam()
self.camIndex = self.cam1sel.getIndex() - 1
self.cam2Index = self.cam2sel.getIndex() - 1
if self.camIndex >= 0:
actcam = self.cam1sel.value
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.value == "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.value)
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.value)
self["key_green"].setText(_("ReStart"))
except:
pass
def waitTime(self, ret):
if self.cam2Index >= 0:
if config.softcam.waittime.value == '0':
self.startcam2(None)
else:
self.session.openWithCallback(
self.startcam2,
MessageBox,
_("Waiting..."),
MessageBox.TYPE_WARNING,
timeout=int(config.softcam.waittime.value),
simple=True)
def doNothing(self, ret):
pass
def startcam2(self, ret):
camIndex = self.cam2Index
if camIndex >= 0:
actcam = self.cam2sel.value
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 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
# distributed other than under the conditions noted above.
#
from Plugins.Plugin import PluginDescriptor
from Screens.Screen import Screen
from Components.ActionMap import ActionMap
from Components.Sources.StaticText import StaticText
from Components.config import config, ConfigSubsection, ConfigSelection, getConfigListEntry
from Components.ConfigList import ConfigListScreen
from enigma import eTimer
from time import time, strftime, localtime
from timer import TimerEntry
config.plugins.automatictimerlistcleanup = ConfigSubsection()
config.plugins.automatictimerlistcleanup.type = ConfigSelection(
default="-1",
choices=[("-1", _("disabled")), ("0", _("immediately after recording")),
("1", _("older than 1 day")), ("3", _("older than 3 days")),
("7", _("older than 1 week")), ("14", _("older than 2 weeks")),
("28", _("older than 4 weeks")), ("42", _("older than 6 weeks"))])
class AutomaticTimerlistCleanUpSetup(Screen, ConfigListScreen): # config
skin = """
<screen position="center,center" size="620,200" title="%s" >
<ePixmap pixmap="skin_default/buttons/red.png" position="10,5" size="200,40" alphatest="on" />
<ePixmap pixmap="skin_default/buttons/green.png" position="210,5" size="200,40" alphatest="on" />
<widget source="key_red" render="Label" position="10,5" size="200,40" zPosition="1" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" shadowColor="black" shadowOffset="-2,-2" />
<widget source="key_green" render="Label" position="210,5" size="200,40" zPosition="1" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" shadowColor="black" shadowOffset="-2,-2" />
<eLabel position="10,50" size="600,1" backgroundColor="grey" />
<widget name="config" position="10,60" size="600,120" enableWrapAround="1" scrollbarMode="showOnDemand" />
</screen>""" % _("Automatic Timerlist Cleanup Setup")
# Tools
from Tools.Directories import pathExists, fileExists
#Plugins
from Plugins.Plugin import PluginDescriptor
from mixes import Mixes
mixes = Mixes().read()
choices = sorted([(mixes[x]["key"], mixes[x]["name"]) for x in mixes],
key=lambda listItem: listItem[1])
default_mix = "dsayers_vmuk_into_skyuk"
ABMpath = "/usr/lib/enigma2/python/Plugins/SystemPlugins/AutoBouquetsMaker/custom/"
config.plugins.abmImporter = ConfigSubsection()
config.plugins.abmImporter.mix = ConfigSelection(default=default_mix,
choices=choices)
config.plugins.abmImporter.enableImporter = ConfigYesNo(default=False)
config.plugins.abmImporter.leadTime = ConfigSelection(
default="5",
choices=[("1", _("1 minute")), ("2", _("2 minutes")),
("3", _("3 minutes")), ("5", _("5 minutes")),
("10", _("10 minutes")), ("20", _("20 minutes")),
("30", _("30 minutes"))])
class ABMCustomMixImporterScreen(Setup):
skin = """
<screen position="340,70" size="600,620">
<widget source="key_red" render="Label" position="0,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" backgroundColor="#9f1313" font="Regular;18" transparent="1"/>
<widget source="key_green" render="Label" position="150,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" backgroundColor="#1f771f" font="Regular;18" transparent="1"/>
<widget source="key_yellow" render="Label" position="300,0" size="140,40" valign="center" halign="center" zPosition="4" foregroundColor="white" backgroundColor="#a08500" font="Regular;18" transparent="1"/>
class SetupFallbacktuner(ConfigListScreen, Screen):
def __init__(self, session):
Screen.__init__(self, session)
Screen.setTitle(self, _("Fallback tuner setup"))
self.skinName = ["FallbackTunerSetup", "Setup"]
self.onChangedEntry = []
self.session = session
ConfigListScreen.__init__(self, [], session = session, on_change = self.changedEntry)
self["actions2"] = ActionMap(["SetupActions"],
{
"ok": self.run,
"menu": self.keyCancel,
"cancel": self.keyCancel,
"save": self.run,
}, -2)
self["key_red"] = StaticText(_("Exit"))
self["key_green"] = StaticText(_("Save"))
self["description"] = Label("")
self["VKeyIcon"] = Boolean(False)
self["HelpWindow"] = Pixmap()
self["HelpWindow"].hide()
self.force_update_list = False
self.createConfig()
self.createSetup()
self.remote_fallback_prev = config.usage.remote_fallback_import.value
self["config"].onSelectionChanged.append(self.selectionChanged)
self.selectionChanged()
def createConfig(self):
def set_avahiselect_seperate(configElement):
if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value != config.usage.remote_fallback.value:
peerDefault_sepearate = config.usage.remote_fallback_import_url.value
else:
peerDefault_sepearate = "same"
config.usage.remote_fallback_import_url.value = config.usage.remote_fallback.value
self.seperateBoxes = [("same", _("Same as stream"))] + self.peerStreamingBoxes
if configElement.value not in ("url", "ip") and configElement.value in self.seperateBoxes:
self.seperateBoxes.remove(configElement.value)
self.avahiselect_seperate = ConfigSelection(default=peerDefault_sepearate, choices=self.seperateBoxes)
self.peerStreamingBoxes = getPeerStreamingBoxes() + [("ip", _("Enter IP address")), ("url", _("Enter URL"))]
peerDefault = peerDefault_sepearate = None
if config.usage.remote_fallback.value:
peerDefault = peerDefault_sepearate = config.usage.remote_fallback.value
if config.usage.remote_fallback.value and config.usage.remote_fallback.value not in self.peerStreamingBoxes:
self.peerStreamingBoxes = [config.usage.remote_fallback.value] + self.peerStreamingBoxes
if config.usage.remote_fallback_import_url.value and config.usage.remote_fallback_import_url.value not in self.peerStreamingBoxes:
self.peerStreamingBoxes = [config.usage.remote_fallback_import_url.value] + self.peerStreamingBoxes
self.avahiselect = ConfigSelection(default=peerDefault, choices=self.peerStreamingBoxes)
self.avahiselect.addNotifier(set_avahiselect_seperate)
try:
ipDefault = [int(x) for x in config.usage.remote_fallback.value.split(":")[1][2:].split(".")]
portDefault = int( config.usage.remote_fallback.value.split(":")[2])
except:
ipDefault = [0, 0, 0, 0]
portDefault = 8001
self.ip = ConfigIP(default=ipDefault, auto_jump=True)
self.port = ConfigInteger(default=portDefault, limits=(1,65535))
self.ip_seperate = ConfigIP( default=ipDefault, auto_jump=True)
self.port_seperate = ConfigInteger(default=portDefault, limits=(1,65535))
def createSetup(self):
self.list = []
self.list.append(getConfigListEntry(_("Enable fallback remote receiver"),
config.usage.remote_fallback_enabled,
_("Enable remote enigma2 receiver to be tried to tune into services that cannot be tuned into locally (e.g. tuner is occupied or service type is unavailable on the local tuner. Specify complete URL including http:// and port number (normally ...:8001), e.g. http://second_box:8001.")))
self.list.append(getConfigListEntry(_("Import from remote receiver URL"),
config.usage.remote_fallback_import,
_("Import channels and/or EPG from remote receiver URL when receiver is booted")))
if config.usage.remote_fallback_enabled.value or config.usage.remote_fallback_import.value:
self.list.append(getConfigListEntry(_("Enable import timer from fallback tuner"),
config.usage.remote_fallback_external_timer,
_("When enabled the timer from the fallback tuner is imported")))
self.list.append(getConfigListEntry(_("Fallback remote receiver"),
self.avahiselect,
_("Destination of fallback remote receiver")))
if self.avahiselect.value == "ip":
self.list.append(getConfigListEntry(" %s" % _("Fallback remote receiver IP"),
self.ip,
_("IP of fallback remote receiver")))
self.list.append(getConfigListEntry(" %s" % _("Fallback remote receiver Port"),
self.port,
_("Port of fallback remote receiver")))
if self.avahiselect.value == "url":
self.list.append(getConfigListEntry(" %s" % _("Fallback remote receiver URL"),
config.usage.remote_fallback,
_("URL of fallback remote receiver")))
if config.usage.remote_fallback_enabled.value and config.usage.remote_fallback_import.value and config.usage.remote_fallback.value:
self.list.append(getConfigListEntry(_("Import remote receiver URL"),
self.avahiselect_seperate,
_("URL of fallback remote receiver")))
if self.avahiselect_seperate.value == "ip":
self.list.append(getConfigListEntry(" %s" % _("Fallback remote receiver IP"),
self.ip_seperate,
_("IP of fallback remote receiver")))
self.list.append(getConfigListEntry(" %s" % _("Fallback remote receiver Port"),
self.port_seperate,
_("Port of fallback remote receiver")))
if self.avahiselect_seperate.value == "url":
self.list.append(getConfigListEntry(" %s" % _("Fallback remote receiver URL"),
config.usage.remote_fallback_import_url,
_("URL of fallback remote receiver")))
if config.usage.remote_fallback_enabled.value and config.usage.remote_fallback_import.value:
self.list.append(getConfigListEntry(_("Also import at reboot/restart enigma2"),
config.usage.remote_fallback_import_restart,
_("Import channels and/or EPG from remote receiver URL when receiver or enigma2 is restarted")))
self.list.append(getConfigListEntry(_("Also import when box is leaving standby"),
config.usage.remote_fallback_import_standby,
_("Import channels and/or EPG from remote receiver URL also when the receiver is getting out of standby")))
self.list.append(getConfigListEntry(_("Also import from the extension menu"),
config.usage.remote_fallback_extension_menu,
_("Make it possible to manually initiate the channels import and/or EPG via the extension menu")))
self.list.append(getConfigListEntry(_("Show notification when import channels was successful"),
config.usage.remote_fallback_ok,
_("Show notification when import channels and/or EPG from remote receiver URL is completed")))
self.list.append(getConfigListEntry(_("Show notification when import channels was not successful"),
config.usage.remote_fallback_nok,
_("Show notification when import channels and/or EPG from remote receiver URL did not complete")))
self.list.append(getConfigListEntry(_("Customize OpenWebIF settings for fallback tuner"),
config.usage.remote_fallback_openwebif_customize,
_("When enabled you can customize the OpenWebIf settings for the fallback tuner")))
if config.usage.remote_fallback_openwebif_customize.value:
self.list.append(getConfigListEntry(" %s" % _("User ID"),
config.usage.remote_fallback_openwebif_userid,
_("Set the User ID of the OpenWebif from your fallback tuner")))
self.list.append(getConfigListEntry(" %s" % _("Password"),
config.usage.remote_fallback_openwebif_password,
_("Set the password of the OpenWebif from your fallback tuner")))
self.list.append(getConfigListEntry(" %s" % _("Port"),
config.usage.remote_fallback_openwebif_port,
" %s" % _("Set the port of the OpenWebif from your fallback tuner")))
self["config"].list = self.list
self["config"].l.setList(self.list)
def selectionChanged(self):
if self.force_update_list:
self["config"].onSelectionChanged.remove(self.selectionChanged)
self.createSetup()
self["config"].onSelectionChanged.append(self.selectionChanged)
self.force_update_list = False
if not (isinstance(self["config"].getCurrent()[1], ConfigBoolean) or isinstance(self["config"].getCurrent()[1], ConfigSelection)):
self.force_update_list = True
self["description"].setText(self.getCurrentDescription())
def changedEntry(self):
if isinstance(self["config"].getCurrent()[1], ConfigBoolean) or isinstance(self["config"].getCurrent()[1], ConfigSelection):
self.createSetup()
def run(self):
if self.avahiselect.value == "ip":
config.usage.remote_fallback.value = "http://%d.%d.%d.%d:%d" % (tuple(self.ip.value) + (self.port.value,))
elif self.avahiselect.value != "url":
config.usage.remote_fallback.value = self.avahiselect.value
if self.avahiselect_seperate.value == "ip":
config.usage.remote_fallback_import_url.value = "http://%d.%d.%d.%d:%d" % (tuple(self.ip_seperate.value) + (self.port_seperate.value,))
elif self.avahiselect_seperate.value == "same":
config.usage.remote_fallback_import_url.value = ""
elif self.avahiselect_seperate.value != "url":
config.usage.remote_fallback_import_url.value = self.avahiselect_seperate.value
if config.usage.remote_fallback_import_url.value == config.usage.remote_fallback.value:
config.usage.remote_fallback_import_url.value = ""
config.usage.remote_fallback_enabled.save()
config.usage.remote_fallback_import.save()
config.usage.remote_fallback_import_url.save()
config.usage.remote_fallback_import_restart.save()
config.usage.remote_fallback_import_standby.save()
config.usage.remote_fallback_extension_menu.save()
config.usage.remote_fallback_ok.save()
config.usage.remote_fallback_nok.save()
config.usage.remote_fallback.save()
config.usage.remote_fallback_external_timer.save()
config.usage.remote_fallback_openwebif_customize.save()
config.usage.remote_fallback_openwebif_userid.save()
config.usage.remote_fallback_openwebif_password.save()
config.usage.remote_fallback_openwebif_port.save()
configfile.save()
if not self.remote_fallback_prev and config.usage.remote_fallback_import.value:
ImportChannels()
self.close(False)
from enigma import iPlayableService, eServiceCenter, eTimer, eActionMap, eDBoxLCD
from Components.ServiceEventTracker import ServiceEventTracker
from Screens.InfoBar import InfoBar
from time import localtime, time
import Screens.Standby
from Tools.HardwareInfo import HardwareInfo
use_oled = False
if HardwareInfo().get_device_model() in ("formuler3", "formuler4", "s1", "h3",
"h4", "h5", "lc"):
use_oled = True
config.plugins.VFD_ini = ConfigSubsection()
config.plugins.VFD_ini.showClock = ConfigSelection(
default="True_Switch",
choices=[("False", _("Channelnumber in Standby off")),
("True", _("Channelnumber in Standby Clock")),
("True_Switch", _("Channelnumber/Clock in Standby Clock")),
("True_All", _("Clock always")), ("Off", _("Always off"))])
config.plugins.VFD_ini.timeMode = ConfigSelection(default="24h",
choices=[("12h", _("12h")),
("24h", _("24h"))])
config.plugins.VFD_ini.recDisplay = ConfigSelection(default="False",
choices=[
("True", _("yes")),
("False", _("no"))
])
config.plugins.VFD_ini.recClockBlink = ConfigSelection(
default="off",
choices=[("off", _("Off")), ("on_off", _("On/Off")),
("brightness", _("Brightness level"))])
config.plugins.VFD_ini.ClockLevel1 = ConfigSlider(default=1, limits=(0, 10))
def __init__(self,
session,
job,
parent=None,
cancelable=True,
backgroundable=True,
afterEventChangeable=True):
Screen.__init__(self, session, parent)
InfoBarNotifications.__init__(self)
ConfigListScreen.__init__(self, [])
self.parent = parent
self.job = job
self.setTitle(_("Job overview"))
self["job_name"] = StaticText(job.name)
self["job_progress"] = Progress()
self["job_task"] = StaticText()
self["summary_job_name"] = StaticText(job.name)
self["summary_job_progress"] = Progress()
self["summary_job_task"] = StaticText()
self["job_status"] = StaticText()
self.cancelable = cancelable
self.backgroundable = backgroundable
self["key_green"] = StaticText("")
if self.cancelable:
self["key_red"] = StaticText(_("Cancel"))
else:
self["key_red"] = StaticText("")
if self.backgroundable:
self["key_blue"] = StaticText(_("Background"))
else:
self["key_blue"] = StaticText("")
self.onShow.append(self.windowShow)
self.onHide.append(self.windowHide)
self["setupActions"] = ActionMap(
["ColorActions", "SetupActions"], {
"green": self.ok,
"red": self.abort,
"blue": self.background,
"cancel": self.abort,
"ok": self.ok,
}, -2)
self.settings = ConfigSubsection()
if SystemInfo["DeepstandbySupport"]:
shutdownString = _("go to deep standby")
else:
shutdownString = _("shut down")
self.settings.afterEvent = ConfigSelection(choices=[
("nothing", _("do nothing")), ("close", _("Close")),
("standby", _("go to standby")), ("deepstandby", shutdownString)
],
default=self.job.afterEvent
or "nothing")
self.job.afterEvent = self.settings.afterEvent.getValue()
self.afterEventChangeable = afterEventChangeable
self.setupList()
self.state_changed()
list = []
list.append("Unencrypted")
list.append("WEP")
list.append("WPA")
list.append("WPA/WPA2")
list.append("WPA2")
weplist = []
weplist.append("ASCII")
weplist.append("HEX")
config.plugins.wlan = ConfigSubsection()
config.plugins.wlan.essid = NoSave(ConfigText(default="", fixed_size=False))
config.plugins.wlan.hiddenessid = NoSave(ConfigYesNo(default=False))
config.plugins.wlan.encryption = NoSave(ConfigSelection(list, default="WPA2"))
config.plugins.wlan.wepkeytype = NoSave(
ConfigSelection(weplist, default="ASCII"))
config.plugins.wlan.psk = NoSave(ConfigPassword(default="", fixed_size=False))
def existBcmWifi(iface):
return os.path.exists("/tmp/bcm/" + iface)
def getWlConfName(iface):
return "/etc/wl.conf.%s" % iface
def getWlanConfigName(iface):
return '/etc/wpa_supplicant.' + iface + '.conf'
def buildMy_rec(self, device):
try:
if device.find('1') > 1:
device2 = device.replace('1', '')
except:
device2 = ''
try:
if device.find('2') > 1:
device2 = device.replace('2', '')
except:
device2 = ''
try:
if device.find('3') > 1:
device2 = device.replace('3', '')
except:
device2 = ''
try:
if device.find('4') > 1:
device2 = device.replace('4', '')
except:
device2 = ''
try:
if device.find('5') > 1:
device2 = device.replace('5', '')
except:
device2 = ''
try:
if device.find('6') > 1:
device2 = device.replace('6', '')
except:
device2 = ''
try:
if device.find('7') > 1:
device2 = device.replace('7', '')
except:
device2 = ''
try:
if device.find('8') > 1:
device2 = device.replace('8', '')
except:
device2 = ''
try:
if device.find('p1') > 1:
device2 = device.replace('p1', '')
except:
device2 = ''
try:
if device.find('p2') > 1:
device2 = device.replace('p2', '')
except:
device2 = ''
try:
if device.find('p3') > 1:
device2 = device.replace('p3', '')
except:
device2 = ''
try:
if device.find('p4') > 1:
device2 = device.replace('p4', '')
except:
device2 = ''
try:
if device.find('p5') > 1:
device2 = device.replace('p5', '')
except:
device2 = ''
try:
if device.find('p6') > 1:
device2 = device.replace('p6', '')
except:
device2 = ''
try:
if device.find('p7') > 1:
device2 = device.replace('p7', '')
except:
device2 = ''
try:
if device.find('p8') > 1:
device2 = device.replace('p8', '')
except:
device2 = ''
devicetype = path.realpath('/sys/block/' + device2 + '/device')
d2 = device
name = 'USB: '
mypixmap = '/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/dev_usbstick.png'
if device2.startswith('mmcblk'):
model = file('/sys/block/' + device2 + '/device/name').read()
mypixmap = '/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/dev_mmc.png'
name = 'MMC: '
else:
model = file('/sys/block/' + device2 + '/device/model').read()
model = str(model).replace('\n', '')
des = ''
print "test:"
if devicetype.find('/devices/pci') != -1 or devicetype.find(
'ahci') != -1:
name = _("HARD DISK: ")
mypixmap = '/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/dev_hdd.png'
name = name + model
f = open('/proc/mounts', 'r')
for line in f.readlines():
if line.find(device) != -1:
parts = line.strip().split()
d1 = parts[1]
dtype = parts[2]
break
continue
else:
d1 = _("None")
dtype = _("unavailable")
f.close()
f = open('/proc/partitions', 'r')
for line in f.readlines():
if line.find(device) != -1:
parts = line.strip().split()
size = int(parts[2])
if (((float(size) / 1024) / 1024) / 1024) > 1:
des = _("Size: ") + str(
round(((
(float(size) / 1024) / 1024) / 1024), 2)) + _("TB")
elif ((size / 1024) / 1024) > 1:
des = _("Size: ") + str((size / 1024) / 1024) + _("GB")
else:
des = _("Size: ") + str(size / 1024) + _("MB")
else:
try:
size = file('/sys/block/' + device2 + '/' + device +
'/size').read()
size = str(size).replace('\n', '')
size = int(size)
except:
size = 0
if ((((float(size) / 2) / 1024) / 1024) / 1024) > 1:
des = _("Size: ") + str(
round(((((float(size) / 2) / 1024) / 1024) / 1024),
2)) + _("TB")
elif (((size / 2) / 1024) / 1024) > 1:
des = _("Size: ") + str(
((size / 2) / 1024) / 1024) + _("GB")
else:
des = _("Size: ") + str((size / 2) / 1024) + _("MB")
f.close()
item = NoSave(
ConfigSelection(default='/media/' + device,
choices=[('/media/' + device, '/media/' + device),
('/media/hdd', '/media/hdd'),
('/media/hdd2', '/media/hdd2'),
('/media/hdd3', '/media/hdd3'),
('/media/usb', '/media/usb'),
('/media/usb2', '/media/usb2'),
('/media/usb3', '/media/usb3'),
('/media/mmc', '/media/mmc'),
('/media/mmc2', '/media/mmc2'),
('/media/mmc3', '/media/mmc3'),
('/usr', '/usr')]))
if dtype == 'Linux':
dtype = 'ext3'
else:
dtype = 'auto'
item.value = d1.strip()
text = name + ' ' + des + ' /dev/' + device
res = getConfigListEntry(text, item, device, dtype)
if des != '' and self.list.append(res):
pass
from os import urandom as os_urandom
###################################################
###################################################
# E2 GUI COMMPONENTS
###################################################
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer.ekstraklasa_defaultformat = ConfigSelection(
default="450",
choices=[("0", "bitrate: najgorszy"), ("200", "bitrate: 200p"),
("450", "bitrate: 450p"), ("900", "bitrate: 900"),
("1800", "bitrate: 1800"), ("9999", "bitrate: najlepszy")])
config.plugins.iptvplayer.ekstraklasa_usedf = ConfigYesNo(default=False)
config.plugins.iptvplayer.ekstraklasa_proxy = ConfigYesNo(default=False)
def GetConfigList():
optionList = []
optionList.append(
getConfigListEntry(
"Domyślny format video:",
config.plugins.iptvplayer.ekstraklasa_defaultformat))
optionList.append(
getConfigListEntry("Używaj domyślnego format video:",
config.plugins.iptvplayer.ekstraklasa_usedf))
import re
from Components.config import config, ConfigText, ConfigSelection, getConfigListEntry
###################################################
###################################################
# E2 GUI COMMPONENTS
###################################################
from Screens.MessageBox import MessageBox
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer.mediayou_language = ConfigSelection(
default="pol",
choices=[("pol", _("Polish")), ("eng", _("English")),
("ger", _("Deutsch")), ("rus", _("Russian")),
("ita", _("Italian")), ("fre", _("French"))])
def GetConfigList():
optionList = []
optionList.append(
getConfigListEntry(_("Language"),
config.plugins.iptvplayer.mediayou_language))
return optionList
###################################################
session = None
ElektroWakeUpTime = -1
elektro_pluginversion = "3.4.5b"
elektrostarttime = 60
elektrosleeptime = 5
elektroShutdownThreshold = 60 * 20
###############################################################################
#Configuration
if debug:
print pluginPrintname, "Setting config defaults"
config.plugins.elektro = ConfigSubsection()
config.plugins.elektro.nextday = ConfigClock(default=((6 * 60 + 0) * 60))
config.plugins.elektro.nextday2 = ConfigClock(default=((6 * 60 + 0) * 60))
config.plugins.elektro.profile = ConfigSelection(choices=[("1", "Profile 1"),
("2", "Profile 2")],
default="1")
config.plugins.elektro.profileShift = ConfigYesNo(default=False)
config.plugins.elektro.sleep = ConfigSubDict()
for i in range(7):
config.plugins.elektro.sleep[i] = ConfigClock(default=((1 * 60 + 0) * 60))
config.plugins.elektro.wakeup = ConfigSubDict()
for i in range(7):
config.plugins.elektro.wakeup[i] = ConfigClock(default=((9 * 60 + 0) * 60))
config.plugins.elektro.sleep2 = ConfigSubDict()
for i in range(7):
config.plugins.elektro.sleep2[i] = ConfigClock(default=((1 * 60 + 0) * 60))
def InitOsd():
SystemInfo["CanChange3DOsd"] = (access('/proc/stb/fb/3dmode', R_OK)
or access('/proc/stb/fb/primary/3d',
R_OK)) and True or False
def languageNotifier(configElement):
language.activateLanguage(configElement.value)
config.osd = ConfigSubsection()
config.osd.language = ConfigText(default="en_GB")
config.osd.language.addNotifier(languageNotifier)
config.osd.dst_left = ConfigSelectionNumber(default=0,
stepwidth=1,
min=0,
max=720,
wraparound=False)
config.osd.dst_width = ConfigSelectionNumber(default=720,
stepwidth=1,
min=0,
max=720,
wraparound=False)
config.osd.dst_top = ConfigSelectionNumber(default=0,
stepwidth=1,
min=0,
max=576,
wraparound=False)
config.osd.dst_height = ConfigSelectionNumber(default=576,
stepwidth=1,
min=0,
max=576,
wraparound=False)
config.osd.alpha = ConfigSelectionNumber(default=255,
stepwidth=1,
min=0,
max=255,
wraparound=False)
config.av.osd_alpha = NoSave(ConfigNumber(default=255))
config.osd.threeDmode = ConfigSelection(
[("off", _("Off")), ("auto", _("Auto")),
("sidebyside", _("Side by Side")),
("topandbottom", _("Top and Bottom"))], "auto")
config.osd.threeDznorm = ConfigSlider(default=50,
increment=1,
limits=(0, 100))
config.osd.show3dextensions = ConfigYesNo(default=False)
def set3DMode(configElement):
if SystemInfo["CanChange3DOsd"] and getBoxType() not in ('spycat'):
print '[UserInterfacePositioner] Setting 3D mode:', configElement.value
file3d = fileCheck('/proc/stb/fb/3dmode') or fileCheck(
'/proc/stb/fb/primary/3d')
f = open(file3d, "w")
f.write(configElement.value)
f.close()
config.osd.threeDmode.addNotifier(set3DMode)
def set3DZnorm(configElement):
if SystemInfo["CanChange3DOsd"] and getBoxType() not in ('spycat'):
print '[UserInterfacePositioner] Setting 3D depth:', configElement.value
f = open("/proc/stb/fb/znorm", "w")
f.write('%d' % int(configElement.value))
f.close()
config.osd.threeDznorm.addNotifier(set3DZnorm)