('hd_i', (_("HD Interlace Mode"))), ('hd_p', (_("HD Progressive Mode"))), \
('p720_24', (_("Enable 720p24 Mode"))), ('p1080_24', (_("Enable 1080p24 Mode"))), \
('p1080_25', (_("Enable 1080p25 Mode"))), ('p1080_30', (_("Enable 1080p30 Mode"))))
config.plugins.autoresolution = ConfigSubsection()
config.plugins.autoresolution.enable = ConfigYesNo(default=False)
config.plugins.autoresolution.showinfo = ConfigYesNo(default=True)
config.plugins.autoresolution.testmode = ConfigYesNo(default=False)
#config.plugins.autoresolution.deinterlacer = ConfigSelection(default = "auto", choices =
#[("off", _("off")), ("auto", _("auto")), ("on", _("on")), ("bob", _("bob"))])
#config.plugins.autoresolution.deinterlacer_progressive = ConfigSelection(default = "auto", choices =
#[("off", _("off")), ("auto", _("auto")), ("on", _("on")), ("bob", _("bob"))])
config.plugins.autoresolution.delay_switch_mode = ConfigSelection(
default="1000",
choices=[("0", "0 " + _("seconds")), ("1000", "1 " + _("second")),
("2000", "2 " + _("seconds")), ("3000", "3 " + _("seconds")),
("4000", "4 " + _("seconds")), ("5000", "5 " + _("seconds")),
("6000", "6 " + _("seconds")), ("7000", "7 " + _("seconds")),
("8000", "8 " + _("seconds")), ("9000", "9 " + _("seconds")),
("10000", "10 " + _("seconds"))])
#def setDeinterlacer(mode):
#print "[AutoRes] switch deinterlacer mode to %s" % mode
#f = open('/proc/stb/vmpeg/deinterlace' , "w")
#f.write("%s\n" % mode)
#f.close()
frqdic = { 23976: '24', \
24000: '24', \
25000: '25', \
29970: '30', \
30000: '30', \
("TemplatesChannelSelectionTvInfoEPGNowProgram", _("Now, 5 Programs")),
("TemplatesChannelSelectionTvInfoEPGProgram", _("10 Programs"))
]
buqetradiochannelselection = [
("TemplatesChannelSelectionRadioBuqetNo", _("No")),
("TemplatesChannelSelectionRadioBuqetYes", _("Yes"))
]
panelmovieselection = [
("TemplatesMovieSelectionDescriptionNo", _("No")),
("TemplatesMovieSelectionDescriptionShort", _("Short Description")),
("TemplatesMovieSelectionDescriptionFull", _("Full Description"))
]
extratranslation = [("0", _("Tuner Info")), ("1", _("Info")), ("2", _("Menu"))]
config.skin.cyber = ConfigSubsection()
config.skin.cyber.fonts = ConfigSelection(default="Roboto-Regular",
choices=fonts)
config.skin.cyber.colorsetting = ConfigSelection(default="0",
choices=colorsetting)
if config.skin.cyber.colorsetting.value == "0":
config.skin.cyber.colorbackground1 = ConfigSelection(default="0000000",
choices=stylecolor)
config.skin.cyber.colorbackground2 = ConfigSelection(default="0696969",
choices=stylecolor)
config.skin.cyber.colorbackground3 = ConfigSelection(default="0ffffff",
choices=stylecolor)
config.skin.cyber.colorbackground4 = ConfigSelection(default="000ffff",
choices=stylecolor)
config.skin.cyber.colorbackground5 = ConfigSelection(default="0696969",
choices=stylecolor)
from Components.Label import Label
from Plugins.Plugin import PluginDescriptor
from Screens.Console import Console
from Screens.InputBox import InputBox
from Screens.MessageBox import MessageBox
from Screens.Standby import TryQuitMainloop
from Screens.Screen import Screen
from Tools.Directories import fileExists
from NTPSyncPoller import NTPSyncPoller
import os
import time
from calendar import isleap
config.plugins.SystemTime = ConfigSubsection()
config.plugins.SystemTime.choiceSystemTime = ConfigSelection(default="0", choices=[("0", _("Transponder")), ("1", _("NTP"))])
config.plugins.SystemTime.useNTPminutes = ConfigSelection(default="60", choices=[("5", _("5 mins")), ("15", _("15 mins")), ("30", _("30 mins")), ("60", _("1 hour")), ("120", _("2 hours")), ("240", _("4 hours")), ("720", _("12 hours")), ("1440", _("24 hours")), ("2880", _("48 hours"))])
config.plugins.SystemTime.syncNTPcoldstart = ConfigYesNo(default=False)
config.plugins.SystemTime.useRTCstart = ConfigYesNo(default=False)
config.plugins.SystemTime.wifi_delay = ConfigInteger(0, limits=(0, 120))
config.plugins.SystemTime.syncNTPtime = ConfigSelection(default="1", choices=[("1", _("Press OK"))])
config.plugins.SystemTime.syncDVBtime = ConfigSelection(default="1", choices=[("1", _("Press OK"))])
config.plugins.SystemTime.syncManually = ConfigSelection(default="1", choices=[("1", _("Press OK"))])
config.plugins.SystemTime.ip = ConfigText(default="pool.ntp.org", fixed_size=False)
ntpsyncpoller = None
fullHD = False
if getDesktop(0).size().width() >= 1920:
fullHD = True
("%d" % i, ngettext("%d second", "%d seconds", i) % i))
else:
choicelist.append(("%d" % i, "%d seconds" % i))
for i in range(1, 5, 1):
if NGETTEXT:
choicelist.append(
("%d" % (i * 60), ngettext("%d minute", "%d minutes", i) % i))
else:
choicelist.append(("%d" % (i * 60), "%d minutes" % i))
for i in range(5, 61, 5):
if NGETTEXT:
choicelist.append(
("%d" % (i * 60), ngettext("%d minute", "%d minutes", i) % i))
else:
choicelist.append(("%d" % (i * 60), "%d minutes" % i))
config.plugins.MemInfo.repeat_timeout = ConfigSelection(default="300",
choices=choicelist)
config.plugins.MemInfo.screen_info = ConfigYesNo(default=True)
choicelist = []
for i in range(1, 11):
if NGETTEXT:
choicelist.append(
("%d" % i, ngettext("%d second", "%d seconds", i) % i))
else:
choicelist.append(("%d" % i))
config.plugins.MemInfo.timescreen_info = ConfigSelection(default="5",
choices=choicelist)
choicelist = [
("0", _("Default")),
]
cfg = config.plugins.MemInfo
def createConfig(self, frontendData):
#("Type", frontendData["system"], TYPE_TEXT),
#("Modulation", frontendData["modulation"], TYPE_TEXT),
#("Orbital position", frontendData["orbital_position"], TYPE_VALUE_DEC),
#("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
#("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
#("Polarization", frontendData["polarization"], TYPE_TEXT),
#("Inversion", frontendData["inversion"], TYPE_TEXT),
#("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
#)
#elif frontendData["tuner_type"] == "DVB-C":
#return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
#("Type", frontendData["tuner_type"], TYPE_TEXT),
#("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
#("Symbolrate", frontendData["symbol_rate"], TYPE_VALUE_DEC),
#("Modulation", frontendData["modulation"], TYPE_TEXT),
#("Inversion", frontendData["inversion"], TYPE_TEXT),
# ("FEC inner", frontendData["fec_inner"], TYPE_TEXT),
#)
#elif frontendData["tuner_type"] == "DVB-T":
#return ( ("NIM", ['A', 'B', 'C', 'D'][frontendData["tuner_number"]], TYPE_TEXT),
#("Type", frontendData["tuner_type"], TYPE_TEXT),
#("Frequency", frontendData["frequency"], TYPE_VALUE_DEC),
#("Inversion", frontendData["inversion"], TYPE_TEXT),
#("Bandwidth", frontendData["bandwidth"], TYPE_VALUE_DEC),
#("CodeRateLP", frontendData["code_rate_lp"], TYPE_TEXT),
#("CodeRateHP", frontendData["code_rate_hp"], TYPE_TEXT),
#("Constellation", frontendData["constellation"], TYPE_TEXT),
#("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT),
#("Guard Interval", frontendData["guard_interval"], TYPE_TEXT),
#("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT),
defaultSat = {
"orbpos": 192,
"system": eDVBFrontendParametersSatellite.System_DVB_S,
"frequency": 11836,
"inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
"symbolrate": 27500,
"polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
"fec": eDVBFrontendParametersSatellite.FEC_Auto,
"fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
"modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
defaultCab = {
"frequency": 466,
"inversion": eDVBFrontendParametersCable.Inversion_Unknown,
"modulation": eDVBFrontendParametersCable.Modulation_QAM64,
"fec": eDVBFrontendParametersCable.FEC_Auto,
"symbolrate": 6900 }
defaultTer = {
"frequency" : 466000,
"inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown,
"bandwidth" : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz,
"fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto,
"feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto,
"modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto,
"transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto,
"guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto,
"hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto }
if frontendData is not None:
ttype = frontendData.get("tuner_type", "UNKNOWN")
if ttype == "DVB-S":
defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)
else:
defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)
defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
elif ttype == "DVB-C":
defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown)
defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto)
defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16)
elif ttype == "DVB-T":
defaultTer["frequency"] = frontendData.get("frequency", 0)
defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown)
defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz)
defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto)
defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto)
defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto)
defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto)
defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto)
defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto)
self.scan_sat = ConfigSubsection()
self.scan_cab = ConfigSubsection()
self.scan_ter = ConfigSubsection()
self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat"))])
self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))])
self.scan_onlyfree = ConfigYesNo(default = False)
self.scan_networkScan = ConfigYesNo(default = False)
nim_list = []
# collect all nims which are *not* set to "nothing"
for n in nimmanager.nim_slots:
if n.config_mode == "nothing":
continue
if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
continue
if n.config_mode in ("loopthrough", "satposdepends"):
root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.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)
# status
self.scan_snr = ConfigSlider()
self.scan_snr.enabled = False
self.scan_agc = ConfigSlider()
self.scan_agc.enabled = False
self.scan_ber = ConfigSlider()
self.scan_ber.enabled = False
# sat
self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
(eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
(eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])
self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
(eDVBFrontendParametersSatellite.Inversion_Off, _("Off")),
(eDVBFrontendParametersSatellite.Inversion_On, _("On")),
(eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])
self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
(eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
(eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
(eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
(eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [
(eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")),
(eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
(eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
(eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
(eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
(eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
(eDVBFrontendParametersSatellite.FEC_None, _("None"))])
self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [
(eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
(eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
(eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
(eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
(eDVBFrontendParametersSatellite.FEC_4_5, "4/5"),
(eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
(eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
(eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
(eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
(eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
(eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
(eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
(eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
(eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20"),
(eDVBFrontendParametersSatellite.RollOff_auto, _("Auto"))])
self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
(eDVBFrontendParametersSatellite.Pilot_Off, _("Off")),
(eDVBFrontendParametersSatellite.Pilot_On, _("On")),
(eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])
# cable
self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [
(eDVBFrontendParametersCable.Inversion_Off, _("Off")),
(eDVBFrontendParametersCable.Inversion_On, _("On")),
(eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))])
self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [
(eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"),
(eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")])
self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [
(eDVBFrontendParametersCable.FEC_Auto, _("Auto")),
(eDVBFrontendParametersCable.FEC_1_2, "1/2"),
(eDVBFrontendParametersCable.FEC_2_3, "2/3"),
(eDVBFrontendParametersCable.FEC_3_4, "3/4"),
(eDVBFrontendParametersCable.FEC_5_6, "5/6"),
(eDVBFrontendParametersCable.FEC_7_8, "7/8"),
(eDVBFrontendParametersCable.FEC_8_9, "8/9"),
(eDVBFrontendParametersCable.FEC_None, _("None"))])
self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
# terrestial
self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000))
self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
(eDVBFrontendParametersTerrestrial.Inversion_Off, _("Off")),
(eDVBFrontendParametersTerrestrial.Inversion_On, _("On")),
(eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))])
# WORKAROUND: we can't use BW-auto
self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [
(eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
(eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
(eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")])
#, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto"))))
self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [
(eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
(eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
(eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
(eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
(eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
(eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [
(eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
(eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
(eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
(eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
(eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
(eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [
(eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
(eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
(eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
(eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
(eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
(eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [
(eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
(eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
(eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
(eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
(eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [
(eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")),
(eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"),
(eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"),
(eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"),
(eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))])
self.scan_scansat = {}
for sat in nimmanager.satList:
#print sat[1]
self.scan_scansat[sat[0]] = ConfigYesNo(default = False)
self.scan_satselection = []
for slot in nimmanager.nim_slots:
if slot.isCompatible("DVB-S"):
self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]))
else:
self.scan_satselection.append(None)
return True
def createTransCodingConfig(encoder):
if fileExists(getProcPath(encoder, "bitrate")):
if getBoxType() == "vusolo2":
choice = ConfigSelection(default="400000",
choices=[("-1", "Auto"),
("50000", "50 Kbits"),
("100000", "100 Kbits"),
("150000", "150 Kbits"),
("200000", "200 Kbits"),
("250000", "250 Kbits"),
("300000", "300 Kbits"),
("350000", "350 Kbits"),
("400000", "400 Kbits"),
("450000", "450 Kbits"),
("500000", "500 Kbits"),
("600000", "600 Kbits"),
("700000", "700 Kbits"),
("800000", "800 Kbits"),
("900000", "900 Kbits"),
("1000000", "1 Mbits")])
elif getBoxType() in ("gbquad", "gbquadplus"):
choice = ConfigSelection(default="-1",
choices=[("-1", "Auto"),
("50000", "50 Kbits"),
("100000", "100 Kbits"),
("150000", "150 Kbits"),
("200000", "200 Kbits"),
("250000", "250 Kbits"),
("300000", "300 Kbits"),
("350000", "350 Kbits"),
("400000", "400 Kbits"),
("450000", "450 Kbits"),
("500000", "500 Kbits"),
("600000", "600 Kbits"),
("700000", "700 Kbits"),
("800000", "800 Kbits"),
("900000", "900 Kbits"),
("1000000", "1 Mbits")])
else:
choice = ConfigSelection(default="2000000",
choices=[("-1", "Auto"),
("100000", "100 Kbits"),
("150000", "150 Kbits"),
("200000", "200 Kbits"),
("250000", "250 Kbits"),
("300000", "300 Kbits"),
("350000", "350 Kbits"),
("400000", "400 Kbits"),
("450000", "450 Kbits"),
("500000", "500 Kbits"),
("750000", "750 Kbits"),
("1000000", "1 Mbits"),
("1500000", "1.5 Mbits"),
("2000000", "2 Mbits"),
("2500000", "2.5 Mbits"),
("3000000", "3 Mbits"),
("3500000", "3.5 Mbits"),
("4000000", "4 Mbits"),
("4500000", "4.5 Mbits"),
("5000000", "5 Mbits"),
("10000000", "10 Mbits")])
config.plugins.transcodingsetup.encoder[int(encoder)].bitrate = choice
if fileExists(getProcPath(encoder, "framerate")):
if getBoxType() in ("gbquad", "gbquadplus"):
choice = ConfigSelection(default="-1",
choices=[("-1", "Auto"),
("23976", "23.976 fps"),
("24000", "24 fps"),
("25000", "25 fps"),
("29970", "29.970 fps")])
else:
choice = ConfigSelection(default="50000",
choices=[("-1", "Auto"),
("23976", "23.976 fps"),
("24000", "24 fps"),
("25000", "25 fps"),
("29970", "29.970 fps"),
("30000", "30 fps"),
("50000", "50 fps"),
("59940", "59.940 fps"),
("60000", "60 fps")])
config.plugins.transcodingsetup.encoder[int(
encoder)].framerate = choice
if checkSupportAdvanced():
if (hasattr(config.plugins.transcodingsetup.encoder[int(encoder)],
"bitrate") or hasattr(
config.plugins.transcodingsetup.encoder[int(encoder)],
"framerate")):
choice = ConfigSelection(default="Off",
choices=[("On", _("On")),
("Off", _("Off"))])
config.plugins.transcodingsetup.encoder[int(
encoder)].automode = choice
if fileExists(getProcPath(encoder, "resolution")):
resolution_choices = [("480p", _("480p")), ("576p", _("576p")),
("720p", _("720p")),
("320x240", _("320x240")),
("160x120", _("160x120"))]
if getBoxType() == "vusolo4k":
resolution_choices.insert(3, ("1080p", _("1080p")))
choice = ConfigSelection(default="480p",
choices=resolution_choices)
config.plugins.transcodingsetup.encoder[int(
encoder)].resolution = choice
if fileExists(getProcPath(encoder, "aspectratio")):
choice = ConfigSelection(default="2",
choices=[("0", _("auto")),
("1", _("4x3")),
("2", _("16x9"))])
config.plugins.transcodingsetup.encoder[int(
encoder)].aspectratio = choice
if fileExists(getProcPath(encoder, "audiocodec")):
choice = ConfigSelection(default="aac",
choices=[("mpg", _("mpg")),
("mp3", _("mp3")),
("aac", _("aac")),
("aac+", _("aac+")),
("aac+loas", _("aac+loas")),
("aac+adts", _("aac+adts")),
("ac3", _("ac3"))])
config.plugins.transcodingsetup.encoder[int(
encoder)].audiocodec = choice
if fileExists(getProcPath(encoder, "videocodec")):
choice = ConfigSelection(default="h264",
choices=[("h264", _("h264"))])
config.plugins.transcodingsetup.encoder[int(
encoder)].videocodec = choice
if fileExists(getProcPath(encoder, "gopframeb")):
choice = ConfigInteger(default=0, limits=(0, 60))
config.plugins.transcodingsetup.encoder[int(
encoder)].gopframeb = choice
if fileExists(getProcPath(encoder, "gopframep")):
choice = ConfigInteger(default=29, limits=(0, 60))
config.plugins.transcodingsetup.encoder[int(
encoder)].gopframep = choice
if fileExists(getProcPath(encoder, "level")):
choice = ConfigSelection(default="3.1",
choices=[("1.0", _("1.0")),
("2.0", _("2.0")),
("2.1", _("2.1")),
("2.2", _("2.2")),
("3.0", _("3.0")),
("3.1", _("3.1")),
("3.2", _("3.2")),
("4.0", _("4.0")),
("4.1", _("4.1")),
("4.2", _("4.2")),
("5.0", _("5.0")),
("low", _("low")),
("main", _("main")),
("high", _("high"))])
config.plugins.transcodingsetup.encoder[int(
encoder)].level = choice
if fileExists(getProcPath(encoder, "profile")):
choice = ConfigSelection(default="baseline",
choices=[("baseline", _("baseline")),
("simple", _("simple")),
("main", _("main")),
("high", _("high")),
("advanced simple",
_("advancedsimple"))])
config.plugins.transcodingsetup.encoder[int(
encoder)].profile = choice
profile('LOAD:Tools')
from Tools.Directories import InitFallbackFiles, resolveFilename, SCOPE_PLUGINS, SCOPE_ACTIVE_SKIN, SCOPE_CURRENT_SKIN, SCOPE_CONFIG
from Components.config import config, configfile, ConfigText, ConfigYesNo, ConfigInteger, ConfigSelection, NoSave
import Components.RecordingConfig
InitFallbackFiles()
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.nextWakeup = ConfigText(default='-1,-1,-1,0,0,-1,0')
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)
config.misc.standbyCounter = NoSave(ConfigInteger(default=0))
config.misc.DeepStandby = NoSave(ConfigYesNo(default=False))
config.misc.query_restart = ConfigYesNo(default=False)
config.misc.query_restart_full = ConfigYesNo(default=False)
config.misc.fadeShowMenu = ConfigYesNo(default=False)
config.misc.enableAnimation = ConfigYesNo(default=False)
config.misc.enableAnimationInfobar = ConfigYesNo(default=False)
config.misc.enableAnimationInfobarMovie = ConfigYesNo(default=False)
config.misc.enableAnimationMenuScreens = ConfigYesNo(default=False)
config.misc.enableAnimationChSelection = ConfigYesNo(default=False)
from Plugins.Extensions.IPTVPlayer.components.iptvplayerinit import TranslateTXT as _
###################################################
###################################################
# FOREIGN import
###################################################
import skin
from enigma import eLabel, getDesktop
from Screens.MessageBox import MessageBox
from Components.config import config, ConfigSelection, ConfigYesNo, Config, ConfigInteger, getConfigListEntry, configfile
from Components.SystemInfo import BoxInfo
architecture = BoxInfo.getItem("architecture")
###################################################
config.plugins.iptvplayer.extplayer_summary = ConfigSelection(
default="yes",
choices=[('auto', _('Auto')), ('yes', _('Yes')), ('no', _('No'))])
config.plugins.iptvplayer.use_clear_iframe = ConfigYesNo(default=False)
config.plugins.iptvplayer.show_iframe = ConfigYesNo(default=True)
config.plugins.iptvplayer.iframe_file = ConfigIPTVFileSelection(
fileMatch="^.*\.mvi$", default="/usr/share/enigma2/radio.mvi")
config.plugins.iptvplayer.clear_iframe_file = ConfigIPTVFileSelection(
fileMatch="^.*\.mvi$", default="/usr/share/enigma2/black.mvi")
config.plugins.iptvplayer.remember_last_position = ConfigYesNo(default=False)
config.plugins.iptvplayer.remember_last_position_time = ConfigInteger(
0, (0, 99))
config.plugins.iptvplayer.fakeExtePlayer3 = ConfigSelection(default="fake",
choices=[("fake",
" ")])
config.plugins.iptvplayer.rambuffer_sizemb_network_proto = ConfigInteger(
def __init__(self):
# fill aac_mix option
options = [(None, _("From E2 settings"))]
tmp = GetE2AudioCodecMixChoices('aac')
for item in tmp:
options.append((item, _(item)))
if config.plugins.iptvplayer.aac_mix.value not in tmp:
config.plugins.iptvplayer.aac_mix.value = None
if len(tmp):
self.aac_mix_avaliable = True
else:
self.aac_mix_avaliable = False
config.plugins.iptvplayer.aac_mix = ConfigSelection(default=None,
choices=options)
# fill ac3_mix option
options = [(None, _("From E2 settings"))]
tmp = GetE2AudioCodecMixChoices('ac3')
for item in tmp:
options.append((item, _(item)))
if config.plugins.iptvplayer.ac3_mix.value not in tmp:
config.plugins.iptvplayer.ac3_mix.value = None
if len(tmp):
self.ac3_mix_avaliable = True
else:
self.ac3_mix_avaliable = False
config.plugins.iptvplayer.ac3_mix = ConfigSelection(default=None,
choices=options)
# fill aspect option
options = [(None, _("From E2 settings"))]
tmp = GetE2VideoAspectChoices()
for item in tmp:
options.append((item, _(item)))
if config.plugins.iptvplayer.extplayer_aspect.value not in tmp:
config.plugins.iptvplayer.extplayer_aspect.value = None
if len(tmp):
self.aspect_avaliable = True
else:
self.aspect_avaliable = False
config.plugins.iptvplayer.extplayer_aspect = ConfigSelection(
default=None, choices=options)
# fill policy option
options = [(None, _("From E2 settings"))]
tmp = GetE2VideoPolicyChoices()
for item in tmp:
options.append((item, _(item)))
if config.plugins.iptvplayer.extplayer_policy.value not in tmp:
config.plugins.iptvplayer.extplayer_policy.value = None
if len(tmp):
self.policy_avaliable = True
else:
self.policy_avaliable = False
config.plugins.iptvplayer.extplayer_policy = ConfigSelection(
default=None, choices=options)
# fill policy 2 option
options = [(None, _("From E2 settings"))]
if None != GetE2VideoPolicy('2'):
tmp = GetE2VideoPolicyChoices()
for item in tmp:
options.append((item, _(item)))
else:
tmp = []
if config.plugins.iptvplayer.extplayer_policy2.value not in tmp:
config.plugins.iptvplayer.extplayer_policy2.value = None
if len(tmp):
self.policy2_avaliable = True
else:
self.policy2_avaliable = False
config.plugins.iptvplayer.extplayer_policy2 = ConfigSelection(
default=None, choices=options)
# fill fonts option
options = [("Regular", "Regular")]
fonts = ["Regular"]
try:
for key in skin.fonts:
font = skin.fonts[key][0]
if font not in fonts:
fonts.append(font)
options.append((font, font))
except Exception:
printExc()
config.plugins.iptvplayer.extplayer_subtitle_font = ConfigSelection(
default="Regular", choices=options)
# check if border is avaliable
self.subtitle_border_avaliable = False
try:
tmp = dir(eLabel)
if 'setBorderColor' in tmp:
self.subtitle_border_avaliable = True
except Exception:
printExc()
if not self.subtitle_border_avaliable:
config.plugins.iptvplayer.extplayer_subtitle_border_enabled.value = False
import time
import re
import urllib
try:
import json
except Exception:
import simplejson as json
from Components.config import config, ConfigSelection, ConfigYesNo, ConfigText, getConfigListEntry
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer.laola1tv_defquality = ConfigSelection(
default="1000000",
choices=[("0", _("The worst")), ("500000", _("Low")),
("1000000", _("Mid")), ("1500000", _("High")),
("9000000", _("The best"))])
config.plugins.iptvplayer.laola1tv_onelink = ConfigYesNo(default=False)
config.plugins.iptvplayer.laola1tv_portal = ConfigSelection(default="int",
choices=[
("at", "AT"),
("de", "DE"),
("int", "INT")
])
config.plugins.iptvplayer.laola1tv_language = ConfigSelection(
default="en", choices=[("en", _("English")), ("de", _("Deutsch"))])
config.plugins.iptvplayer.laola1tv_myip1 = ConfigText(default="146.0.32.8",
fixed_size=False)
config.plugins.iptvplayer.laola1tv_myip2 = ConfigText(default="85.128.142.29",
fixed_size=False)
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))
class WlanStatus(Screen):
skin = """
<screen name="WlanStatus" position="center,center" size="560,400" title="Wireless network status" >
<ePixmap pixmap="skin_default/buttons/red.png" position="0,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="LabelBSSID" render="Label" position="10,60" size="200,25" valign="left" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
<widget source="LabelESSID" render="Label" position="10,100" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
<widget source="LabelQuality" render="Label" position="10,140" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
<widget source="LabelSignal" render="Label" position="10,180" size="200,25" valign="center" font="Regular;20" transparent="1" foregroundColor="#FFFFFF" />
import urlparse
import urllib
from Components.config import config, ConfigText, ConfigSelection, getConfigListEntry
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer.ekinotv_login = ConfigText(default="",
fixed_size=False)
config.plugins.iptvplayer.ekinotv_password = ConfigText(default="",
fixed_size=False)
config.plugins.iptvplayer.ekinotv_sortby = ConfigSelection(
default="data-dodania",
choices=[("alfabetycznie", "nazwy"), ("ocena", "oceny"),
("odslony", "ilości odsłon"), ("data-dodania", "daty dodania"),
("data-premiery", "daty premiery"),
('data-aktualizacji', 'daty aktualizacji')])
config.plugins.iptvplayer.ekinotv_sortorder = ConfigSelection(
default="desc", choices=[("desc", "malejąco"), ("asc", "rosnąco")])
def GetConfigList():
optionList = []
optionList.append(
getConfigListEntry("Ekino TV login:"******"Ekino TV hasło:",
config.plugins.iptvplayer.ekinotv_password))
optionList.append(
import urllib2
from Components.ActionMap import ActionMap
from Components.config import config, ConfigSelection, getConfigListEntry
from Components.ConfigList import ConfigListScreen
from Components.Label import Label
from Components.Sources.StaticText import StaticText
from Plugins.Plugin import PluginDescriptor
from Screens.MessageBox import MessageBox
from Screens.Screen import Screen
from Screens.Standby import TryQuitMainloop
config.dvbtypexmlupdate = ConfigSelection(default="satellites",
choices=[
("atsc", _("ATSC")),
("cables", _("Cables")),
("satellites", _("Satellites")),
("terrestrial",
_("Terrestrial")),
("unicable", _("Unicable"))
])
config.satellitestypexmlupdate = ConfigSelection(
default="europe",
choices=[("all", _("All (not recommended)")),
("america", _("America (61°W-160°W)")),
("asia", _("Asia (160°W-73°E)")),
("atlantic", _("Atlantic (0°W-61°W)")),
("europe", _("Europe (73°E-0°E)"))])
config.foldertypexmlupdate = ConfigSelection(
default="/etc/tuxbox",
choices=[("/etc/tuxbox", _("/etc/tuxbox (default)")),
("/etc/enigma2", _("/etc/enigma2")),
def localeInit():
gettext.bindtextdomain(PluginLanguageDomain, resolveFilename(SCOPE_PLUGINS, PluginLanguagePath))
def _(txt):
if gettext.dgettext(PluginLanguageDomain, txt):
return gettext.dgettext(PluginLanguageDomain, txt)
else:
print("[" + PluginLanguageDomain + "] fallback to default translation for " + txt)
return gettext.gettext(txt)
language.addCallback(localeInit())
################################################
config.plugins.ZapHistoryConfigurator = ConfigSubsection()
config.plugins.ZapHistoryConfigurator.enable_zap_history = ConfigSelection(choices = {"off": _("disabled"), "on": _("enabled"), "parental_lock": _("disabled at parental lock")}, default="on")
config.plugins.ZapHistoryConfigurator.maxEntries_zap_history = ConfigInteger(default=20, limits=(1, 60))
config.plugins.ZapHistoryConfigurator.e1_like_history = ConfigYesNo(default = False)
config.plugins.ZapHistoryConfigurator.history_tv = ConfigSet(choices = [])
config.plugins.ZapHistoryConfigurator.history_radio = ConfigSet(choices = [])
################################################
def addToHistory(instance, ref):
if config.plugins.ZapHistoryConfigurator.enable_zap_history.value == "off":
return
if config.ParentalControl.servicepinactive.value and config.plugins.ZapHistoryConfigurator.enable_zap_history.value == "parental_lock":
if parentalControl.getProtectionLevel(ref.toCompareString()) != -1:
return
if instance.servicePath is not None:
tmp = instance.servicePath[:]
from enigma import eTimer, quitMainloop, eListbox, ePoint, RT_HALIGN_LEFT, RT_HALIGN_RIGHT, RT_VALIGN_CENTER, eListboxPythonMultiContent, eListbox, gFont, getDesktop, ePicLoad, eServiceCenter, iServiceInformation, eServiceReference, iSeekableService, iServiceInformation, iPlayableService, iPlayableServicePtr
from os import path as os_path, system as os_system, unlink, stat, mkdir, popen, makedirs, listdir, access, rename, remove, W_OK, R_OK, F_OK
from twisted.web import client
from twisted.internet import reactor
from time import time
from Screens.InfoBarGenerics import InfoBarShowHide, InfoBarSeek, InfoBarNotifications, InfoBarServiceNotifications
from ServiceXML import iWebTVStations
from MoviePlayer import dreamMediathekPlayer
config.plugins.dreamMediathek = ConfigSubsection()
config.plugins.dreamMediathek.general = ConfigSubsection()
config.plugins.dreamMediathek.general.on_movie_stop = ConfigSelection(
default="ask",
choices=[("ask", _("Ask user")), ("quit", _("Return to movie list")),
("playnext", _("Play next video")),
("playagain", _("Play video again"))])
config.plugins.dreamMediathek.general.on_exit = ConfigSelection(
default="ask",
choices=[("ask", _("Ask user")), ("quit", _("Return to movie list"))])
class dreamMediathekStationsScreen(Screen):
Details = {}
skin = """
<screen name="dreamMediathekStationsScreen" position="center,center" size="560,440" title="dreamMediathekStationsScreen" >
<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" />
<ePixmap pixmap="buttons/blue.png" position="420,0" size="140,40" alphatest="on" />
from . import _
from Components.ActionMap import ActionMap
from Components.config import getConfigListEntry, config, ConfigSubsection, ConfigText, ConfigSelection, ConfigInteger, ConfigClock, NoSave, configfile
from Components.ConfigList import ConfigListScreen
from Components.Label import Label
from Components.Sources.List import List
from Components.Pixmap import Pixmap
from Screens.Screen import Screen
from Screens.MessageBox import MessageBox
from Components.Console import Console
from os import system, listdir, rename, symlink, unlink, path, mkdir
from time import sleep
config.spateam = ConfigSubsection()
config.spateam.cronmanager_commandtype = NoSave(
ConfigSelection(choices=[('custom',
_("Custom")), ('predefined', _("Predefined"))]))
config.spateam.cronmanager_cmdtime = NoSave(ConfigClock(default=0))
config.spateam.cronmanager_cmdtime.value, mytmpt = ([0, 0], [0, 0])
config.spateam.cronmanager_user_command = NoSave(ConfigText(fixed_size=False))
config.spateam.cronmanager_runwhen = NoSave(
ConfigSelection(default='Daily',
choices=[('Hourly', _("Hourly")), ('Daily', _("Daily")),
('Weekly', _("Weekly")),
('Monthly', _("Monthly"))]))
config.spateam.cronmanager_dayofweek = NoSave(
ConfigSelection(default='Monday',
choices=[('Monday', _("Monday")),
('Tuesday', _("Tuesday")),
('Wednesday', _("Wednesday")),
('Thursday', _("Thursday")),
('Friday', _("Friday")),
"profile": "profile",
"width": "width",
"height": "height",
}.get(configName)
return "/proc/stb/encoder/%s/%s" % (encoder, _configName)
def checkSupportAdvanced():
if fileExists(getProcPath(0, "aspectratio")):
return True
return False
config.plugins.transcodingsetup = ConfigSubsection()
config.plugins.transcodingsetup.transcoding = ConfigSelection(
default="enable",
choices=[("enable", _("enable")), ("disable", _("disable"))])
config.plugins.transcodingsetup.port = ConfigInteger(default=8002,
limits=(8002, 9999))
config.plugins.transcodingsetup.encoder = ConfigSubList()
def createTransCodingConfig(encoder):
if fileExists(getProcPath(encoder, "bitrate")):
if getBoxType() == "vusolo2":
choice = ConfigSelection(default="400000",
choices=[("-1", "Auto"),
("50000", "50 Kbits"),
("100000", "100 Kbits"),
("150000", "150 Kbits"),
("200000", "200 Kbits"),
# FOREIGN import
###################################################
import re
import time
import urllib
from datetime import timedelta
###################################################
config.plugins.iptvplayer.christusvincit_preferred_bitrate = ConfigSelection(
default="99999999",
choices=[
("0", _("the lowest")),
("360000", "360000"),
("590000", "590000"),
("820000", "820000"),
("1250000", "1250000"),
("1750000", "1750000"),
("2850000", "2850000"),
("5420000", "5420000"),
("6500000", "6500000"),
("9100000", "9100000"),
("99999999", _("the highest")),
])
config.plugins.iptvplayer.christusvincit_use_preferred_bitrate = ConfigYesNo(
default=True)
###################################################
# Config options for HOST
###################################################
def createConfig(self, frontendData):
defaultSat = {
"orbpos": 192,
"system": eDVBFrontendParametersSatellite.System_DVB_S,
"frequency": 11836,
"inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
"symbolrate": 27500,
"polarization":
eDVBFrontendParametersSatellite.Polarisation_Horizontal,
"fec": eDVBFrontendParametersSatellite.FEC_Auto,
"fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
"modulation": eDVBFrontendParametersSatellite.Modulation_QPSK
}
if frontendData is not None:
ttype = frontendData.get("tuner_type", "UNKNOWN")
if ttype == "DVB-S":
defaultSat["system"] = frontendData.get(
"system", eDVBFrontendParametersSatellite.System_DVB_S)
defaultSat["frequency"] = frontendData.get("frequency",
0) / 1000
defaultSat["inversion"] = frontendData.get(
"inversion",
eDVBFrontendParametersSatellite.Inversion_Unknown)
defaultSat["symbolrate"] = frontendData.get("symbol_rate",
0) / 1000
defaultSat["polarization"] = frontendData.get(
"polarization",
eDVBFrontendParametersSatellite.Polarisation_Horizontal)
defaultSat["modulation"] = frontendData.get(
"modulation",
eDVBFrontendParametersSatellite.Modulation_QPSK)
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["orbpos"] = frontendData.get("orbital_position", 0)
self.scan_sat = ConfigSubsection()
self.scan_clearallservices = ConfigSelection(
default="no",
choices=[("no", _("no")), ("yes", _("yes")),
("yes_hold_feeds", _("yes (keep feeds)"))])
self.scan_onlyfree = ConfigYesNo(default=False)
self.scan_networkScan = ConfigYesNo(default=False)
nim_list = []
for n in nimmanager.nim_slots:
if hasattr(n, 'isFBCLink') and n.isFBCLink():
continue
if not self.legacy:
config = n.config.dvbs
else:
config = n.config
config_mode = config.configMode.value
if config_mode == "nothing":
continue
if n.isCompatible("DVB-S") and len(
nimmanager.getSatListForNim(n.slot)) < 1:
if config_mode in ("advanced", "simple"):
config.Nims[n.slot].configMode.value = "nothing"
config.Nims[n.slot].configMode.save()
continue
if config_mode in ("loopthrough", "satposdepends"):
root_id = nimmanager.sec.getRoot(n.slot_id,
int(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
if n.isCompatible("DVB-S"):
nim_list.append((str(n.slot), n.friendly_full_description))
self.scan_nims = ConfigSelection(choices=nim_list)
self.scan_sat.bs_system = ConfigSelection(
default=eDVBFrontendParametersSatellite.System_DVB_S2,
choices=[(eDVBFrontendParametersSatellite.System_DVB_S2,
_("DVB-S + DVB-S2")),
(eDVBFrontendParametersSatellite.System_DVB_S,
_("DVB-S only"))])
self.scan_sat.bs_accuracy = ConfigSelection(default=2,
choices=[
(1, "1"), (2, "2"),
(3, "3"), (4, "4"),
(5, "5")
])
self.search_type = ConfigSelection(default=0,
choices=[
(0, _("scan for channels")),
(1, _("save to XML file"))
])
self.scan_sat.bs_horizontal = ConfigYesNo(default=True)
self.scan_sat.bs_vertical = ConfigYesNo(default=True)
self.nim_sat_frequency_range = []
self.nim_sat_band_cutoff_frequency = []
self.scan_satselection = []
for slot in nimmanager.nim_slots:
slot_id = slot.slot
if slot.isCompatible("DVB-S"):
satlist_for_slot = self.satList[slot_id]
self.scan_satselection.append(
getConfigSatlist(defaultSat["orbpos"], satlist_for_slot))
sat_freq_range = {(10700000, 12750000)}
sat_band_cutoff = {11700000}
for sat in satlist_for_slot:
orbpos = sat[0]
self.nim_sat_frequency_range.append(sat_freq_range)
self.nim_sat_band_cutoff_frequency.append(sat_band_cutoff)
else:
self.nim_sat_frequency_range.append(None)
self.nim_sat_band_cutoff_frequency.append(None)
self.scan_satselection.append(None)
return True
def _(txt):
t = gettext.dgettext("EPGSearch", txt)
if t == txt:
t = gettext.gettext(txt)
return t
# Language
localeInit()
language.addCallback(localeInit)
config.plugins.epgsearch = ConfigSubsection()
config.plugins.epgsearch.history = ConfigSet(choices=[])
config.plugins.epgsearch.encoding = ConfigSelection(
[('UTF-8', 'UTF-8'), ('ISO8859-15', 'ISO8859-15')], default='UTF-8')
config.plugins.epgsearch.history_length = ConfigNumber(default=10)
config.plugins.epgsearch.add_search_to_epg = ConfigYesNo(default=True)
config.plugins.epgsearch.type_button_blue = ConfigSelection(
[('0', _("only Search")), ('1', _("choice (Search and standard)"))],
default='0')
config.plugins.epgsearch.picons = ConfigYesNo(default=False)
config.plugins.epgsearch.bouquet = ConfigYesNo(default=False)
config.plugins.epgsearch.favorit_name = ConfigYesNo(default=False)
config.plugins.epgsearch.show_in_furtheroptionsmenu = ConfigYesNo(default=True)
config.plugins.epgsearch.search_in_channelmenu = ConfigYesNo(default=True)
config.plugins.epgsearch.filter_type = ConfigSelection(
default="exact",
choices=[("partial", _("partial match")), ("exact", _("exact match"))])
config.plugins.epgsearch.search_case = ConfigSelection(
default="insensitive",
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()
###################################################
# FOREIGN import
###################################################
from Components.config import config, ConfigSelection, ConfigYesNo, getConfigListEntry
from datetime import datetime, timedelta
import re
import urllib
import time
###################################################
###################################################
# Config options for HOST
###################################################
config.plugins.iptvplayer.zdfmediathek_iconssize = ConfigSelection(
default="medium",
choices=[("large", _("large")), ("medium", _("medium")),
("small", _("small"))])
config.plugins.iptvplayer.zdfmediathek_prefformat = ConfigSelection(default = "mp4,m3u8", choices = [\
("mp4,m3u8", "mp4,m3u8"),("m3u8,mp4", "m3u8,mp4")])
config.plugins.iptvplayer.zdfmediathek_prefquality = ConfigSelection(
default="4",
choices=[("0", _("low")), ("1", _("medium")), ("2", _("high")),
("3", _("very high")), ("4", _("hd"))])
config.plugins.iptvplayer.zdfmediathek_prefmoreimportant = ConfigSelection(
default="quality",
choices=[("quality", _("quality")), ("format", _("format"))])
config.plugins.iptvplayer.zdfmediathek_onelinkmode = ConfigYesNo(default=True)
def GetConfigList():
optionList = []
def translateBlock(block):
for x in TranslationHelper:
if block.__contains__(x[0]):
block = block.replace(x[0], x[1])
return block
#############################################################
emuactive = 0
config.plugins.OscamSmartcard = ConfigSubsection()
#Oscam webifPort
config.plugins.OscamSmartcard.WebifPort = ConfigSelection(
default="83",
choices=[
("83", _("83")), #default
("8000", _("8000"))
])
# Smartcard oscam.server
config.plugins.OscamSmartcard.internalReader0 = ConfigSelection(
default="none",
choices=[("V13", _("Sky V13")), ("V13_fast", _("Sky V13 Fastmode")),
("V14", _("Sky V14")), ("V14_fast", _("Sky V14 Fastmode")),
("S02", _("Sky S02")), ("HD01", _("HD+ HD01 white")),
("HD02", _("HD+ HD02 black")), ("I02-Beta", _("I02 Beta")),
("I12-Beta", _("I12 Beta")), ("I12-Nagra", _("I12 Nagra")),
("V23", _("KabelBW V23")), ("ORF", _("ORF 0D05")),
("ORF_ICE_crypto", _("ORF ICE Cryptoworks 0D95")),
("ORF_ICE_irdeto", _("ORF ICE Irdeto 0648")),
("SRG-V2", _("SRG V2")), ("SRG-V4", _("SRG V4")),
("SRG-V5", _("SRG V5")), ("UM01", _("UnityMedia UM01")),
from Plugins.Plugin import PluginDescriptor
from Components.ServiceEventTracker import ServiceEventTracker
from Components.ServiceList import ServiceList
from Screens.InfoBar import InfoBar
from time import localtime, time
import Screens.Standby
BOX = getBoxType()
if BOX == 'gb800se' or BOX == 'gb800solo' or BOX == 'gb800ue':
from enigma import evfd
config.plugins.VFD_Giga = ConfigSubsection()
config.plugins.VFD_Giga.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_Giga.showClockDeepStandby = ConfigSelection(
default="False", choices=[("False", _("No")), ("True", _("Yes"))])
config.plugins.VFD_Giga.setLed = ConfigYesNo(default=True)
config.plugins.VFD_Giga.recLedBlink = ConfigYesNo(default=True)
led = [("0", _("None")), ("1", _("Blue")), ("2", _("Red")), ("3", _("Purple"))]
config.plugins.VFD_Giga.ledRUN = ConfigSelection(led, default="1")
config.plugins.VFD_Giga.ledSBY = ConfigSelection(led, default="2")
config.plugins.VFD_Giga.ledREC = ConfigSelection(led, default="3")
config.plugins.VFD_Giga.ledDSBY = ConfigSelection(led, default="2")
config.plugins.VFD_Giga.timeMode = ConfigSelection(default="24h",
choices=[("12h"), ("24h")])
RecLed = None
if gettext.dgettext(PluginLanguageDomain, txt):
return gettext.dgettext(PluginLanguageDomain, txt)
else:
return gettext.gettext(txt)
language.addCallback(localeInit())
#################################################
config.plugins.DVDBackup = ConfigSubsection()
config.plugins.DVDBackup.device = NoSave(ConfigText(default="/dev/sr0", fixed_size=False))
config.plugins.DVDBackup.directory = ConfigText(default="/media/hdd", fixed_size=False)
config.plugins.DVDBackup.name = NoSave(ConfigText(default=_("Name of DVD"), fixed_size=False))
config.plugins.DVDBackup.log = ConfigYesNo(default=True)
config.plugins.DVDBackup.show_message = ConfigYesNo(default=True)
config.plugins.DVDBackup.create_iso = ConfigSelection(default = "no", choices = [("no", _("no")),("genisoimage", _("with genisoimage (slower)")),("dd", _("with dd (faster)"))])
cfg = config.plugins.DVDBackup
#################################################
SESSION = None
def isCdromMount(file=None):
if file:
try:
f = open('/proc/mounts', 'r')
mnt = f.readlines()
f.close()
for line in mnt:
if line.startswith("/dev/sr0") and file in line:
return True
def createConfig(self):
afterevent = {
AFTEREVENT.NONE: "nothing",
AFTEREVENT.WAKEUP: "wakeup",
AFTEREVENT.WAKEUPTOSTANDBY: "wakeuptostandby",
AFTEREVENT.STANDBY: "standby",
AFTEREVENT.DEEPSTANDBY: "deepstandby"
}[self.timer.afterEvent]
timertype = {
TIMERTYPE.NONE: "nothing",
TIMERTYPE.WAKEUP: "wakeup",
TIMERTYPE.WAKEUPTOSTANDBY: "wakeuptostandby",
TIMERTYPE.AUTOSTANDBY: "autostandby",
TIMERTYPE.AUTODEEPSTANDBY: "autodeepstandby",
TIMERTYPE.STANDBY: "standby",
TIMERTYPE.DEEPSTANDBY: "deepstandby",
TIMERTYPE.REBOOT: "reboot",
TIMERTYPE.RESTART: "restart"
}[self.timer.timerType]
weekday_table = ("mon", "tue", "wed", "thu", "fri", "sat", "sun")
time_table = [(1,"1"),(3,"3"),(5,"5"),(10,"10"),(15,"15"),(30,"30"),(45,"45"),(60,"60"),
(75,"75"),(90,"90"),(105,"105"),(120,"120"),(135,"135"),(150,"150"),(165,"165"),(180,"180"),
(195,"195"),(210,"210"),(225,"225"),(240,"240"),(255,"255"),(270,"270"),(285,"285"),(300,"300")]
traffic_table = [(10,"10"),(50,"50"),(100,"100"),(500,"500"),(1000,"1000")]
# calculate default values
day = []
weekday = 0
for x in (0, 1, 2, 3, 4, 5, 6):
day.append(0)
if self.timer.repeated: # repeated
type = "repeated"
if self.timer.repeated == 31: # Mon-Fri
repeated = "weekdays"
elif self.timer.repeated == 127: # daily
repeated = "daily"
else:
flags = self.timer.repeated
repeated = "user"
count = 0
for x in (0, 1, 2, 3, 4, 5, 6):
if flags == 1: # weekly
print "Set to weekday " + str(x)
weekday = x
if flags & 1 == 1: # set user defined flags
day[x] = 1
count += 1
else:
day[x] = 0
flags >>= 1
if count == 1:
repeated = "weekly"
else: # once
type = "once"
repeated = None
weekday = int(strftime("%u", localtime(self.timer.begin))) - 1
day[weekday] = 1
if SystemInfo["DeepstandbySupport"]:
shutdownString = _("go to deep standby")
else:
shutdownString = _("shut down")
self.timerentry_timertype = ConfigSelection(choices = [("nothing", _("do nothing")),("wakeup", _("wakeup")),("wakeuptostandby", _("wakeup to standby")), ("autostandby", _("auto standby")), ("autodeepstandby", _("auto deepstandby")), ("standby", _("go to standby")), ("deepstandby", shutdownString), ("reboot", _("reboot system")), ("restart", _("restart GUI"))], default = timertype)
self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")),("wakeup", _("wakeup")), ("wakeuptostandby", _("wakeup to standby")), ("standby", _("go to standby")), ("deepstandby", shutdownString), ("nothing", _("do nothing"))], default = afterevent)
self.timerentry_type = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = type)
self.timerentry_repeated = ConfigSelection(default = repeated, choices = [("daily", _("daily")), ("weekly", _("weekly")), ("weekdays", _("Mon-Fri")), ("user", _("user defined"))])
self.timerrntry_autosleepdelay = ConfigSelection(choices = time_table, default = self.timer.autosleepdelay)
self.timerentry_autosleeprepeat = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = self.timer.autosleeprepeat)
self.timerrntry_autosleepinstandbyonly = ConfigSelection(choices = [("yes",_("only in Standby")), ("no", _("Standard (always)")), ("noquery", _("without Query"))],default = self.timer.autosleepinstandbyonly)
self.timerrntry_autosleepwindow = ConfigSelection(choices = [("yes",_("Yes")), ("no", _("No"))],default = self.timer.autosleepwindow)
self.timerrntry_autosleepbegin = ConfigClock(default = self.timer.autosleepbegin)
self.timerrntry_autosleepend = ConfigClock(default = self.timer.autosleepend)
self.timerentry_date = ConfigDateTime(default = self.timer.begin, formatstring = _("%d.%B %Y"), increment = 86400)
self.timerentry_starttime = ConfigClock(default = self.timer.begin)
self.timerentry_endtime = ConfigClock(default = self.timer.end)
self.timerentry_showendtime = ConfigSelection(default = (((self.timer.end - self.timer.begin) /60 ) > 4), choices = [(True, _("yes")), (False, _("no"))])
self.timerentry_repeatedbegindate = ConfigDateTime(default = self.timer.repeatedbegindate, formatstring = _("%d.%B %Y"), increment = 86400)
self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))])
self.timerentry_day = ConfigSubList()
for x in (0, 1, 2, 3, 4, 5, 6):
self.timerentry_day.append(ConfigYesNo(default = day[x]))
self.timerrntry_showExtended = ConfigSelection(default = (self.timer.nettraffic == "yes" or self.timer.netip == "yes"), choices = [(True, _("yes")), (False, _("no"))])
self.timerrntry_nettraffic = ConfigSelection(choices = [("yes",_("Yes")), ("no", _("No"))],default = self.timer.nettraffic)
self.timerrntry_trafficlimit = ConfigSelection(choices = traffic_table, default = self.timer.trafficlimit)
self.timerrntry_netip = ConfigSelection(choices = [("yes",_("Yes")), ("no", _("No"))],default = self.timer.netip)
self.timerrntry_ipadress = self.timer.ipadress.split(',')
self.ipcount = ConfigSelectionNumber(default = len(self.timerrntry_ipadress), stepwidth = 1, min = 1, max = 5)
self.ipadressEntry = ConfigSubList()
for x in (0, 1, 2, 3, 4, 5):
try:
self.ipadressEntry.append(ConfigIP(default = [int(n) for n in self.timerrntry_ipadress[x].split('.')] or [0,0,0,0]))
except:
self.ipadressEntry.append(ConfigIP(default = [0,0,0,0]))
config.plugins.epgrefresh.enabled = ConfigYesNo(default=False)
config.plugins.epgrefresh.begin = ConfigClock(default=int(begin))
config.plugins.epgrefresh.end = ConfigClock(default=int(end))
config.plugins.epgrefresh.interval_seconds = ConfigNumber(default=120)
config.plugins.epgrefresh.delay_standby = ConfigNumber(default=10)
config.plugins.epgrefresh.inherit_autotimer = ConfigYesNo(default=False)
config.plugins.epgrefresh.afterevent = ConfigYesNo(default=False)
config.plugins.epgrefresh.force = ConfigYesNo(default=False)
config.plugins.epgrefresh.enablemessage = ConfigYesNo(default=True)
config.plugins.epgrefresh.wakeup = ConfigYesNo(default=False)
config.plugins.epgrefresh.lastscan = ConfigNumber(default=0)
config.plugins.epgrefresh.parse_autotimer = ConfigYesNo(default=False)
config.plugins.epgrefresh.adapter = ConfigSelection(choices=[
("main", _("Main Picture")),
("pip", _("Picture in Picture")),
("pip_hidden", _("Picture in Picture (hidden)")),
("record", _("Fake recording")),
],
default="main")
config.plugins.epgrefresh.show_in_extensionsmenu = ConfigYesNo(default=False)
config.plugins.epgrefresh.show_help = ConfigYesNo(default=True)
# convert previous parameters
config.plugins.epgrefresh.background = ConfigYesNo(default=False)
if config.plugins.epgrefresh.background.value:
config.plugins.epgrefresh.adapter.value = "pip_hidden"
config.plugins.epgrefresh.background.value = False
config.plugins.epgrefresh.save()
config.plugins.epgrefresh.interval = ConfigNumber(default=2)
if config.plugins.epgrefresh.interval.value != 2:
config.plugins.epgrefresh.interval_seconds.value = config.plugins.epgrefresh.interval.value * 60
def fillList(self, arg=None):
from Tools.ISO639 import LanguageCodes
streams = []
conflist = []
selectedidx = 0
self["key_blue"].setBoolean(False)
subtitlelist = self.getSubtitleList()
if self.settings.menupage.getValue() == PAGE_AUDIO:
self.setTitle(_("Select audio track"))
service = self.session.nav.getCurrentService()
self.audioTracks = audio = service and service.audioTracks()
n = audio and audio.getNumberOfTracks() or 0
if SystemInfo["CanDownmixAC3"]:
if SystemInfo["DreamBoxAudio"]:
choice_list = [
("downmix", _("Downmix")),
("passthrough", _("Passthrough")),
("multichannel", _("convert to multi-channel PCM")),
("hdmi_best", _("use best / controlled by HDMI"))
]
self.settings.downmix_ac3 = ConfigSelection(
choices=choice_list,
default=config.av.downmix_ac3.value)
else:
self.settings.downmix_ac3 = ConfigOnOff(
default=config.av.downmix_ac3.value)
self.settings.downmix_ac3.addNotifier(self.changeAC3Downmix,
initial_call=False)
conflist.append(
getConfigListEntry(_("AC3 downmix"),
self.settings.downmix_ac3, None))
self["key_red"].setBoolean(True)
if n > 0:
self.audioChannel = service.audioChannel()
if self.audioChannel:
choicelist = [("0", _("left")), ("1", _("stereo")),
("2", _("right"))]
self.settings.channelmode = ConfigSelection(
choices=choicelist,
default=str(self.audioChannel.getCurrentChannel()))
self.settings.channelmode.addNotifier(self.changeMode,
initial_call=False)
conflist.append(
getConfigListEntry(_("Channel"),
self.settings.channelmode))
self["key_green"].setBoolean(True)
else:
conflist.append(('', ))
self["key_green"].setBoolean(False)
selectedAudio = self.audioTracks.getCurrentTrack()
for x in range(n):
number = str(x + 1)
i = audio.getTrackInfo(x)
languages = i.getLanguage().split('/')
description = i.getDescription() or ""
selected = ""
language = ""
if selectedAudio == x:
selected = "X"
selectedidx = x
cnt = 0
for lang in languages:
if cnt:
language += ' / '
if lang in LanguageCodes:
language += _(LanguageCodes[lang][0])
elif lang == "und":
""
else:
language += lang
cnt += 1
streams.append(
(x, "", number, description, language, selected))
else:
streams = []
conflist.append(('', ))
self["key_green"].setBoolean(False)
if subtitlelist:
self["key_yellow"].setBoolean(True)
conflist.append(
getConfigListEntry(_("To subtitle selection"),
self.settings.menupage))
else:
self["key_yellow"].setBoolean(False)
conflist.append(('', ))
if SystemInfo["Has3DSurround"]:
choice_list = [("none", _("off")), ("hdmi", _("HDMI")),
("spdif", _("SPDIF")), ("dac", _("DAC"))]
self.settings.surround_3d = ConfigSelection(
choices=choice_list, default=config.av.surround_3d.value)
self.settings.surround_3d.addNotifier(self.change3DSurround,
initial_call=False)
conflist.append(
getConfigListEntry(_("3D Surround"),
self.settings.surround_3d, None))
if SystemInfo[
"Has3DSpeaker"] and config.av.surround_3d.value != "none":
choice_list = [("center", _("center")), ("wide", _("wide")),
("extrawide", _("extra wide"))]
self.settings.surround_3d_speaker = ConfigSelection(
choices=choice_list,
default=config.av.surround_3d_speaker.value)
self.settings.surround_3d_speaker.addNotifier(
self.change3DSurroundSpeaker, initial_call=False)
conflist.append(
getConfigListEntry(_("3D Surround Speaker Position"),
self.settings.surround_3d_speaker,
None))
if SystemInfo["HasAutoVolume"]:
choice_list = [("none", _("off")), ("hdmi", _("HDMI")),
("spdif", _("SPDIF")), ("dac", _("DAC"))]
self.settings.autovolume = ConfigSelection(
choices=choice_list, default=config.av.autovolume.value)
self.settings.autovolume.addNotifier(self.changeAutoVolume,
initial_call=False)
conflist.append(
getConfigListEntry(_("Auto Volume Level"),
self.settings.autovolume, None))
from Components.PluginComponent import plugins
from Plugins.Plugin import PluginDescriptor
if hasattr(self.infobar, "runPlugin"):
class PluginCaller:
def __init__(self, fnc, *args):
self.fnc = fnc
self.args = args
def __call__(self, *args, **kwargs):
self.fnc(*self.args)
self.Plugins = [(p.name, PluginCaller(self.infobar.runPlugin,
p))
for p in plugins.getPlugins(
where=PluginDescriptor.WHERE_AUDIOMENU)]
if self.Plugins:
self["key_blue"].setBoolean(True)
if len(self.Plugins) > 1:
conflist.append(
getConfigListEntry(_("Audio plugins"),
ConfigNothing()))
self.plugincallfunc = [(x[0], x[1])
for x in self.Plugins]
else:
conflist.append(
getConfigListEntry(self.Plugins[0][0],
ConfigNothing()))
self.plugincallfunc = self.Plugins[0][1]
elif self.settings.menupage.getValue() == PAGE_SUBTITLES:
self.setTitle(_("Subtitle selection"))
conflist.append(('', ))
conflist.append(('', ))
self["key_red"].setBoolean(False)
self["key_green"].setBoolean(False)
idx = 0
for x in subtitlelist:
number = str(x[1])
description = "?"
language = ""
selected = ""
if config.subtitles.show.value and self.selectedSubtitle and x[:
4] == self.selectedSubtitle[:
4]:
selected = "X"
selectedidx = idx
try:
if x[4] != "und":
if x[4] in LanguageCodes:
language = _(LanguageCodes[x[4]][0])
else:
language = x[4]
except:
language = ""
if x[0] == 0:
description = "DVB"
number = "%x" % (x[1])
elif x[0] == 1:
description = "teletext"
number = "%x%02x" % (x[3] and x[3] or 8, x[2])
elif x[0] == 2:
types = (_("unknown"), _("embedded"), _("SSA file"),
_("ASS file"), _("SRT file"), _("VOB file"),
_("PGS file"))
try:
description = types[x[2]]
except:
description = _("unknown") + ": %s" % x[2]
number = str(int(number) + 1)
streams.append(
(x, "", number, description, language, selected))
idx += 1
conflist.append(
getConfigListEntry(_("To audio selection"),
self.settings.menupage))
if self.infobar.selected_subtitle and self.infobar.selected_subtitle != (
0, 0, 0, 0) and not ".DVDPlayer'>" in self.infobar:
self["key_blue"].setBoolean(True)
conflist.append(
getConfigListEntry(_("Subtitle Quickmenu"),
ConfigNothing()))
self["config"].list = conflist
self["config"].l.setList(conflist)
self["streams"].list = streams
self["streams"].setIndex(selectedidx)
otherinfobar = [("TemplatesInfoBarOther1", _("no")),
("TemplatesInfoBarOther2", _("rambler weather")),
("TemplatesInfoBarOther5", _("calendar")),
("TemplatesInfoBarOther6", _("rambler weather, calendar"))]
elif fileExists("/usr/lib/enigma2/python/Plugins/Extensions/WeatherMSN/plugin.pyo")\
and fileExists("/usr/lib/enigma2/python/Components/Converter/MSNWeather2.py"):
otherinfobar = [("TemplatesInfoBarOther1", _("no")),
("TemplatesInfoBarOther2", _("rambler weather")),
("TemplatesInfoBarOther3", _("msn weather")),
("TemplatesInfoBarOther4", _("msn weather full"))]
else:
otherinfobar = [("TemplatesInfoBarOther1", _("no")),
("TemplatesInfoBarOther2", _("rambler weather"))]
config.skin.neutron = ConfigSubsection()
config.skin.neutron.style = ConfigSelection(default="grey", choices=style)
config.skin.neutron.numberchannel = ConfigSelection(
default="TemplatesInfoBarNumber1", choices=numberchannel)
config.skin.neutron.styleinfobar = ConfigSelection(
default="TemplatesInfoBarTvPiconTuner", choices=styleinfobar)
config.skin.neutron.technicalinfobar = ConfigSelection(
default="TemplatesInfoBarTechnical1", choices=technicalinfobar)
config.skin.neutron.stylesecondinfobar = ConfigSelection(
default="TTemplatesInfoBarTvPiconTuner", choices=styleinfobar)
config.skin.neutron.technicalsecondinfobar = ConfigSelection(
default="TemplatesInfoBarTechnical1", choices=technicalinfobar)
config.skin.neutron.ecmepgpanel = ConfigSelection(
default="TemplatesInfoBarECMEPG5", choices=ecmepgpanel)
config.skin.neutron.epgchannelselection = ConfigSelection(
default="TemplatesChannelSelectionInfoEPG2", choices=epgchannelselection)
config.skin.neutron.infochannelselection = ConfigSelection(
def buildMy_rec(self, device):
mypath = SkinPath()
device2 = re.sub('[0-9]', '', device)
devicetype = path.realpath('/sys/block/' + device2 + '/device')
d2 = device
name = _('HARD DISK: ')
mypixmap = '' + LinkNeoBoot + '/images/dev_hdd.png'
model = open('/sys/block/' + device2 + '/device/model').read()
model = str(model).replace('\n', '')
des = ''
if devicetype.find('usb') != -1:
name = _('USB: ')
mypixmap = '' + LinkNeoBoot + '/images/dev_usb.png'
if devicetype.find('usb1') != -1:
name = _('USB1: ')
mypixmap = '' + LinkNeoBoot + '/images/dev_usb.png'
if devicetype.find('usb2') != -1:
name = _('USB2: ')
mypixmap = '' + LinkNeoBoot + '/images/dev_usb.png'
if devicetype.find('card') != -1:
name = _('CARD: ')
mypixmap = '' + LinkNeoBoot + '/images/dev_sd.png'
if devicetype.find('mmc') != -1:
name = _('MMC: ')
mypixmap = '' + LinkNeoBoot + '/images/dev_sd.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()
size = Harddisk(device).diskSize()
if float(size) / 1024 / 1024 >= 1:
des = _('Size: ') + str(round(float(size) / 1024 / 1024,
2)) + _('TB')
elif size / 1024 >= 1:
des = _('Size: ') + str(round(float(size) / 1024, 2)) + _('GB')
elif size >= 1:
des = _('Size: ') + str(size) + _('MB')
else:
des = _('Size: ') + _('unavailable')
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/usb1', '/media/usb1'),
('/media/usb2', '/media/usb2'),
('/media/usb3', '/media/usb3'),
('/media/usb3', '/media/cf'),
('/media/usb3', '/media/card'),
('/media/cf', '/media/cf'),
('/media/mmc', '/media/mmc'),
('/media/card', '/media/card')]))
if dtype == 'Linux':
dtype = 'ext2', 'ext3', 'ext4'
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
