<convert type="ConditionalShowHide">Invert</convert>
</widget>
<ePixmap pixmap="skin_default/div-h.png" position="10,152" zPosition="1" size="500,2" />
- <widget name="config" position="10,165" size="500,240" scrollbarMode="showOnDemand" />
+ <widget name="config" position="10,165" size="500,225" scrollbarMode="showOnDemand" />
</screen>
<!-- Scan setup -->
<screen name="ScanSetup" position="100,115" size="520,390" title="Service scan">
case signalQuality:
case signalQualitydB: /* this will move into the driver */
{
+ int sat_max = 1600; // for stv0288 / bsbe2
int ret = 0x12345678;
uint16_t snr=0;
if (m_simulate)
snr_in_db = fval1;
}
#endif
+ sat_max = 1750;
ret = (int)(snr_in_db * 100);
- ret -= 150; // -1.5db for latest bcm4501 firmware..
}
else if (strstr(m_description, "Alps BSBE1 C01A") ||
!strcmp(m_description, "Alps -S(STV0288)"))
!strcmp(m_description, "Philips -S") ||
!strcmp(m_description, "LG -S") )
{
+ sat_max = 1500;
ret = (int)((snr-39075)/17.647);
} else if (!strcmp(m_description, "Alps BSBE2"))
{
return snr;
switch(m_type)
{
- case feSatellite: // we assume a max of 16.0db here
- return ret >= 1600 ? 65536 : ret * 65536 / 1600;
+ case feSatellite:
+ return ret >= sat_max ? 65536 : ret * 65536 / sat_max;
case feCable: // we assume a max of 42db here
return ret >= 4200 ? 65536 : ret * 65536 / 4200;
case feTerrestrial: // we assume a max of 24db here
res = m_sec->prepare(*this, parm, feparm, 1 << m_slotid, tunetimeout);
if (!res)
{
+#if HAVE_DVB_API_VERSION >= 3
+ eDebugNoSimulate("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d",
+ feparm.system,
+ feparm.frequency,
+ feparm.polarisation,
+ feparm.symbol_rate,
+ feparm.inversion,
+ feparm.fec,
+ feparm.orbital_position,
+ feparm.system,
+ feparm.modulation,
+ feparm.pilot,
+ feparm.rolloff);
+#else
eDebugNoSimulate("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d orbpos %d",
feparm.system,
feparm.frequency,
feparm.inversion,
feparm.fec,
feparm.orbital_position);
+#endif
parm_u_qpsk_symbol_rate = feparm.symbol_rate;
switch (feparm.inversion)
{
{
}
- RESULT getSystem(int &type) const;
- RESULT getDVBS(eDVBFrontendParametersSatellite &) const;
- RESULT getDVBC(eDVBFrontendParametersCable &) const;
- RESULT getDVBT(eDVBFrontendParametersTerrestrial &) const;
+ SWIG_VOID(RESULT) getSystem(int &SWIG_OUTPUT) const;
+ SWIG_VOID(RESULT) getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const;
+ SWIG_VOID(RESULT) getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const;
+ SWIG_VOID(RESULT) getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const;
RESULT setDVBS(const eDVBFrontendParametersSatellite &p, bool no_rotor_command_on_tune=false);
RESULT setDVBC(const eDVBFrontendParametersCable &p);
RESULT setDVBT(const eDVBFrontendParametersTerrestrial &p);
-
+ SWIG_VOID(RESULT) getFlags(unsigned int &SWIG_NAMED_OUTPUT(flags)) const { flags = m_flags; return 0; }
+ RESULT setFlags(unsigned int flags) { m_flags = flags; return 0; }
+#ifndef SWIG
RESULT calculateDifference(const iDVBFrontendParameters *parm, int &, bool exact) const;
RESULT getHash(unsigned long &) const;
RESULT calcLockTimeout(unsigned int &) const;
-
- RESULT getFlags(unsigned int &flags) const { flags = m_flags; return 0; }
- RESULT setFlags(unsigned int flags) { m_flags = flags; return 0; }
+#endif
};
#ifndef SWIG
alpha_0_35, alpha_0_25, alpha_0_20
};
};
- // only 8psk
struct Pilot {
enum {
Off, On, Unknown
#endif
public:
enum { flagOnlyFree = 1 };
- virtual RESULT getSystem(int &SWIG_OUTPUT) const = 0;
- virtual RESULT getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const = 0;
- virtual RESULT getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const = 0;
- virtual RESULT getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const = 0;
-
- virtual RESULT calculateDifference(const iDVBFrontendParameters *parm, int &SWIG_OUTPUT, bool exact) const = 0;
- virtual RESULT getHash(unsigned long &SWIG_OUTPUT) const = 0;
- virtual RESULT calcLockTimeout(unsigned int &) const = 0;
- virtual RESULT getFlags(unsigned int &) const = 0;
+ virtual SWIG_VOID(RESULT) getSystem(int &SWIG_OUTPUT) const = 0;
+ virtual SWIG_VOID(RESULT) getDVBS(eDVBFrontendParametersSatellite &SWIG_OUTPUT) const = 0;
+ virtual SWIG_VOID(RESULT) getDVBC(eDVBFrontendParametersCable &SWIG_OUTPUT) const = 0;
+ virtual SWIG_VOID(RESULT) getDVBT(eDVBFrontendParametersTerrestrial &SWIG_OUTPUT) const = 0;
+ virtual SWIG_VOID(RESULT) getFlags(unsigned int &SWIG_OUTPUT) const = 0;
+#ifndef SWIG
+ virtual SWIG_VOID(RESULT) calculateDifference(const iDVBFrontendParameters *parm, int &, bool exact) const = 0;
+ virtual SWIG_VOID(RESULT) getHash(unsigned long &) const = 0;
+ virtual SWIG_VOID(RESULT) calcLockTimeout(unsigned int &) const = 0;
+#endif
};
SWIG_TEMPLATE_TYPEDEF(ePtr<iDVBFrontendParameters>, iDVBFrontendParametersPtr);
{
bool rotor=false;
eDVBSatelliteLNBParameters &lnb_param = m_lnbs[idx];
- if ( lnb_param.slot_mask & slot_id ) // lnb for correct tuner?
+ if ( lnb_param.m_slot_mask & slot_id ) // lnb for correct tuner?
{
int ret = 0;
eDVBSatelliteDiseqcParameters &di_param = lnb_param.m_diseqc_parameters;
ret=0;
}
+ if (ret && lnb_param.m_prio != -1)
+ ret = lnb_param.m_prio;
+
eSecDebugNoSimulate("ret %d, score old %d", ret, score);
if (ret > score)
{
}
}
if (score && satcount)
- score -= (satcount-1);
+ {
+ if (score > (satcount-1))
+ score -= (satcount-1);
+ else
+ score = 1; // min score
+ }
if (score && direct_connected)
score += 5; // increase score for tuners with direct sat connection
eSecDebugNoSimulate("final score %d", score);
for (int i=0; i <= m_lnbidx; ++i)
{
m_lnbs[i].m_satellites.clear();
- m_lnbs[i].slot_mask = 0;
+ m_lnbs[i].m_slot_mask = 0;
+ m_lnbs[i].m_prio = -1; // auto
}
m_lnbidx=-1;
{
eSecDebug("eDVBSatelliteEquipmentControl::setLNBSlotMask(%d)", slotmask);
if ( currentLNBValid() )
- m_lnbs[m_lnbidx].slot_mask = slotmask;
+ m_lnbs[m_lnbidx].m_slot_mask = slotmask;
else
return -ENOENT;
return 0;
return 0;
}
+RESULT eDVBSatelliteEquipmentControl::setLNBPrio(int prio)
+{
+ eSecDebug("eDVBSatelliteEquipmentControl::setLNBPrio(%d)", prio);
+ if ( currentLNBValid() )
+ m_lnbs[m_lnbidx].m_prio = prio;
+ else
+ return -ENOENT;
+ return 0;
+}
+
+
/* DiSEqC Specific Parameters */
RESULT eDVBSatelliteEquipmentControl::setDiSEqCMode(int diseqcmode)
{
#ifndef SWIG
t_12V_relais_state m_12V_relais_state; // 12V relais output on/off
- __u8 slot_mask; // useable by slot ( 1 | 2 | 4...)
+ int m_slot_mask; // useable by slot ( 1 | 2 | 4...)
unsigned int m_lof_hi, // for 2 band universal lnb 10600 Mhz (high band offset frequency)
m_lof_lo, // for 2 band universal lnb 9750 Mhz (low band offset frequency)
std::map<int, eDVBSatelliteSwitchParameters> m_satellites;
eDVBSatelliteDiseqcParameters m_diseqc_parameters;
eDVBSatelliteRotorParameters m_rotor_parameters;
+
+ int m_prio; // to override automatic tuner management ... -1 is Auto
#endif
};
RESULT setLNBLOFH(int lofh);
RESULT setLNBThreshold(int threshold);
RESULT setLNBIncreasedVoltage(bool onoff);
+ RESULT setLNBPrio(int prio);
/* DiSEqC Specific Parameters */
RESULT setDiSEqCMode(int diseqcmode);
RESULT setToneburst(int toneburst);
from Components.Element import cached
class RemainingToText(Converter, object):
+ DEFAULT = 0
+ WITH_SECONDS = 1
+ NO_SECONDS = 2
+
def __init__(self, type):
Converter.__init__(self, type)
+ if type == "WithSeconds":
+ self.type = self.WITH_SECONDS
+ elif type == "NoSeconds":
+ self.type = self.NO_SECONDS
+ else:
+ self.type = self.DEFAULT
@cached
def getText(self):
- r = self.source.time
- if r is None:
+ time = self.source.time
+ if time is None:
return ""
(duration, remaining) = self.source.time
- if remaining is not None:
- return "+%d min" % (remaining / 60)
+
+ if self.type == self.WITH_SECONDS:
+ if remaining is not None:
+ return "%d:%02d:%02d" % (remaining / 3600, (remaining / 60) - ((remaining / 3600) * 60), remaining % 60)
+ else:
+ return "%02d:%02d:%02d" % (duration / 3600, (duration / 60) - ((duration / 3600) * 60), duration % 60)
+ elif self.type == self.NO_SECONDS:
+ if remaining is not None:
+ return "+%d:%02d" % (remaining / 3600, (remaining / 60) - ((remaining / 3600) * 60))
+ else:
+ return "%02d:%02d" % (duration / 3600, (duration / 60) - ((duration / 3600) * 60))
+ elif self.type == self.DEFAULT:
+ if remaining is not None:
+ return "+%d min" % (remaining / 60)
+ else:
+ return "%d min" % (duration / 60)
else:
- return "%d min" % (duration / 60)
+ return "???"
text = property(getText)
self.negate = 'Negate' in args
self.detailed = 'Detailed' in args
self.showHours = 'ShowHours' in args
+ self.showNoSeconds = 'ShowNoSeconds' in args
if self.detailed:
self.poll_interval = 100
elif type == "Gauge":
self.type = self.TYPE_GAUGE
else:
- raise "type must be {Length|Position|Remaining|Gauge} with optional arguments {Negate|Detailed|ShowHours}"
+ raise "type must be {Length|Position|Remaining|Gauge} with optional arguments {Negate|Detailed|ShowHours|NoSeconds}"
self.poll_enabled = self.type != self.TYPE_LENGTH
if not self.detailed:
if self.showHours:
- return sign + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
+ if self.showNoSeconds:
+ return sign + "%d:%02d" % (l/3600, l%3600/60)
+ else:
+ return sign + "%d:%02d:%02d" % (l/3600, l%3600/60, l%60)
else:
- return sign + "%d:%02d" % (l/60, l%60)
+ if self.showNoSeconds:
+ return sign + "%d" % (l/60)
+ else:
+ return sign + "%d:%02d" % (l/60, l%60)
else:
if self.showHours:
return sign + "%d:%02d:%02d:%03d" % ((l/3600/90000), (l/90000)%3600/60, (l/90000)%60, (l%90000)/90)
sec.setLNBSlotMask(tunermask)
+ sec.setLNBPrio(int(currLnb.prio.value))
+
# finally add the orbital positions
for y in lnbSat[x]:
self.addSatellite(sec, y)
nim.advanced.lnb[x].fastTurningBegin = ConfigDateTime(default=mktime(btime.timetuple()), formatstring = _("%H:%M"), increment = 600)
etime = datetime(1970, 1, 1, 19, 0);
nim.advanced.lnb[x].fastTurningEnd = ConfigDateTime(default=mktime(etime.timetuple()), formatstring = _("%H:%M"), increment = 600)
+ prio_list = [ ("-1", _("Auto")) ]
+ for prio in range(65):
+ prio_list.append((str(prio), str(prio)))
+ for prio in range(14000,14065):
+ prio_list.append((str(prio), str(prio)))
+ for prio in range(19000,19065):
+ prio_list.append((str(prio), str(prio)))
+ nim.advanced.lnb[x].prio = ConfigSelection(default="-1", choices=prio_list)
elif slot.isCompatible("DVB-C"):
nim.configMode = ConfigSelection(
choices = {
tp_text = ""
if transponder:
tp_type = transponder.getSystem()
- if not tp_type[0]:
- tp_type = tp_type[1]
- if tp_type == iDVBFrontend.feSatellite:
- network = _("Satellite")
- tp = transponder.getDVBS()
- if not tp[0]:
- tp = tp[1]
- orb_pos = tp.orbital_position
- try:
- sat_name = str(nimmgr.getSatDescription(orb_pos))
- except KeyError:
- sat_name = ""
- if orb_pos > 1800: # west
- orb_pos = 3600 - orb_pos
- h = _("W")
- else:
- h = _("E")
- if sat_name.find("%d.%d" % (orb_pos/10, orb_pos%10)) != -1:
- network = sat_name
- else:
- network = ("%s %d.%d %s") % (sat_name, orb_pos / 10, orb_pos % 10, h)
- tp_text = ("%s %s %d%c / %d / %s") %( { 0 : "DVB-S", 1 : "DVB-S2" }[tp.system],
- { 0 : "Auto", 1 : "QPSK", 2 : "M8PSK", 3 : "QAM16" }[tp.modulation],
- tp.frequency/1000,
- { 0 : 'H', 1 : 'V', 2 : 'L', 3 : 'R' }[tp.polarisation],
- tp.symbol_rate/1000,
- { 0 : "AUTO", 1 : "1/2", 2 : "2/3", 3 : "3/4", 4 : "5/6",
- 5 : "7/8", 6 : "8/9", 7 : "3/5", 8 : "4/5", 9 : "9/10",
- 15 : "NONE" }[tp.fec] )
- elif tp_type == iDVBFrontend.feCable:
- network = _("Cable")
- tp = transponder.getDVBC()
- if not tp[0]:
- tp = tp[1]
- tp_text = ("DVB-C %s %d / %d / %s") %( { 0 : "AUTO", 1 : "QAM16", 2 : "QAM32", 3 : "QAM64", 4 : "QAM128", 5 : "QAM256" }[tp.modulation],
- tp.frequency,
- tp.symbol_rate/1000,
- { 0 : "AUTO", 1 : "1/2", 2 : "2/3", 3 : "3/4", 4 : "5/6", 5 : "7/8", 6 : "8/9", 15 : "NONE" }[tp.fec_inner] )
- elif tp_type == iDVBFrontend.feTerrestrial:
- network = _("Terrestrial")
- tp = transponder.getDVBT()
- if not tp[0]:
- tp = tp[1]
- tp_text = ("DVB-T %s %d %s") %( { 0 : "QPSK", 1 : "QAM16", 2 : "QAM64", 3 : "AUTO"}[tp.modulation],
- tp.frequency,
- { 0 : "Bw 8MHz", 1 : "Bw 7MHz", 2 : "Bw 6MHz", 3 : "Bw Auto" }[tp.bandwidth])
+ if tp_type == iDVBFrontend.feSatellite:
+ network = _("Satellite")
+ tp = transponder.getDVBS()
+ orb_pos = tp.orbital_position
+ try:
+ sat_name = str(nimmgr.getSatDescription(orb_pos))
+ except KeyError:
+ sat_name = ""
+ if orb_pos > 1800: # west
+ orb_pos = 3600 - orb_pos
+ h = _("W")
else:
- print "unknown transponder type in scanStatusChanged"
+ h = _("E")
+ if sat_name.find("%d.%d" % (orb_pos/10, orb_pos%10)) != -1:
+ network = sat_name
+ else:
+ network = ("%s %d.%d %s") % (sat_name, orb_pos / 10, orb_pos % 10, h)
+ tp_text = ("%s %s %d%c / %d / %s") %( { 0 : "DVB-S", 1 : "DVB-S2" }[tp.system],
+ { 0 : "Auto", 1 : "QPSK", 2 : "M8PSK", 3 : "QAM16" }[tp.modulation],
+ tp.frequency/1000,
+ { 0 : 'H', 1 : 'V', 2 : 'L', 3 : 'R' }[tp.polarisation],
+ tp.symbol_rate/1000,
+ { 0 : "AUTO", 1 : "1/2", 2 : "2/3", 3 : "3/4", 4 : "5/6",
+ 5 : "7/8", 6 : "8/9", 7 : "3/5", 8 : "4/5", 9 : "9/10",
+ 15 : "NONE" }[tp.fec] )
+ elif tp_type == iDVBFrontend.feCable:
+ network = _("Cable")
+ tp = transponder.getDVBC()
+ tp_text = ("DVB-C %s %d / %d / %s") %( { 0 : "AUTO", 1 : "QAM16", 2 : "QAM32", 3 : "QAM64", 4 : "QAM128", 5 : "QAM256" }[tp.modulation],
+ tp.frequency,
+ tp.symbol_rate/1000,
+ { 0 : "AUTO", 1 : "1/2", 2 : "2/3", 3 : "3/4", 4 : "5/6", 5 : "7/8", 6 : "8/9", 15 : "NONE" }[tp.fec_inner] )
+ elif tp_type == iDVBFrontend.feTerrestrial:
+ network = _("Terrestrial")
+ tp = transponder.getDVBT()
+ tp_text = ("DVB-T %s %d %s") %( { 0 : "QPSK", 1 : "QAM16", 2 : "QAM64", 3 : "AUTO"}[tp.modulation],
+ tp.frequency,
+ { 0 : "Bw 8MHz", 1 : "Bw 7MHz", 2 : "Bw 6MHz", 3 : "Bw Auto" }[tp.bandwidth])
+ else:
+ print "unknown transponder type in scanStatusChanged"
self.network.setText(network)
self.transponder.setText(tp_text)
config.seek.speeds_backward = ConfigSet(default=[8, 16, 32, 64, 128], choices=[1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128])
config.seek.speeds_slowmotion = ConfigSet(default=[2, 4, 8], choices=[2, 4, 6, 8, 12, 16, 25])
- config.seek.enter_forward = ConfigSelection(default = "2", choices = ["2"])
- config.seek.enter_backward = ConfigSelection(default = "2", choices = ["2"])
+ config.seek.enter_forward = ConfigSelection(default = "2", choices = ["2", "4", "6", "8", "12", "16", "24", "32", "48", "64", "96", "128"])
+ config.seek.enter_backward = ConfigSelection(default = "1", choices = ["1", "2", "4", "6", "8", "12", "16", "24", "32", "48", "64", "96", "128"])
config.seek.stepwise_minspeed = ConfigSelection(default = "16", choices = ["Never", "2", "4", "6", "8", "12", "16", "24", "32", "48", "64", "96", "128"])
config.seek.stepwise_repeat = ConfigSelection(default = "3", choices = ["2", "3", "4", "5", "6"])
configElement.value = [2]
updateChoices(config.seek.enter_forward, configElement.value)
- config.seek.speeds_forward.addNotifier(updateEnterForward)
+ config.seek.speeds_forward.addNotifier(updateEnterForward, immediate_feedback = False)
def updateEnterBackward(configElement):
if not configElement.value:
configElement.value = [2]
updateChoices(config.seek.enter_backward, configElement.value)
- config.seek.speeds_backward.addNotifier(updateEnterBackward)
+ config.seek.speeds_backward.addNotifier(updateEnterBackward, immediate_feedback = False)
def updateChoices(sel, choices):
if choices:
object.__init__(self)
self.saved_value = None
+ self.last_value = None
self.save_disabled = False
self.notifiers = []
+ self.notifiers_final = []
self.enabled = True
self.callNotifiersOnSaveAndCancel = False
for x in self.notifiers:
x(self)
- def addNotifier(self, notifier, initial_call = True):
+ def changedFinal(self):
+ for x in self.notifiers_final:
+ x(self)
+
+ def addNotifier(self, notifier, initial_call = True, immediate_feedback = True):
assert callable(notifier), "notifiers must be callable"
- self.notifiers.append(notifier)
-
+ if immediate_feedback:
+ self.notifiers.append(notifier)
+ else:
+ self.notifiers_final.append(notifier)
# CHECKME:
# do we want to call the notifier
# - at all when adding it? (yes, though optional)
pass
def onDeselect(self, session):
- pass
+ if not self.last_value == self.value:
+ self.changedFinal()
+ self.last_value = self.value
KEY_LEFT = 0
KEY_RIGHT = 1
ConfigElement.__init__(self)
self._value = None
self.setChoices(choices, default)
+ self.last_value = self._value
def setChoices(self, choices, default = None):
self.choices = []
def __init__(self, default = False, descriptions = {False: "false", True: "true"}):
ConfigElement.__init__(self)
self.descriptions = descriptions
- self.value = self.default = default
+ self.value = self.last_value = self.default = default
+
def handleKey(self, key):
if key in [KEY_LEFT, KEY_RIGHT]:
self.value = not self.value
else:
self.value = False
+ def onDeselect(self, session):
+ if not self.last_value == self.value:
+ self.changedFinal()
+ self.last_value = self.value
+
class ConfigYesNo(ConfigBoolean):
def __init__(self, default = False):
ConfigBoolean.__init__(self, default = default, descriptions = {False: _("no"), True: _("yes")})
ConfigElement.__init__(self)
self.increment = increment
self.formatstring = formatstring
- self.value = self.default = int(default)
+ self.value = self.last_value = self.default = int(default)
def handleKey(self, key):
if key == KEY_LEFT:
self.default = default
self.value = copy.copy(default)
+ self.last_value = copy.copy(default)
self.endNotifier = []
def fromstring(self, value):
return [int(x) for x in value.split(self.seperator)]
+ def onDeselect(self, session):
+ if not self.last_value == self._value:
+ self.changedFinal()
+ self.last_value = copy.copy(self._value)
+
class ConfigIP(ConfigSequence):
def __init__(self, default, auto_jump = False):
ConfigSequence.__init__(self, seperator = ".", limits = [(0,255),(0,255),(0,255),(0,255)], default = default)
self.offset = 0
self.overwrite = fixed_size
self.help_window = None
- self.value = self.default = default
+ self.value = self.last_value = self.default = default
def validateMarker(self):
if self.fixed_size:
if self.help_window:
session.deleteDialog(self.help_window)
self.help_window = None
+ if not self.last_value == self.value:
+ self.changedFinal()
+ self.last_value = self.value
def getHTML(self, id):
return '<input type="text" name="' + id + '" value="' + self.value + '" /><br>\n'
def onDeselect(self, session):
self.marked_pos = 0
self.offset = 0
+ if not self.last_value == self.value:
+ self.changedFinal()
+ self.last_value = self.value
class ConfigSearchText(ConfigText):
def __init__(self, default = "", fixed_size = False, visible_width = False):
class ConfigSlider(ConfigElement):
def __init__(self, default = 0, increment = 1, limits = (0, 100)):
ConfigElement.__init__(self)
- self.value = self.default = default
+ self.value = self.last_value = self.default = default
self.min = limits[0]
self.max = limits[1]
self.increment = increment
default = []
self.pos = -1
default.sort()
- self.default = default
+ self.last_value = self.default = default
self.value = default+[]
def toggleChoice(self, choice):
else:
self.value.append(choice)
self.value.sort()
+ self.changed()
def handleKey(self, key):
if key in KEY_NUMBERS + [KEY_DELETE, KEY_BACKSPACE]:
def onDeselect(self, session):
self.pos = -1
- self.changed()
+ if not self.last_value == self.value:
+ self.changedFinal()
+ self.last_value = self.value+[]
def tostring(self, value):
return str(value)
self.locations = []
self.mountpoints = []
harddiskmanager.on_partition_list_change.append(self.mountpointsChanged)
+ self.value = default+[]
def setValue(self, value):
loc = [x[0] for x in self.locations if x[3]]
from os import path as os_path, remove as os_remove, listdir as os_listdir, system
-from enigma import eTimer, iPlayableService, iServiceInformation, eServiceReference, iServiceKeys
+from enigma import eTimer, iPlayableService, iServiceInformation, eServiceReference, iServiceKeys, getDesktop
from Screens.Screen import Screen
from Screens.MessageBox import MessageBox
from Screens.ChoiceBox import ChoiceBox
self["Title"].setText(title)
class DVDOverlay(Screen):
- skin = """<screen name="DVDOverlay" position="0,0" size="720,576" flags="wfNoBorder" zPosition="-1" backgroundColor="transparent" />"""
def __init__(self, session, args = None):
+ desktop_size = getDesktop(0).size()
+ DVDOverlay.skin = """<screen name="DVDOverlay" position="0,0" size="%d,%d" flags="wfNoBorder" zPosition="-1" backgroundColor="transparent" />""" %(desktop_size.width(), desktop_size.height())
Screen.__init__(self, session)
-
+
class ChapterZap(Screen):
skin = """
<screen name="ChapterZap" position="235,255" size="250,60" title="Chapter" >
if file.mimetype == "video/x-dvd":
self.dvd_device = devicepath
print "physical dvd found:", self.dvd_device
- self.physicalDVD = True
+ self.physicalDVD = True
self.dvd_filelist = dvd_filelist
self.onFirstExecBegin.append(self.showFileBrowser)
def serviceStarted(self): #override InfoBarShowHide function
self.dvdScreen.show()
- subs = self.getServiceInterface("subtitle")
- if subs:
- subs.enableSubtitles(self.dvdScreen.instance, None)
def doEofInternal(self, playing):
if self.in_menu:
self.service = self.session.nav.getCurrentService()
print "self.service", self.service
print "cur_dlg", self.session.current_dialog
+ subs = self.getServiceInterface("subtitle")
+ if subs:
+ subs.enableSubtitles(self.dvdScreen.instance, None)
def exitCB(self, answer):
if answer is not None:
eServiceDVD::eServiceDVD(const char *filename):
m_filename(filename),
m_ddvdconfig(ddvd_create()),
- m_pixmap(new gPixmap(eSize(720, 576), 32)),
m_subtitle_widget(0),
m_state(stIdle),
m_current_trick(0),
m_pump(eApp, 1)
{
+ int aspect = DDVD_16_9;
+ int policy = DDVD_PAN_SCAN;
+
+ char tmp[255];
+ ssize_t rd;
+
m_sn = eSocketNotifier::create(eApp, ddvd_get_messagepipe_fd(m_ddvdconfig), eSocketNotifier::Read|eSocketNotifier::Priority|eSocketNotifier::Error|eSocketNotifier::Hungup);
- std::string aspect;
eDebug("SERVICEDVD construct!");
// create handle
ddvd_set_dvd_path(m_ddvdconfig, filename);
ddvd_set_ac3thru(m_ddvdconfig, 0);
ddvd_set_language(m_ddvdconfig, "de");
- if (ePythonConfigQuery::getConfigValue("config.av.aspect", aspect) != 0)
- aspect = "16_9";
- if (aspect == "4_3_letterbox")
- ddvd_set_video(m_ddvdconfig, DDVD_4_3_LETTERBOX, DDVD_PAL);
- else if (aspect == "4_3_panscan")
- ddvd_set_video(m_ddvdconfig, DDVD_4_3_PAN_SCAN, DDVD_PAL);
- else
- ddvd_set_video(m_ddvdconfig, DDVD_16_9, DDVD_PAL);
+ int fd = open("/proc/stb/video/aspect", O_RDONLY);
+ if (fd > -1)
+ {
+ rd = read(fd, tmp, 255);
+ if (rd > 2 && !strncmp(tmp, "4:3", 3))
+ aspect = DDVD_4_3;
+ else if (rd > 4 && !strncmp(tmp, "16:10", 5))
+ aspect = DDVD_16_10;
+ close(fd);
+ }
+
+ fd = open("/proc/stb/video/policy", O_RDONLY);
+ if (fd > -1)
+ {
+ rd = read(fd, tmp, 255);
+ if (rd > 6 && !strncmp(tmp, "bestfit", 7))
+ policy = DDVD_JUSTSCALE;
+ else if (rd > 8 && !strncmp(tmp, "letterbox", 9))
+ policy = DDVD_LETTERBOX;
+ close(fd);
+ }
+
+ ddvd_set_video(m_ddvdconfig, aspect, policy, DDVD_PAL /*unused*/);
- ddvd_set_lfb(m_ddvdconfig, (unsigned char *)m_pixmap->surface->data, 720, 576, 4, 720*4);
CONNECT(m_sn->activated, eServiceDVD::gotMessage);
CONNECT(m_pump.recv_msg, eServiceDVD::gotThreadMessage);
strcpy(m_ddvd_titlestring,"");
}
case DDVD_SCREEN_UPDATE:
eDebug("DVD_SCREEN_UPDATE!");
- if (m_subtitle_widget)
- m_subtitle_widget->setPixmap(m_pixmap, eRect(0, 0, 720, 576));
+ if (m_subtitle_widget) {
+ int x1,x2,y1,y2;
+ ddvd_get_last_blit_area(m_ddvdconfig, &x1, &x2, &y1, &y2);
+ m_subtitle_widget->setPixmap(m_pixmap, eRect(x1, y1, x2-x1, y2-y1));
+ }
break;
case DDVD_SHOWOSD_STATE_PLAY:
{
kill();
saveCuesheet();
ddvd_close(m_ddvdconfig);
+ disableSubtitles(0);
}
RESULT eServiceDVD::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
assert(m_state == stIdle);
m_state = stRunning;
eDebug("eServiceDVD starting");
- run();
// m_event(this, evStart);
return 0;
}
RESULT eServiceDVD::enableSubtitles(eWidget *parent, SWIG_PYOBJECT(ePyObject) /*entry*/)
{
- if (m_subtitle_widget)
- delete m_subtitle_widget;
+ delete m_subtitle_widget;
+
m_subtitle_widget = new eSubtitleWidget(parent);
m_subtitle_widget->resize(parent->size());
- m_subtitle_widget->setPixmap(m_pixmap, eRect(0, 0, 720, 576));
+
+ eSize size = parent->size();
+
+ if (!m_pixmap)
+ {
+ m_pixmap = new gPixmap(size, 32);
+ ddvd_set_lfb(m_ddvdconfig, (unsigned char *)m_pixmap->surface->data, size.width(), size.height(), 4, size.width()*4);
+ run(); // start the thread
+ }
+
m_subtitle_widget->setZPosition(-1);
m_subtitle_widget->show();
+
return 0;
}
Screen.__init__(self, session)
self.feid = feid
self.oldref = None
-
+
+ cur = { }
if not self.openFrontend():
self.oldref = session.nav.getCurrentlyPlayingServiceReference()
+ service = session.nav.getCurrentService()
+ feInfo = service and service.frontendInfo()
+ if feInfo:
+ cur = feInfo.getTransponderData(True)
+ del feInfo
+ del service
session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if session.pipshown: # try to disable pip
+ service = self.session.pip.pipservice
+ feInfo = service and service.frontendInfo()
+ if feInfo:
+ cur = feInfo.getTransponderData()
+ del feInfo
+ del service
session.pipshown = False
del session.pip
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
-
+
self.frontendStatus = { }
-
self.diseqc = Diseqc(self.frontend)
self.tuner = Tuner(self.frontend)
- self.tuner.tune((0,0,0,0,0,0))
+
+ tp = ( cur.get("frequency", 0) / 1000,
+ cur.get("symbol_rate", 0) / 1000,
+ { "HORIZONTAL" : 0, "VERTICAL" : 1,
+ "CIRCULAR_LEFT" : 2, "CIRCULAR_RIGHT" : 3 }[cur.get("polarization", "HORIZONTAL")],
+ { "FEC_AUTO" : 0, "FEC_1_2" : 1, "FEC_2_3" : 2, "FEC_3_4" : 3,
+ "FEC_5_6" : 4, "FEC_7_8" : 5, "FEC_8_9" : 6, "FEC_3_5" : 7,
+ "FEC_4_5" : 8, "FEC_9_10" : 9, "FEC_NONE" : 15 }[cur.get("fec_inner", "FEC_AUTO")],
+ { "INVERSION_OFF" : 0,
+ "INVERSION_ON" : 1,
+ "INVERSION_AUTO" : 2 }[cur.get("inversion", "INVERSION_AUTO")],
+ cur.get("orbital_position", 0),
+ { "DVB-S" : 0, "DVB-S2" : 1 }[cur.get("system", "DVB-S")],
+ { "QPSK" : 1, "8PSK" : 2 }[cur.get("modulation", "QPSK")],
+ { "ROLLOFF_0_35" : 0, "ROLLOFF_0_25" : 1,
+ "ROLLOFF_0_20" : 2 }[cur.get("rolloff", "ROLLOFF_0_35")],
+ { "PILOT_OFF" : 0, "PILOT_ON" : 1,
+ "PILOT_AUTO" : 2 }[cur.get("pilot", "PILOT_AUTO")]
+ )
+
+ self.tuner.tune(tp)
self.createConfig()
elif entry == "limits":
self.diseqccommand("limitOff")
elif entry == "tune":
- self.session.openWithCallback(self.tune, TunerScreen, self.feid)
+ fe_data = { }
+ self.frontend.getFrontendData(fe_data)
+ self.frontend.getTransponderData(fe_data, True)
+ feparm = self.tuner.lastparm.getDVBS()
+ fe_data["orbital_position"] = feparm.orbital_position
+ self.session.openWithCallback(self.tune, TunerScreen, self.feid, fe_data)
elif entry == "goto0":
print "move to position 0"
self.diseqccommand("moveTo", 0)
elif entry == "storage":
print "store at position", int(self.positioner_storage.value)
self.diseqccommand("store", int(self.positioner_storage.value))
+
elif entry == "limits":
self.diseqccommand("limitWest")
parm.fec = transponder[3]
parm.inversion = transponder[4]
parm.orbital_position = transponder[5]
- parm.system = 0 # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2)
- parm.modulation = 1 # FIXMEE !! HARDCODED QPSK
+ parm.system = transponder[6]
+ parm.modulation = transponder[7]
+ parm.rolloff = transponder[8]
+ parm.pilot = transponder[9]
feparm = eDVBFrontendParameters()
feparm.setDVBS(parm, True)
self.lastparm = feparm
<widget name="introduction" position="20,360" size="350,30" font="Regular;23" />
</screen>"""
- def __init__(self, session, feid):
+ def __init__(self, session, feid, fe_data):
self.feid = feid
+ self.fe_data = fe_data
ScanSetup.__init__(self, session)
self["introduction"].setText("")
self.list.append(self.typeOfTuningEntry)
self.satEntry = getConfigListEntry(_('Satellite'), tuning.sat)
self.list.append(self.satEntry)
+ nim = nimmanager.nim_slots[self.feid]
+ self.systemEntry = None
+
if tuning.type.value == "manual_transponder":
+ if nim.isCompatible("DVB-S2"):
+ self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
+ self.list.append(self.systemEntry)
+ else:
+ # downgrade to dvb-s, in case a -s2 config was active
+ self.scan_sat.system.value = "dvb-s"
self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
- self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
+ if self.scan_sat.system.value == "dvb-s":
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
+ elif self.scan_sat.system.value == "dvb-s2":
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+ self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
+ self.list.append(self.modulationEntry)
+ self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff))
+ self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
elif tuning.type.value == "predefined_transponder":
self.list.append(getConfigListEntry(_("Transponder"), tuning.transponder))
self["config"].list = self.list
self["config"].l.setList(self.list)
def newConfig(self):
- if self["config"].getCurrent() == self.typeOfTuningEntry:
- self.createSetup()
- elif self["config"].getCurrent() == self.satEntry:
+ if self["config"].getCurrent() in (self.typeOfTuningEntry, self.satEntry, self.systemEntry):
self.createSetup()
def createConfig(self, foo):
tuning.sat = ConfigSatlist(list=nimmanager.getRotorSatListForNim(self.feid))
tuning.sat.addNotifier(self.tuningSatChanged)
self.updateTransponders()
- TunerScreenConfigCreated = True
- ScanSetup.createConfig(self, None)
+ orb_pos = self.fe_data.get("orbital_position", None)
+ if orb_pos is not None:
+ for x in nimmanager.getRotorSatListForNim(self.feid):
+ opos = str(orb_pos)
+ if x[0] == orb_pos and tuning.sat.value != opos:
+ tuning.sat.value = opos
+ del self.fe_data["orbital_position"]
+ ScanSetup.createConfig(self, self.fe_data)
def tuningSatChanged(self, *parm):
self.updateTransponders()
tuning.transponder = ConfigSelection(choices=tps)
def keyGo(self):
- returnvalue = (0, 0, 0, 0, 0, 0)
+ returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
satpos = int(tuning.sat.value)
if tuning.type.value == "manual_transponder":
+ if self.scan_sat.system.value == "dvb-s2":
+ fec = self.scan_sat.fec_s2.value
+ else:
+ fec = self.scan_sat.fec.value
returnvalue = (
self.scan_sat.frequency.value,
self.scan_sat.symbolrate.value,
self.scan_sat.polarization.index,
- self.scan_sat.fec.index,
+ { "auto": 0,
+ "1_2": 1,
+ "2_3": 2,
+ "3_4": 3,
+ "5_6": 4,
+ "7_8": 5,
+ "8_9": 6,
+ "3_5": 7,
+ "4_5": 8,
+ "9_10": 9,
+ "none": 15 }[fec],
self.scan_sat.inversion.index,
- satpos)
+ satpos,
+ self.scan_sat.system.index,
+ self.scan_sat.modulation.index == 1 and 2 or 1,
+ self.scan_sat.rolloff.index,
+ self.scan_sat.pilot.index)
elif tuning.type.value == "predefined_transponder":
transponder = nimmanager.getTransponders(satpos)[tuning.transponder.index]
- returnvalue = (int(transponder[1] / 1000), int(transponder[2] / 1000), transponder[3], transponder[4], 2, satpos)
+ returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
+ transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
self.close(returnvalue)
def keyCancel(self):
class RotorNimSelection(Screen):
skin = """
- <screen position="140,165" size="400,100" title="select Slot">
- <widget name="nimlist" position="20,10" size="360,75" />
+ <screen position="140,165" size="400,130" title="select Slot">
+ <widget name="nimlist" position="20,10" size="360,100" />
</screen>"""
def __init__(self, session):
parm.fec = transponder[3]
parm.inversion = transponder[4]
parm.orbital_position = transponder[5]
- parm.system = 0 # FIXMEE !! HARDCODED DVB-S (add support for DVB-S2)
- parm.modulation = 1 # FIXMEE !! HARDCODED QPSK
+ parm.system = transponder[6]
+ parm.modulation = transponder[7]
+ parm.rolloff = transponder[8]
+ parm.pilot = transponder[9]
feparm = eDVBFrontendParameters()
- feparm.setDVBS(parm)
+ feparm.setDVBS(parm, True)
self.lastparm = feparm
self.frontend.tune(feparm)
-
+
def retune(self):
if self.frontend:
self.frontend.tune(self.lastparm)
self.satEntry = None
self.list = []
+
self.typeOfTuningEntry = getConfigListEntry(_('Tune'), self.tuning_type)
self.list.append(self.typeOfTuningEntry)
self.satEntry = getConfigListEntry(_('Satellite'), self.tuning_sat)
self.list.append(self.satEntry)
+
+ nim = nimmanager.nim_slots[self.feid]
+
+ self.systemEntry = None
if self.tuning_type.value == "manual_transponder":
+ if nim.isCompatible("DVB-S2"):
+ self.systemEntry = getConfigListEntry(_('System'), self.scan_sat.system)
+ self.list.append(self.systemEntry)
+ else:
+ # downgrade to dvb-s, in case a -s2 config was active
+ self.scan_sat.system.value = "dvb-s"
self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
- self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
+ if self.scan_sat.system.value == "dvb-s":
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
+ elif self.scan_sat.system.value == "dvb-s2":
+ self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+ self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
+ self.list.append(self.modulationEntry)
+ self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff))
+ self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))
elif self.tuning_transponder and self.tuning_type.value == "predefined_transponder":
self.list.append(getConfigListEntry(_("Transponder"), self.tuning_transponder))
self["config"].list = self.list
self["config"].l.setList(self.list)
def newConfig(self):
- if self["config"].getCurrent() == self.typeOfTuningEntry:
+ cur = self["config"].getCurrent()
+ if cur in (self.typeOfTuningEntry, self.systemEntry):
self.createSetup()
- elif self["config"].getCurrent() == self.satEntry:
+ elif cur == self.satEntry:
self.updateSats()
self.createSetup()
self.retune(config_element)
def retune(self, configElement):
- returnvalue = (0, 0, 0, 0, 0, 0, 0)
- satpos = self.tuning_sat.orbital_position
-
- if satpos is not None:
- if self.tuning_type.value == "manual_transponder":
- returnvalue = (self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, self.scan_sat.polarization.index, self.scan_sat.fec.index, self.scan_sat.inversion.index, satpos)
+ returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+ satpos = int(self.tuning_sat.value)
+ if self.tuning_type.value == "manual_transponder":
+ if self.scan_sat.system.value == "dvb-s2":
+ fec = self.scan_sat.fec_s2.value
+ else:
+ fec = self.scan_sat.fec.value
+ returnvalue = (
+ self.scan_sat.frequency.value,
+ self.scan_sat.symbolrate.value,
+ self.scan_sat.polarization.index,
+ { "auto": 0,
+ "1_2": 1,
+ "2_3": 2,
+ "3_4": 3,
+ "5_6": 4,
+ "7_8": 5,
+ "8_9": 6,
+ "3_5": 7,
+ "4_5": 8,
+ "9_10": 9,
+ "none": 15 }[fec],
+ self.scan_sat.inversion.index,
+ satpos,
+ self.scan_sat.system.index,
+ self.scan_sat.modulation.index == 1 and 2 or 1,
+ self.scan_sat.rolloff.index,
+ self.scan_sat.pilot.index)
+ self.tune(returnvalue)
+ elif self.tuning_type.value == "predefined_transponder":
+ tps = nimmanager.getTransponders(satpos)
+ l = len(tps)
+ if l > self.tuning_transponder.index:
+ transponder = tps[self.tuning_transponder.index]
+ returnvalue = (transponder[1] / 1000, transponder[2] / 1000,
+ transponder[3], transponder[4], 2, satpos, transponder[5], transponder[6], transponder[8], transponder[9])
self.tune(returnvalue)
- elif self.tuning_type.value == "predefined_transponder":
- tps = nimmanager.getTransponders(satpos)
- l = len(tps)
- if l > self.tuning_transponder.index:
- transponder = nimmanager.getTransponders(satpos)[self.tuning_transponder.index]
- returnvalue = (int(transponder[1] / 1000), int(transponder[2] / 1000), transponder[3], transponder[4], 2, satpos)
- self.tune(returnvalue)
def createConfig(self, foo):
self.tuning_transponder = None
ScanSetup.createConfig(self, None)
self.updateSats()
-
- self.tuning_type.addNotifier(self.retune, initial_call = False)
- self.tuning_sat.addNotifier(self.sat_changed, initial_call = False)
- self.scan_sat.frequency.addNotifier(self.retune, initial_call = False)
- self.scan_sat.inversion.addNotifier(self.retune, initial_call = False)
- self.scan_sat.symbolrate.addNotifier(self.retune, initial_call = False)
- self.scan_sat.polarization.addNotifier(self.retune, initial_call = False)
- self.scan_sat.fec.addNotifier(self.retune, initial_call = False)
+
+ for x in (self.tuning_type, self.tuning_sat, self.scan_sat.frequency,
+ self.scan_sat.inversion, self.scan_sat.symbolrate,
+ self.scan_sat.polarization, self.scan_sat.fec, self.scan_sat.pilot,
+ self.scan_sat.fec_s2, self.scan_sat.fec, self.scan_sat.modulation,
+ self.scan_sat.rolloff, self.scan_sat.system):
+ x.addNotifier(self.retune, initial_call = False)
def updateSats(self):
orb_pos = self.tuning_sat.orbital_position
class SatNimSelection(Screen):
skin = """
- <screen position="140,165" size="400,100" title="select Slot">
- <widget name="nimlist" position="20,10" size="360,75" />
+ <screen position="140,165" size="400,130" title="select Slot">
+ <widget name="nimlist" position="20,10" size="360,100" />
</screen>"""
def __init__(self, session):
self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold))
# self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v))
self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage))
+ self.list.append(getConfigListEntry(_("Priority"), currLnb.prio))
def fillAdvancedList(self):
self.list = [ ]
ttype = frontendData.get("tuner_type", "UNKNOWN")
if ttype == "DVB-S":
defaultSat["system"] = {"DVB-S": "dvb-s", "DVB-S2": "dvb-s2"}[frontendData.get("system", "DVB-S")]
- defaultSat["frequency"] = int(frontendData.get("frequency", 0) / 1000)
+ defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
defaultSat["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")]
- defaultSat["symbolrate"] = int(frontendData.get("symbol_rate", 0) / 1000)
+ defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultSat["polarization"] = {"HORIZONTAL": "horizontal", "VERTICAL": "vertical", "CIRCULAR_LEFT": "circular_left", "CIRCULAR_RIGHT": "circular_right", "UNKNOWN": None}[frontendData.get("polarization", "HORIZONTAL")]
if frontendData.get("system", "DVB-S") == "DVB-S2":
defaultSat["modulation"] = {"QPSK": "qpsk", "8PSK": "8psk"}[frontendData.get("modulation", "QPSK")]
defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
elif ttype == "DVB-C":
- defaultCab["frequency"] = int(frontendData.get("frequency", 0) / 1000)
- defaultCab["symbolrate"] = int(frontendData.get("symbol_rate", 0) / 1000)
+ defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
+ defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
defaultCab["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")]
defaultCab["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_NONE": "none"}[frontendData.get("fec_inner", "FEC_AUTO")]
defaultCab["modulation"] = {"QAM_AUTO": "auto", "QAM_16": "16qam", "QAM_32": "32qam", "QAM_64": "64qam", "QAM_128": "128qam", "QAM_256": "256qam"}[frontendData.get("modulation", "QAM_16")]
self.scan_satselection = []
for slot in nimmanager.nim_slots:
if slot.isCompatible("DVB-S"):
- self.scan_satselection.append(getConfigSatlist(int(defaultSat["orbpos"]), self.satList[slot.slot]))
+ self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]))
else:
self.scan_satselection.append(None)
parm.polarisation = polarisation
parm.fec = self.fecmap[fec]
parm.inversion = inversion
- parm.orbital_position = int(orbital_position)
- parm.rolloff = int(rolloff)
- parm.pilot = int(pilot)
+ parm.orbital_position = orbital_position
+ parm.rolloff = rolloff
+ parm.pilot = pilot
tlist.append(parm)
def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
import string
from Screens.HelpMenu import HelpableScreen
-from Components.config import config, KEY_LEFT, KEY_RIGHT, KEY_DELETE, KEY_BACKSPACE
+from Components.config import config, KEY_LEFT, KEY_RIGHT, KEY_HOME, KEY_END, KEY_0, KEY_DELETE, KEY_BACKSPACE, KEY_OK, KEY_TOGGLEOW, KEY_ASCII, KEY_TIMEOUT, KEY_NUMBERS
+
from Components.Label import Label
from Components.Slider import Slider
from Components.ActionMap import NumberActionMap
self.disableKeys = False
- self["actions"] = NumberActionMap(["WizardActions", "NumberActions", "ColorActions", "SetupActions"],
+ self["actions"] = NumberActionMap(["WizardActions", "NumberActions", "ColorActions", "SetupActions", "InputAsciiActions"],
{
+ "gotAsciiCode": self.keyGotAscii,
"ok": self.ok,
"back": self.back,
"left": self.left,
def keyNumberGlobal(self, number):
if (self.wizard[self.currStep]["config"]["screen"] != None):
self.configInstance.keyNumberGlobal(number)
+
+ def keyGotAscii(self):
+ if (self.wizard[self.currStep]["config"]["screen"] != None):
+ self["config"].handleKey(KEY_ASCII)
def left(self):
self.resetCounter()
return false;
}
-static void PutToDict(ePyObject &dict, const char*key, long value)
+static void PutToDictAsStr(ePyObject &dict, const char*key, long value)
{
ePyObject item = PyString_FromFormat("%d", value);
if (item)
eDebug("could not create PyObject for %s", key);
}
+extern void PutToDict(ePyObject &dict, const char*key, long value); // defined in dvb/frontend.cpp
+extern void PutToDict(ePyObject &dict, const char*key, ePyObject item); // defined in dvb/frontend.cpp
extern void PutToDict(ePyObject &dict, const char*key, const char *value); // defined in dvb/frontend.cpp
void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm)
{
const char *tmp=0;
PutToDict(dict, "type", "Satellite");
- PutToDict(dict, "frequency", feparm.frequency);
- PutToDict(dict, "symbolrate", feparm.symbol_rate);
- PutToDict(dict, "orbital position", feparm.orbital_position);
+ PutToDictAsStr(dict, "frequency", feparm.frequency);
+ PutToDictAsStr(dict, "symbolrate", feparm.symbol_rate);
+ PutToDictAsStr(dict, "orbital position", feparm.orbital_position);
switch (feparm.inversion)
{
case eDVBFrontendParametersSatellite::Inversion::On: tmp="ON"; break;
void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm)
{
PutToDict(dict, "type", "Terrestrial");
- PutToDict(dict, "frequency", feparm.frequency);
+ PutToDictAsStr(dict, "frequency", feparm.frequency);
const char *tmp=0;
switch (feparm.bandwidth)
{
{
const char *tmp=0;
PutToDict(dict, "type", "Cable");
- PutToDict(dict, "frequency", feparm.frequency);
- PutToDict(dict, "symbolrate", feparm.symbol_rate);
+ PutToDictAsStr(dict, "frequency", feparm.frequency);
+ PutToDictAsStr(dict, "symbolrate", feparm.symbol_rate);
switch (feparm.modulation)
{
case eDVBFrontendParametersCable::Modulation::QAM16: tmp="QAM16"; break;
eDVBFrontendParametersSatellite osat;
if (!feparm->getDVBS(osat))
{
- void PutToDict(ePyObject &, const char*, long);
- void PutToDict(ePyObject &, const char*, const char*);
PutToDict(ret, "orbital_position", osat.orbital_position);
const char *tmp = "UNKNOWN";
switch(osat.polarisation)
return 0;
}
-extern void PutToDict(ePyObject &dict, const char*key, ePyObject item); // defined in dvb/frontend.cpp
-
PyObject *eDVBServicePlay::getStreamingData()
{
eDVBServicePMTHandler::program program;
{
uint8_t demux_id;
if (!demux->getCADemuxID(demux_id))
- PutToDict(r, "demux", PyInt_FromLong(demux_id));
+ PutToDict(r, "demux", demux_id);
}
return r;
return 0;
}
-extern void PutToDict(ePyObject &dict, const char*key, ePyObject item); // defined in dvb/frontend.cpp
+extern void PutToDict(ePyObject &dict, const char*key, long val); // defined in dvb/frontend.cpp
PyObject *eDVBServiceRecord::getStreamingData()
{
{
uint8_t demux_id;
if (!demux->getCADemuxID(demux_id))
- PutToDict(r, "demux", PyInt_FromLong(demux_id));
+ PutToDict(r, "demux", demux_id);
}
return r;
projects / vuplus_dvbapp / commitdiff