lib/python/Plugins/SystemPlugins/SatelliteEquipmentControl/Makefile
lib/python/Plugins/SystemPlugins/Videomode/Makefile
lib/python/Plugins/SystemPlugins/VideoTune/Makefile
+lib/python/Plugins/SystemPlugins/DiseqcTester/Makefile
lib/python/Plugins/DemoPlugins/Makefile
lib/python/Plugins/DemoPlugins/TestPlugin/Makefile
lib/python/Plugins/Extensions/Makefile
</screen>
<!-- Subtitle area -->
<screen name="SubtitleDisplay" position="0,0" size="720,576" zPosition="-1" flags="wfNoBorder" backgroundColor="transparent" />
+ <!-- TextBox -->
+ <screen name="TextBox" position="90,50" size="550,400" title="Message...">
+ <widget name="text" position="0,0" size="540,390" font="Regular;18" />
+ <!--widget source="text" render="Label" position="0,0" size="540,390" font="Regular;18" /-->
+ </screen>
<!-- Time & date input -->
<screen name="TimeDateInput" position="160,150" size="400,200" title="Time/Date Input">
<widget name="cancel" pixmap="skin_default/buttons/red.png" position="10,0" size="140,40" alphatest="on" />
return Py_False;
}
int tmp, *dest = NULL,
- modulation, system, freq, sr, pol, fec, inv, pilot, rolloff;
+ modulation, system, freq, sr, pol, fec, inv, pilot, rolloff, tsid, onid;
char *end_ptr;
const Attribute *at;
std::string name;
inv = 2; // AUTO default
pilot = 2; // AUTO default
rolloff = 0; // alpha 0.35
+ tsid = -1;
+ onid = -1;
+
for (AttributeConstIterator it(tp_attributes.begin()); it != end; ++it)
{
-// eDebug("\t\tattr: %s", at->name().c_str());
+ //eDebug("\t\tattr: %s", at->name().c_str());
at = *it;
name = at->name();
if (name == "modulation") dest = &modulation;
else if (name == "inversion") dest = &inv;
else if (name == "rolloff") dest = &rolloff;
else if (name == "pilot") dest = &pilot;
+ else if (name == "tsid") dest = &tsid;
+ else if (name == "onid") dest = &onid;
if (dest)
{
tmp = strtol(at->value().c_str(), &end_ptr, 10);
}
if (freq && sr && pol != -1)
{
- tuple = PyTuple_New(10);
+ tuple = PyTuple_New(12);
PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(freq));
PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(sr));
PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong(inv));
PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong(rolloff));
PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong(pilot));
+ PyTuple_SET_ITEM(tuple, 10, PyInt_FromLong(tsid));
+ PyTuple_SET_ITEM(tuple, 11, PyInt_FromLong(onid));
PyList_Append(tplist, tuple);
Py_DECREF(tuple);
}
{
ePtr<eDVBService> a_service, b_service;
int sortmode = m_query ? m_query->m_sort : eDVBChannelQuery::tName;
-
+
if ((sortmode == eDVBChannelQuery::tName) || (sortmode == eDVBChannelQuery::tProvider))
{
if (a.name.empty() && m_db->getService(a, a_service))
if (b.name.empty() && m_db->getService(b, b_service))
return 1;
}
-
+
switch (sortmode)
{
case eDVBChannelQuery::tName:
RESULT parseExpression(ePtr<eDVBChannelQuery> &res, std::list<std::string>::const_iterator begin, std::list<std::string>::const_iterator end)
{
std::list<std::string>::const_iterator end_of_exp;
-
+
if (begin == end)
return 0;
-
+
if (*begin == "(")
{
end_of_exp = begin;
break;
else
++end_of_exp;
-
+
if (end_of_exp == end)
{
eDebug("expression parse: end of expression while searching for closing brace");
return -1;
}
-
+
++begin;
// begin..end_of_exp
int r = parseExpression(res, begin, end_of_exp);
if (r)
return r;
++end_of_exp;
-
+
/* we had only one sub expression */
if (end_of_exp == end)
{
// eDebug("only one sub expression");
return 0;
}
-
+
/* otherwise we have an operator here.. */
-
+
ePtr<eDVBChannelQuery> r2 = res;
res = new eDVBChannelQuery();
res->m_sort = 0;
res->m_p1 = r2;
res->m_inverse = 0;
r2 = 0;
-
+
if (*end_of_exp == "||")
res->m_type = eDVBChannelQuery::tOR;
else if (*end_of_exp == "&&")
res = 0;
return 1;
}
-
+
++end_of_exp;
-
+
return parseExpression(res->m_p2, end_of_exp, end);
}
-
+
// "begin" <op> "end"
std::string type, op, val;
-
+
res = new eDVBChannelQuery();
res->m_sort = 0;
-
+
int cnt = 0;
while (begin != end)
{
++begin;
++cnt;
}
-
+
if (cnt != 3)
{
eDebug("malformed query: missing stuff");
res = 0;
return 1;
}
-
+
res->m_type = decodeType(type);
-
+
if (res->m_type == -1)
{
eDebug("malformed query: invalid type %s", type.c_str());
res = 0;
return 1;
}
-
+
if (op == "==")
res->m_inverse = 0;
else if (op == "!=")
res = 0;
return 1;
}
-
+
res->m_string = val;
if (res->m_type == eDVBChannelQuery::tChannelID)
RESULT eDVBChannelQuery::compile(ePtr<eDVBChannelQuery> &res, std::string query)
{
std::list<std::string> tokens;
-
+
std::string current_token;
std::string bouquet_name;
{
int c = (i < query.size()) ? query[i] : ' ';
++i;
-
+
int issplit = !!strchr(splitchars, c);
int isaln = isalnum(c);
int iswhite = c == ' ';
int isquot = c == '\"';
-
+
if (quotemode)
{
iswhite = issplit = 0;
isaln = lastalnum;
}
-
+
if (issplit || iswhite || isquot || lastsplit || (lastalnum != isaln))
{
if (current_token.size())
tokens.push_back(current_token);
current_token.clear();
}
-
+
if (!(iswhite || isquot))
current_token += c;
-
+
if (isquot)
quotemode = !quotemode;
lastsplit = issplit;
lastalnum = isaln;
}
-
+
// for (std::list<std::string>::const_iterator a(tokens.begin()); a != tokens.end(); ++a)
// {
// printf("%s\n", a->c_str());
res = 0;
return -1;
}
-
+
// eDebug("sort by %d", sort);
-
+
/* now we recursivly parse that. */
int r = parseExpression(res, tokens.begin(), tokens.end());
-
+
/* we have an empty (but valid!) expression */
if (!r && !res)
{
res->m_inverse = 0;
res->m_type = eDVBChannelQuery::tAny;
}
-
+
if (res)
{
res->m_sort = sort;
if (!instance)
instance = this;
-
+
/* search available adapters... */
// add linux devices
-
+
int num_adapter = 0;
while (eDVBAdapterLinux::exist(num_adapter))
{
addAdapter(new eDVBAdapterLinux(num_adapter));
num_adapter++;
}
-
- eDebug("found %d adapter, %d frontends(%d sim) and %d demux",
+
+ eDebug("found %d adapter, %d frontends(%d sim) and %d demux",
m_adapter.size(), m_frontend.size(), m_simulate_frontend.size(), m_demux.size());
eDVBCAService::registerChannelCallback(this);
{
// scan frontends
int num_fe = 0;
-
+
eDebug("scanning for frontends..");
while (1)
{
}
++num_fe;
}
-
+
// scan demux
int num_demux = 0;
while (1)
if (stat(filename, &s))
break;
ePtr<eDVBDemux> demux;
-
+
demux = new eDVBDemux(m_nr, num_demux);
m_demux.push_back(demux);
-
+
++num_demux;
}
}
--nr;
++i;
}
-
+
if (i != m_demux.end())
demux = *i;
else
return -1;
-
+
return 0;
}
--nr;
++i;
}
-
+
if (i != m_frontend.end())
fe = *i;
else
return -1;
-
+
return 0;
}
{
int num_fe = adapter->getNumFrontends();
int num_demux = adapter->getNumDemux();
-
+
m_adapter.push_back(adapter);
-
+
int i;
for (i=0; i<num_demux; ++i)
{
if (i == m_demux.end())
return -1;
-
+
ePtr<eDVBRegisteredDemux> unused;
-
+
if (m_demux.size() < 5)
{
/* FIXME: hardware demux policy */
for (; i != m_demux.end(); ++i, ++n)
{
int is_decode = n < 2;
-
+
int in_use = is_decode ? (i->m_demux->getRefCount() != 2) : i->m_inuse;
-
+
if ((!in_use) && ((!fe) || (i->m_adapter == fe->m_adapter)))
{
if ((cap & iDVBChannel::capDecode) && !is_decode)
continue;
- unused = i;
+ unused = i;
break;
}
}
if (!unused)
unused = i;
}
- else if (i->m_adapter == fe->m_adapter &&
+ else if (i->m_adapter == fe->m_adapter &&
i->m_demux->getSource() == fe->m_frontend->getDVBID())
{
demux = new eDVBAllocatedDemux(i);
}
/* allocate a frontend. */
-
+
ePtr<eDVBAllocatedFrontend> fe;
int err = allocateFrontend(fe, feparm, simulate);
if (m_iframe_state == 1)
{
- /* we are allowing data, and stop allowing data on the next frame.
+ /* we are allowing data, and stop allowing data on the next frame.
we now found a frame. so stop here. */
memset(data + offset, 0, 188 - (offset%188)); /* zero out rest of TS packet */
current_span_remaining = 0;
m_frontend = frontend;
m_pvr_thread = 0;
-
+
m_skipmode_n = m_skipmode_m = 0;
-
+
if (m_frontend)
m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged);
}
void eDVBChannel::frontendStateChanged(iDVBFrontend*fe)
{
int state, ourstate = 0;
-
+
/* if we are already in shutdown, don't change state. */
if (m_state == state_release)
return;
-
+
if (fe->getState(state))
return;
-
+
if (state == iDVBFrontend::stateLock)
{
eDebug("OURSTATE: ok");
ourstate = state_failed;
} else
eFatal("state unknown");
-
+
if (ourstate != m_state)
{
m_state = ourstate;
const int blocksize = 188;
unsigned int max = align(10*1024*1024, blocksize);
current_offset = align(current_offset, blocksize);
-
+
if (!m_cue)
{
eDebug("no cue sheet. forcing normal play");
continue;
}
}
-
+
if (relative == 1) /* pts relative */
{
pts += now;
if (relative != 2)
if (pts < 0)
pts = 0;
-
+
if (relative == 2) /* AP relative */
{
eDebug("AP relative seeking: %lld, at %lld", pts, now);
pts = nextap;
}
}
-
+
off_t offset = 0;
if (m_tstools.getOffset(offset, pts))
{
{
long long aligned_start = align(i->first, blocksize);
long long aligned_end = align(i->second, blocksize);
-
+
if ((current_offset >= aligned_start) && (current_offset < aligned_end))
{
start = current_offset;
{
if (m_channel_id)
m_mgr->removeChannel(this);
-
+
if (!channelid)
return 0;
eDebug("no frontend to tune!");
return -ENODEV;
}
-
+
m_channel_id = channelid;
m_mgr->addChannel(channelid, this);
m_state = state_tuning;
int res;
res = m_frontend->get().tune(*feparm);
m_current_frontend_parameters = feparm;
-
+
if (res)
{
m_state = state_release;
m_stateChanged(this);
return res;
}
-
+
return 0;
}
RESULT eDVBChannel::getDemux(ePtr<iDVBDemux> &demux, int cap)
{
ePtr<eDVBAllocatedDemux> &our_demux = (cap & capDecode) ? m_decoder_demux : m_demux;
-
+
if (!our_demux)
{
demux = 0;
-
+
if (m_mgr->allocateDemux(m_frontend ? (eDVBRegisteredFrontend*)*m_frontend : (eDVBRegisteredFrontend*)0, our_demux, cap))
return -1;
}
-
+
demux = *our_demux;
/* don't hold a reference to the decoding demux, we don't need it. */
-
+
/* FIXME: by dropping the 'allocated demux' in favour of the 'iDVBDemux',
- the refcount is lost. thus, decoding demuxes are never allocated.
-
+ the refcount is lost. thus, decoding demuxes are never allocated.
+
this poses a big problem for PiP. */
if (cap & capDecode)
our_demux = 0;
delete m_pvr_thread;
m_pvr_thread = 0;
}
-
+
m_tstools.openFile(file);
-
+
/* DON'T EVEN THINK ABOUT FIXING THIS. FIX THE ATI SOURCES FIRST,
THEN DO A REAL FIX HERE! */
-
+
/* (this codepath needs to be improved anyway.) */
#if HAVE_DVB_API_VERSION < 3
m_pvr_fd_dst = open("/dev/pvr", O_WRONLY);
{
if (!decoding_demux)
return -1;
-
+
pts_t now;
-
+
int r;
-
+
if (mode == 0) /* demux */
{
r = decoding_demux->getSTC(now, 0);
}
} else
now = pos; /* fixup supplied */
-
+
off_t off = 0; /* TODO: fixme */
r = m_tstools.fixupPTS(off, now);
if (r)
eDebug("fixup PTS failed");
return -1;
}
-
+
pos = now;
-
+
return 0;
}
a.) the filepush's internal buffer
b.) the PVR buffer (before demux)
c.) the ratebuffer (after demux)
-
+
it's important to clear them in the correct order, otherwise
the ratebuffer (for example) would immediately refill from
the not-yet-flushed PVR buffer.
m_pvr_thread->flush();
/* HACK: flush PVR buffer */
::ioctl(m_pvr_fd_dst, 0);
-
+
/* flush ratebuffers (video, audio) */
if (decoding_demux)
decoding_demux->flush();
m_lock.Unlock();
m_event(evtSeek);
}
-
+
void eCueSheet::clear()
{
m_lock.WrLock();
MultiContent.py MediaPlayer.py TunerInfo.py VideoWindow.py ChoiceList.py \
Element.py Playlist.py ParentalControl.py ParentalControlList.py \
Ipkg.py SelectionList.py Scanner.py SystemInfo.py DreamInfoHandler.py \
- Task.py language_cache.py Console.py
+ Task.py language_cache.py Console.py ResourceManager.py TuneTest.py
--- /dev/null
+class ResourceManager:
+ def __init__(self):
+ self.resourceList = {}
+
+ def addResource(self, name, resource):
+ print "adding Resource", name
+ self.resourceList[name] = resource
+ print "resources:", self.resourceList
+
+
+ def getResource(self, name):
+ if not self.hasResource(name):
+ return None
+ return self.resourceList[name]
+
+ def hasResource(self, name):
+ return self.resourceList.has_key(name)
+
+ def removeResource(self, name):
+ if self.hasResource(name):
+ del self.resourceList[name]
+
+resourcemanager = ResourceManager()
\ No newline at end of file
def setValue(self, value):
self.__value = value
self.changed((self.CHANGED_ALL,))
+
+ def setRange(self, range = 100):
+ self.range = range
+ self.changed((self.CHANGED_ALL,))
+
+ def getRange(self):
+ return self.range
value = property(getValue, setValue)
--- /dev/null
+from enigma import eDVBFrontendParametersSatellite, eDVBFrontendParameters, eDVBResourceManager, eTimer
+
+class Tuner:
+ def __init__(self, frontend):
+ self.frontend = frontend
+
+ # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, system, modulation)
+ # 0 1 2 3 4 5 6 7
+ def tune(self, transponder):
+ if self.frontend:
+ print "tuning to transponder with data", transponder
+ parm = eDVBFrontendParametersSatellite()
+ parm.frequency = transponder[0] * 1000
+ parm.symbol_rate = transponder[1] * 1000
+ parm.polarisation = transponder[2]
+ 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
+ feparm = eDVBFrontendParameters()
+ feparm.setDVBS(parm)
+ self.lastparm = feparm
+ self.frontend.tune(feparm)
+
+ def retune(self):
+ if self.frontend:
+ self.frontend.tune(self.lastparm)
+
+# tunes a list of transponders and checks, if they lock and optionally checks the onid/tsid combination
+# 1) add transponders with addTransponder()
+# 2) call run(<checkPIDs = True>)
+# 3) finishedChecking() is called, when the run is finished
+class TuneTest:
+ def __init__(self, feid, stopOnSuccess = -1, stopOnError = -1):
+ self.stopOnSuccess = stopOnSuccess
+ self.stopOnError = stopOnError
+ self.feid = feid
+ self.transponderlist = []
+ self.currTuned = None
+ print "TuneTest for feid %d" % self.feid
+ if not self.openFrontend():
+ self.oldref = self.session.nav.getCurrentlyPlayingServiceReference()
+ self.session.nav.stopService() # try to disable foreground service
+ if not self.openFrontend():
+ if self.session.pipshown: # try to disable pip
+ self.session.pipshown = False
+ del self.session.pip
+ if not self.openFrontend():
+ self.frontend = None # in normal case this should not happen
+ self.tuner = Tuner(self.frontend)
+ self.timer = eTimer()
+ self.timer.callback.append(self.updateStatus)
+
+ def gotTsidOnid(self, tsid, onid):
+ print "******** got tsid, onid:", tsid, onid
+ if tsid is not None and onid is not None:
+ self.pidStatus = self.INTERNAL_PID_STATUS_SUCCESSFUL
+ self.tsid = tsid
+ self.onid = onid
+ else:
+ self.pidStatus = self.INTERNAL_PID_STATUS_FAILED
+ self.tsid = -1
+ self.onid = -1
+ self.timer.start(100, True)
+
+ def updateStatus(self):
+ dict = {}
+ self.frontend.getFrontendStatus(dict)
+ stop = False
+
+ print "status:", dict
+ if dict["tuner_state"] == "TUNING":
+ print "TUNING"
+ self.timer.start(100, True)
+ self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_TUNING, self.currTuned))
+ elif self.checkPIDs and self.pidStatus == self.INTERNAL_PID_STATUS_NOOP:
+ print "2nd choice"
+ if dict["tuner_state"] == "LOCKED":
+ print "acquiring TSID/ONID"
+ self.raw_channel.requestTsidOnid(self.gotTsidOnid)
+ self.pidStatus = self.INTERNAL_PID_STATUS_WAITING
+ else:
+ self.pidStatus = self.INTERNAL_PID_STATUS_FAILED
+ elif self.checkPIDs and self.pidStatus == self.INTERNAL_PID_STATUS_WAITING:
+ print "waiting for pids"
+ else:
+ if dict["tuner_state"] == "LOSTLOCK" or dict["tuner_state"] == "FAILED":
+ self.tuningtransponder = self.nextTransponder()
+ self.failedTune.append([self.currTuned, self.oldTuned, "tune_failed"])
+ if self.stopOnError != -1 and self.stopOnError <= len(self.failedTune):
+ stop = True
+ elif dict["tuner_state"] == "LOCKED":
+ pidsFailed = False
+ if self.checkPIDs:
+ if self.currTuned is not None:
+ if self.tsid != self.currTuned[8] or self.onid != self.currTuned[9]:
+ self.failedTune.append([self.currTuned, self.oldTuned, "pids_failed", {"real": (self.tsid, self.onid), "expected": (self.currTuned[8], self.currTuned[9])}])
+ pidsFailed = True
+ else:
+ self.successfullyTune.append([self.currTuned, self.oldTuned])
+ if self.stopOnSuccess != -1 and self.stopOnSuccess <= len(self.successfullyTune):
+ stop = True
+ elif not self.checkPIDs or (self.checkPids and not pidsFailed):
+ self.successfullyTune.append([self.currTuned, self.oldTuned])
+ if self.stopOnSuccess != -1 and self.stopOnSuccess <= len(self.successfullyTune):
+ stop = True
+ self.tuningtransponder = self.nextTransponder()
+ else:
+ print "************* tuner_state:", dict["tuner_state"]
+
+ self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_NOOP, self.currTuned))
+
+ if not stop:
+ self.tune()
+ if self.tuningtransponder < len(self.transponderlist) and not stop:
+ if self.pidStatus != self.INTERNAL_PID_STATUS_WAITING:
+ self.timer.start(100, True)
+ print "restart timer"
+ else:
+ print "not restarting timers (waiting for pids)"
+ else:
+ self.progressCallback((self.getProgressLength(), len(self.transponderlist), self.STATUS_DONE, self.currTuned))
+ print "finishedChecking"
+ self.finishedChecking()
+
+ def firstTransponder(self):
+ print "firstTransponder:"
+ index = 0
+ if self.checkPIDs:
+ print "checkPIDs-loop"
+ # check for tsid != -1 and onid != -1
+ print "index:", index
+ print "len(self.transponderlist):", len(self.transponderlist)
+ while (index < len(self.transponderlist) and (self.transponderlist[index][8] == -1 or self.transponderlist[index][9] == -1)):
+ index += 1
+ print "FirstTransponder final index:", index
+ return index
+
+ def nextTransponder(self):
+ print "getting next transponder", self.tuningtransponder
+ index = self.tuningtransponder + 1
+ if self.checkPIDs:
+ print "checkPIDs-loop"
+ # check for tsid != -1 and onid != -1
+ print "index:", index
+ print "len(self.transponderlist):", len(self.transponderlist)
+ while (index < len(self.transponderlist) and (self.transponderlist[index][8] == -1 or self.transponderlist[index][9] == -1)):
+ index += 1
+
+ print "next transponder index:", index
+ return index
+
+ def finishedChecking(self):
+ print "finished testing"
+ print "successfull:", self.successfullyTune
+ print "failed:", self.failedTune
+
+ def openFrontend(self):
+ res_mgr = eDVBResourceManager.getInstance()
+ if res_mgr:
+ self.raw_channel = res_mgr.allocateRawChannel(self.feid)
+ if self.raw_channel:
+ self.frontend = self.raw_channel.getFrontend()
+ if self.frontend:
+ return True
+ else:
+ print "getFrontend failed"
+ else:
+ print "getRawChannel failed"
+ else:
+ print "getResourceManager instance failed"
+ return False
+
+ def tune(self):
+ print "tuning to", self.tuningtransponder
+ if self.tuningtransponder < len(self.transponderlist):
+ self.pidStatus = self.INTERNAL_PID_STATUS_NOOP
+ self.oldTuned = self.currTuned
+ self.currTuned = self.transponderlist[self.tuningtransponder]
+ self.tuner.tune(self.transponderlist[self.tuningtransponder])
+
+ INTERNAL_PID_STATUS_NOOP = 0
+ INTERNAL_PID_STATUS_WAITING = 1
+ INTERNAL_PID_STATUS_SUCCESSFUL = 2
+ INTERNAL_PID_STATUS_FAILED = 3
+
+ def run(self, checkPIDs = False):
+ self.checkPIDs = checkPIDs
+ self.pidStatus = self.INTERNAL_PID_STATUS_NOOP
+ self.failedTune = []
+ self.successfullyTune = []
+ self.tuningtransponder = self.firstTransponder()
+ self.tune()
+ self.progressCallback((self.getProgressLength(), self.tuningtransponder, self.STATUS_START, self.currTuned))
+ self.timer.start(100, True)
+
+ # transponder = (frequency, symbolrate, polarisation, fec, inversion, orbpos, <system>, <modulation>, <tsid>, <onid>)
+ # 0 1 2 3 4 5 6 7 8 9
+ def addTransponder(self, transponder):
+ self.transponderlist.append(transponder)
+
+ def clearTransponder(self):
+ self.transponderlist = []
+
+ def getProgressLength(self):
+ count = 0
+ if self.stopOnError == -1:
+ count = len(self.transponderlist)
+ else:
+ if count < self.stopOnError:
+ count = self.stopOnError
+ if self.stopOnSuccess == -1:
+ count = len(self.transponderlist)
+ else:
+ if count < self.stopOnSuccess:
+ count = self.stopOnSuccess
+ return count
+
+ STATUS_START = 0
+ STATUS_TUNING = 1
+ STATUS_DONE = 2
+ STATUS_NOOP = 3
+ # can be overwritten
+ # progress = (range, value, status, transponder)
+ def progressCallback(self, progress):
+ pass
\ No newline at end of file
--- /dev/null
+installdir = $(LIBDIR)/enigma2/python/Plugins/SystemPlugins/DiseqcTester
+
+install_PYTHON = \
+ __init__.py \
+ plugin.py
\ No newline at end of file
--- /dev/null
+from Screens.Satconfig import NimSelection
+from Screens.Screen import Screen
+from Screens.TextBox import TextBox
+
+from Plugins.Plugin import PluginDescriptor
+
+from Components.ActionMap import ActionMap, NumberActionMap
+from Components.NimManager import nimmanager
+from Components.ResourceManager import resourcemanager
+from Components.Sources.FrontendStatus import FrontendStatus
+from Components.TuneTest import TuneTest
+from Components.Sources.List import List
+from Components.Sources.Progress import Progress
+from Components.Sources.StaticText import StaticText
+from Components.ConfigList import ConfigListScreen
+from Components.config import getConfigListEntry, ConfigSelection
+
+import random
+
+# always use:
+# setResultType(type)
+# setResultParameter(parameter)
+# getTextualResult()
+class ResultParser:
+ def __init__(self):
+ pass
+
+ TYPE_BYORBPOS = 0
+ TYPE_BYINDEX = 1
+ TYPE_ALL = 2
+ def setResultType(self, type):
+ self.type = type
+
+ def setResultParameter(self, parameter):
+ if self.type == self.TYPE_BYORBPOS:
+ self.orbpos = parameter
+ elif self.type == self.TYPE_BYINDEX:
+ self.index = parameter
+
+ def getTextualResultForIndex(self, index):
+ text = ""
+ text += "%s:\n" % self.getTextualIndexRepresentation(index)
+
+ failed, successful = self.results[index]["failed"], self.results[index]["successful"]
+ countfailed = len(failed)
+ countsuccessful = len(successful)
+ countall = countfailed + countsuccessful
+ percentfailed = round(countfailed / float(countall + 0.0001) * 100)
+ percentsuccessful = round(countsuccessful / float(countall + 0.0001) * 100)
+ text += "Tested %d transponders\n%d (%d %%) transponders succeeded\n%d (%d %%) transponders failed\n" % (countall, countsuccessful, percentsuccessful, countfailed, percentfailed)
+ reasons = {}
+ if countfailed > 0:
+ for transponder in failed:
+ reasons[transponder[2]] = reasons.get(transponder[2], [])
+ reasons[transponder[2]].append(transponder)
+ if transponder[2] == "pids_failed":
+ print transponder[2], "-", transponder[3]
+
+ text += "The %d unsuccessful tuning attempts failed for the following reasons:\n" % countfailed
+
+ for reason in reasons.keys():
+ text += "%s: %d transponders failed\n" % (reason, len(reasons[reason]))
+
+ for reason in reasons.keys():
+ text += "\n"
+ text += "%s previous planes:\n" % reason
+ for transponder in reasons[reason]:
+ if transponder[1] is not None:
+ text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1]))
+ else:
+ text += "No transponder tuned"
+ text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0]))
+ text += "\n"
+ if countsuccessful > 0:
+ text += "\n"
+ text += "Successfully tuned transponders' previous planes:\n"
+ for transponder in successful:
+ if transponder[1] is not None:
+ text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1]))
+ else:
+ text += "No transponder tuned"
+ text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0]))
+ text += "\n"
+ return text
+
+ def getTextualResult(self):
+ text = ""
+ if self.type == self.TYPE_BYINDEX:
+ text += self.getTextualResultForIndex(self.index)
+ elif self.type == self.TYPE_BYORBPOS:
+ for index in self.results.keys():
+ if index[2] == self.orbpos:
+ text += self.getTextualResultForIndex(index)
+ text += "\n-----------------------------------------------------\n"
+
+ return text
+
+class DiseqcTester(Screen, TuneTest, ResultParser):
+ skin = """
+ <screen position="90,100" size="520,400" title="DiSEqC Tester" >
+ <!--ePixmap pixmap="skin_default/icons/dish_scan.png" position="5,25" zPosition="0" size="119,110" transparent="1" alphatest="on" />
+ <widget source="Frontend" render="Label" position="190,10" zPosition="2" size="260,20" font="Regular;19" halign="center" valign="center" transparent="1">
+ <convert type="FrontendInfo">SNRdB</convert>
+ </widget>
+ <eLabel name="snr" text="SNR:" position="120,35" size="60,22" font="Regular;21" halign="right" transparent="1" />
+ <widget source="Frontend" render="Progress" position="190,35" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc">
+ <convert type="FrontendInfo">SNR</convert>
+ </widget>
+ <widget source="Frontend" render="Label" position="460,35" size="60,22" font="Regular;21">
+ <convert type="FrontendInfo">SNR</convert>
+ </widget>
+ <eLabel name="agc" text="AGC:" position="120,60" size="60,22" font="Regular;21" halign="right" transparent="1" />
+ <widget source="Frontend" render="Progress" position="190,60" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc">
+ <convert type="FrontendInfo">AGC</convert>
+ </widget>
+ <widget source="Frontend" render="Label" position="460,60" size="60,22" font="Regular;21">
+ <convert type="FrontendInfo">AGC</convert>
+ </widget>
+ <eLabel name="ber" text="BER:" position="120,85" size="60,22" font="Regular;21" halign="right" transparent="1" />
+ <widget source="Frontend" render="Progress" position="190,85" size="260,20" pixmap="skin_default/bar_ber.png" borderWidth="2" borderColor="#cccccc">
+ <convert type="FrontendInfo">BER</convert>
+ </widget>
+ <widget source="Frontend" render="Label" position="460,85" size="60,22" font="Regular;21">
+ <convert type="FrontendInfo">BER</convert>
+ </widget>
+ <eLabel name="lock" text="Lock:" position="120,115" size="60,22" font="Regular;21" halign="right" />
+ <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_on.png" position="190,110" zPosition="1" size="38,31" alphatest="on">
+ <convert type="FrontendInfo">LOCK</convert>
+ <convert type="ConditionalShowHide" />
+ </widget>
+ <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_off.png" position="190,110" zPosition="1" size="38,31" alphatest="on">
+ <convert type="FrontendInfo">LOCK</convert>
+ <convert type="ConditionalShowHide">Invert</convert>
+ </widget-->
+ <widget source="progress_list" render="Listbox" position="0,0" size="510,150" scrollbarMode="showOnDemand">
+ <convert type="TemplatedMultiContent">
+ {"template": [
+ MultiContentEntryText(pos = (10, 0), size = (330, 25), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the index name,
+ MultiContentEntryText(pos = (330, 0), size = (150, 25), flags = RT_HALIGN_RIGHT, text = 2) # index 2 is the status,
+ ],
+ "fonts": [gFont("Regular", 20)],
+ "itemHeight": 25
+ }
+ </convert>
+ </widget>
+ <eLabel name="overall_progress" text="Overall progress:" position="20,162" size="480,22" font="Regular;21" halign="center" transparent="1" />
+ <widget source="overall_progress" render="Progress" position="20,192" size="480,20" borderWidth="2" backgroundColor="#254f7497" />
+ <eLabel name="overall_progress" text="Progress:" position="20,222" size="480,22" font="Regular;21" halign="center" transparent="1" />
+ <widget source="sub_progress" render="Progress" position="20,252" size="480,20" borderWidth="2" backgroundColor="#254f7497" />
+
+ <eLabel name="" text="Failed:" position="20,282" size="140,22" font="Regular;21" halign="left" transparent="1" />
+ <widget source="failed_counter" render="Label" position="160,282" size="100,20" font="Regular;21" />
+
+ <eLabel name="" text="Succeeded:" position="20,312" size="140,22" font="Regular;21" halign="left" transparent="1" />
+ <widget source="succeeded_counter" render="Label" position="160,312" size="100,20" font="Regular;21" />
+
+ <eLabel name="" text="With errors:" position="20,342" size="140,22" font="Regular;21" halign="left" transparent="1" />
+ <widget source="witherrors_counter" render="Label" position="160,342" size="100,20" font="Regular;21" />
+
+ <eLabel name="" text="Not tested:" position="20,372" size="140,22" font="Regular;21" halign="left" transparent="1" />
+ <widget source="untestable_counter" render="Label" position="160,372" size="100,20" font="Regular;21" />
+
+ <widget source="CmdText" render="Label" position="300,282" size="180,200" font="Regular;21" />
+ </screen>"""
+
+ TEST_TYPE_QUICK = 0
+ TEST_TYPE_RANDOM = 1
+ TEST_TYPE_COMPLETE = 2
+ def __init__(self, session, feid, test_type = TEST_TYPE_QUICK, loopsfailed = 3, loopssuccessful = 1):
+ Screen.__init__(self, session)
+ self.feid = feid
+ self.test_type = test_type
+ self.loopsfailed = loopsfailed
+ self.loopssuccessful = loopssuccessful
+
+ self["actions"] = NumberActionMap(["SetupActions"],
+ {
+ "ok": self.select,
+ "cancel": self.keyCancel,
+ }, -2)
+
+ TuneTest.__init__(self, feid, stopOnSuccess = self.loopssuccessful, stopOnError = self.loopsfailed)
+ #self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
+ self["overall_progress"] = Progress()
+ self["sub_progress"] = Progress()
+
+ self["failed_counter"] = StaticText("0")
+ self["succeeded_counter"] = StaticText("0")
+ self["witherrors_counter"] = StaticText("0")
+ self["untestable_counter"] = StaticText("0")
+
+ self.list = []
+ self["progress_list"] = List(self.list)
+ self["progress_list"].onSelectionChanged.append(self.selectionChanged)
+
+ self["CmdText"] = StaticText(_("Please wait while scanning is in progress..."))
+
+ self.indexlist = {}
+ self.readTransponderList()
+
+ self.running = False
+
+ self.results = {}
+ self.resultsstatus = {}
+
+ self.onLayoutFinish.append(self.go)
+
+ def getProgressListComponent(self, index, status):
+ return (index, self.getTextualIndexRepresentation(index), status)
+
+ def clearProgressList(self):
+ self.list = []
+ self["progress_list"].list = self.list
+
+ def addProgressListItem(self, index):
+ if index in self.indexlist:
+ for entry in self.list:
+ if entry[0] == index:
+ self.changeProgressListStatus(index, "working")
+ return
+ self.list.append(self.getProgressListComponent(index, _("working")))
+ self["progress_list"].list = self.list
+ self["progress_list"].setIndex(len(self.list) - 1)
+
+ def changeProgressListStatus(self, index, status):
+ self.newlist = []
+ count = 0
+ indexpos = 0
+ for entry in self.list:
+ if entry[0] == index:
+ self.newlist.append(self.getProgressListComponent(index, status))
+ indexpos = count
+ else:
+ self.newlist.append(entry)
+ count += 1
+ self.list = self.newlist
+ self["progress_list"].list = self.list
+ self["progress_list"].setIndex(indexpos)
+
+ def readTransponderList(self):
+ for sat in nimmanager.getSatListForNim(self.feid):
+ for transponder in nimmanager.getTransponders(sat[0]):
+ #print transponder
+ mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[5], sat[0], None, None, transponder[10], transponder[11])
+ self.analyseTransponder(mytransponder)
+
+ def getIndexForTransponder(self, transponder):
+
+ if transponder[0] < 11700:
+ band = 1 # low
+ else:
+ band = 0 # high
+
+ polarisation = transponder[2]
+
+ sat = transponder[5]
+
+ index = (band, polarisation, sat)
+ return index
+
+ # sort the transponder into self.transponderlist
+ def analyseTransponder(self, transponder):
+ index = self.getIndexForTransponder(transponder)
+ if index not in self.indexlist:
+ self.indexlist[index] = []
+ self.indexlist[index].append(transponder)
+ #print "self.indexlist:", self.indexlist
+
+ # returns a string for the user representing a human readable output for index
+ def getTextualIndexRepresentation(self, index):
+ print "getTextualIndexRepresentation:", index
+ text = ""
+
+ text += nimmanager.getSatDescription(index[2]) + ", "
+
+ if index[0] == 1:
+ text += "Low Band, "
+ else:
+ text += "High Band, "
+
+ if index[1] == 0:
+ text += "H"
+ else:
+ text += "V"
+ return text
+
+ def fillTransponderList(self):
+ self.clearTransponder()
+ print "----------- fillTransponderList"
+ print "index:", self.currentlyTestedIndex
+ keys = self.indexlist.keys()
+ if self.getContinueScanning():
+ print "index:", self.getTextualIndexRepresentation(self.currentlyTestedIndex)
+ for transponder in self.indexlist[self.currentlyTestedIndex]:
+ self.addTransponder(transponder)
+ print "transponderList:", self.transponderlist
+ return True
+ else:
+ return False
+
+ def progressCallback(self, progress):
+ if progress[0] != self["sub_progress"].getRange():
+ self["sub_progress"].setRange(progress[0])
+ self["sub_progress"].setValue(progress[1])
+
+ # logic for scanning order of transponders
+ # on go getFirstIndex is called
+ def getFirstIndex(self):
+ # TODO use other function to scan more randomly
+ if self.test_type == self.TEST_TYPE_QUICK:
+ self.myindex = 0
+ keys = self.indexlist.keys()
+ keys.sort(key = lambda a: a[2]) # sort by orbpos
+ self["overall_progress"].setRange(len(keys))
+ self["overall_progress"].setValue(self.myindex)
+ return keys[0]
+ elif self.test_type == self.TEST_TYPE_RANDOM:
+ self.randomkeys = self.indexlist.keys()
+ random.shuffle(self.randomkeys)
+ self.myindex = 0
+ self["overall_progress"].setRange(len(self.randomkeys))
+ self["overall_progress"].setValue(self.myindex)
+ return self.randomkeys[0]
+
+ # after each index is finished, getNextIndex is called to get the next index to scan
+ def getNextIndex(self):
+ # TODO use other function to scan more randomly
+ if self.test_type == self.TEST_TYPE_QUICK:
+ self.myindex += 1
+ keys = self.indexlist.keys()
+ keys.sort(key = lambda a: a[2]) # sort by orbpos
+
+ self["overall_progress"].setValue(self.myindex)
+ if self.myindex < len(keys):
+ return keys[self.myindex]
+ else:
+ return None
+ elif self.test_type == self.TEST_TYPE_RANDOM:
+ self.myindex += 1
+ keys = self.randomkeys
+
+ self["overall_progress"].setValue(self.myindex)
+ if self.myindex < len(keys):
+ return keys[self.myindex]
+ else:
+ return None
+
+ # after each index is finished and the next index is returned by getNextIndex
+ # the algorithm checks, if we should continue scanning
+ def getContinueScanning(self):
+ if self.test_type == self.TEST_TYPE_QUICK or self.test_type == self.TEST_TYPE_RANDOM:
+ return (self.myindex < len(self.indexlist.keys()))
+
+ def addResult(self, index, status, failedTune, successfullyTune):
+ self.results[index] = self.results.get(index, {"failed": [], "successful": [], "status": None})
+ self.resultsstatus[status] = self.resultsstatus.get(status, [])
+
+ self.results[index]["status"] = status
+ self.results[index]["failed"] = failedTune
+ self.results[index]["successful"] = successfullyTune
+
+ self.resultsstatus[status].append(index)
+
+ def finishedChecking(self):
+ print "finishedChecking"
+ TuneTest.finishedChecking(self)
+
+ if not self.results.has_key(self.currentlyTestedIndex):
+ self.results[self.currentlyTestedIndex] = {"failed": [], "successful": [], "status": None}
+
+ if len(self.failedTune) > 0 and len(self.successfullyTune) > 0:
+ self.changeProgressListStatus(self.currentlyTestedIndex, "with errors")
+ self["witherrors_counter"].setText(str(int(self["witherrors_counter"].getText()) + 1))
+ self.addResult(self.currentlyTestedIndex, "with_errors", self.failedTune, self.successfullyTune)
+ elif len(self.failedTune) == 0 and len(self.successfullyTune) == 0:
+ self.changeProgressListStatus(self.currentlyTestedIndex, "not tested")
+ self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1))
+ self.addResult(self.currentlyTestedIndex, "untestable", self.failedTune, self.successfullyTune)
+ elif len(self.failedTune) > 0:
+ self.changeProgressListStatus(self.currentlyTestedIndex, "failed")
+ self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune)))
+ self.addResult(self.currentlyTestedIndex, "failed", self.failedTune, self.successfullyTune)
+ else:
+ self.changeProgressListStatus(self.currentlyTestedIndex, "successful")
+ self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune)))
+ self.addResult(self.currentlyTestedIndex, "successful", self.failedTune, self.successfullyTune)
+
+
+ #self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune)))
+ #self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune)))
+ #if len(self.failedTune) == 0 and len(self.successfullyTune) == 0:
+ #self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1))
+
+ self.currentlyTestedIndex = self.getNextIndex()
+ self.addProgressListItem(self.currentlyTestedIndex)
+
+ if self.fillTransponderList():
+ self.run(checkPIDs = True)
+ else:
+ self.running = False
+ self["progress_list"].setIndex(0)
+ print "results:", self.results
+ print "resultsstatus:", self.resultsstatus
+
+ def go(self):
+ self.running = True
+ self["failed_counter"].setText("0")
+ self["succeeded_counter"].setText("0")
+ self["untestable_counter"].setText("0")
+ self.currentlyTestedIndex = self.getFirstIndex()
+
+ self.clearProgressList()
+ self.addProgressListItem(self.currentlyTestedIndex)
+
+ if self.fillTransponderList():
+ self.run(True)
+
+ def keyCancel(self):
+ self.close()
+
+ def select(self):
+ print "selectedIndex:", self["progress_list"].getCurrent()[0]
+ if not self.running:
+ index = self["progress_list"].getCurrent()[0]
+ #self.setResultType(ResultParser.TYPE_BYORBPOS)
+ #self.setResultParameter(index[2])
+ self.setResultType(ResultParser.TYPE_BYINDEX)
+ self.setResultParameter(index)
+ self.session.open(TextBox, self.getTextualResult())
+
+ def selectionChanged(self):
+ print "selection changed"
+ if len(self.list) > 0 and not self.running:
+ self["CmdText"].setText(_("Press OK to get further details for %s") % str(self["progress_list"].getCurrent()[1]))
+
+class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen):
+ skin = """<screen position="80,95" size="560,412" title="DiSEqC Tester Test Settings">
+ <widget name="config" position="10,10" size="540,402" scrollbarMode="showOnDemand" />
+ </screen>
+ """
+ def __init__(self, session, feid):
+ Screen.__init__(self, session)
+ self.feid = feid
+
+ self.list = []
+ ConfigListScreen.__init__(self, self.list)
+
+ self["actions"] = ActionMap(["SetupActions"],
+ {
+ "cancel": self.keyCancel
+ }, -2)
+
+ self.createSetup()
+
+ def createSetup(self):
+ self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random")}, default = "quick")
+ self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype)
+ self.list.append(self.testtypeEntry)
+
+ self.loopsfailed = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "3")
+ self.loopsfailedEntry = getConfigListEntry(_("Stop testing plane after # failed transponders"), self.loopsfailed)
+ self.list.append(self.loopsfailedEntry)
+
+ self.loopssuccessful = ConfigSelection(choices={"-1": "Every known", "1": "1", "2": "2", "3": "3", "4": "4", "5": "5", "6": "6", "7": "7", "8": "8"}, default = "1")
+ self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful)
+ self.list.append(self.loopssuccessfulEntry)
+
+ self["config"].list = self.list
+ self["config"].l.setList(self.list)
+
+ def keyOK(self):
+ print self.testtype.getValue()
+ testtype = DiseqcTester.TEST_TYPE_QUICK
+ if self.testtype.getValue() == "quick":
+ testtype = DiseqcTester.TEST_TYPE_QUICK
+ elif self.testtype.getValue() == "random":
+ testtype = DiseqcTester.TEST_TYPE_RANDOM
+ elif self.testtype.getValue() == "complete":
+ testtype = DiseqcTester.TEST_TYPE_COMPLETE
+ self.session.open(DiseqcTester, feid = self.feid, test_type = testtype, loopsfailed = int(self.loopsfailed.value), loopssuccessful = int(self.loopssuccessful.value))
+
+ def keyCancel(self):
+ self.close()
+
+class DiseqcTesterNimSelection(NimSelection):
+ skin = """
+ <screen position="160,123" size="400,330" title="Choose Tuner">
+ <widget source="nimlist" render="Listbox" position="0,0" size="380,300" scrollbarMode="showOnDemand">
+ <convert type="TemplatedMultiContent">
+ {"template": [
+ MultiContentEntryText(pos = (10, 5), size = (360, 30), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the nim name,
+ MultiContentEntryText(pos = (50, 30), size = (320, 30), font = 1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is a description of the nim settings,
+ ],
+ "fonts": [gFont("Regular", 20), gFont("Regular", 15)],
+ "itemHeight": 70
+ }
+ </convert>
+ </widget>
+ </screen>"""
+
+ def __init__(self, session, args = None):
+ NimSelection.__init__(self, session)
+
+ def setResultClass(self):
+ #self.resultclass = DiseqcTester
+ self.resultclass = DiseqcTesterTestTypeSelection
+
+ def showNim(self, nim):
+ nimConfig = nimmanager.getNimConfig(nim.slot)
+ if nim.isCompatible("DVB-S"):
+ if nimConfig.configMode.value in ["loopthrough", "equal", "satposdepends", "nothing"]:
+ return False
+ if nimConfig.configMode.value == "simple":
+ if nimConfig.diseqcMode.value == "positioner":
+ return True
+ return True
+ return False
+
+def DiseqcTesterMain(session, **kwargs):
+ session.open(DiseqcTesterNimSelection)
+
+def autostart(reason, **kwargs):
+ resourcemanager.addResource("DiseqcTester", DiseqcTesterMain)
+
+def Plugins(**kwargs):
+ return [ PluginDescriptor(name="DiSEqC Tester", description=_("Test DiSEqC settings"), where = PluginDescriptor.WHERE_PLUGINMENU, fnc=DiseqcTesterMain),
+ PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart)]
-SUBDIRS = SoftwareUpdate FrontprocessorUpgrade PositionerSetup ConfigurationBackup Satfinder SkinSelector SatelliteEquipmentControl Videomode VideoTune Hotplug DefaultServicesScanner NFIFlash
+SUBDIRS = SoftwareUpdate FrontprocessorUpgrade PositionerSetup ConfigurationBackup Satfinder SkinSelector SatelliteEquipmentControl Videomode VideoTune Hotplug DefaultServicesScanner NFIFlash DiseqcTester
from Components.NimManager import nimmanager, getConfigSatlist
from Components.MenuList import MenuList
from Components.config import ConfigSelection, getConfigListEntry
+from Components.TuneTest import Tuner
-class Tuner:
- def __init__(self, frontend):
- self.frontend = frontend
-
- def tune(self, transponder):
- if self.frontend:
- print "tuning to transponder with data", transponder
- parm = eDVBFrontendParametersSatellite()
- parm.frequency = transponder[0] * 1000
- parm.symbol_rate = transponder[1] * 1000
- parm.polarisation = transponder[2]
- parm.fec = transponder[3]
- parm.inversion = transponder[4]
- parm.orbital_position = transponder[5]
- 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
- self.frontend.tune(feparm)
-
- def retune(self):
- if self.frontend:
- self.frontend.tune(self.lastparm)
class Satfinder(ScanSetup):
def openFrontend(self):
TimerSelection.py PictureInPicture.py TimeDateInput.py \
SubtitleDisplay.py SubservicesQuickzap.py ParentalControlSetup.py NumericalTextInputHelpDialog.py \
SleepTimerEdit.py Ipkg.py RdsDisplay.py Globals.py DefaultWizard.py \
- SessionGlobals.py LocationBox.py WizardLanguage.py TaskView.py Rc.py VirtualKeyBoard.py
+ SessionGlobals.py LocationBox.py WizardLanguage.py TaskView.py Rc.py VirtualKeyBoard.py \
+ TextBox.py
self.list = [None] * nimmanager.getSlotCount()
self["nimlist"] = List(self.list)
self.updateList()
+
+ self.setResultClass()
self["actions"] = ActionMap(["OkCancelActions"],
{
"ok": self.okbuttonClick ,
"cancel": self.close
}, -2)
+
+ def setResultClass(self):
+ self.resultclass = NimSetup
def okbuttonClick(self):
nim = self["nimlist"].getCurrent()
nim = nim and nim[3]
if nim is not None and not nim.empty:
- self.session.openWithCallback(self.updateList, NimSetup, nim.slot)
+ self.session.openWithCallback(self.updateList, self.resultclass, nim.slot)
+
+ def showNim(self, nim):
+ return True
def updateList(self):
self.list = [ ]
slotid = x.slot
nimConfig = nimmanager.getNimConfig(x.slot)
text = nimConfig.configMode.value
- if x.isCompatible("DVB-S"):
- if nimConfig.configMode.value in ["loopthrough", "equal", "satposdepends"]:
- text = { "loopthrough": _("loopthrough to"),
- "equal": _("equal to"),
- "satposdepends": _("second cable of motorized LNB") } [nimConfig.configMode.value]
- text += " " + _("Tuner") + " " + ["A", "B", "C", "D"][int(nimConfig.connectedTo.value)]
- elif nimConfig.configMode.value == "nothing":
- text = _("nothing connected")
- elif nimConfig.configMode.value == "simple":
- if nimConfig.diseqcMode.value in ["single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
- text = _("Sats") + ": "
- if nimConfig.diseqcA.orbital_position != 3601:
- text += nimmanager.getSatName(int(nimConfig.diseqcA.value))
- if nimConfig.diseqcMode.value in ["toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
- if nimConfig.diseqcB.orbital_position != 3601:
- text += "," + nimmanager.getSatName(int(nimConfig.diseqcB.value))
- if nimConfig.diseqcMode.value == "diseqc_a_b_c_d":
- if nimConfig.diseqcC.orbital_position != 3601:
- text += "," + nimmanager.getSatName(int(nimConfig.diseqcC.value))
- if nimConfig.diseqcD.orbital_position != 3601:
- text += "," + nimmanager.getSatName(int(nimConfig.diseqcD.value))
- elif nimConfig.diseqcMode.value == "positioner":
- text = _("Positioner") + ":"
- if nimConfig.positionerMode.value == "usals":
- text += _("USALS")
- elif nimConfig.positionerMode.value == "manual":
- text += _("manual")
- else:
- text = _("simple")
- elif nimConfig.configMode.value == "advanced":
- text = _("advanced")
- elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"):
- if nimConfig.configMode.value == "nothing":
- text = _("nothing connected")
- elif nimConfig.configMode.value == "enabled":
- text = _("enabled")
-
- self.list.append((slotid, x.friendly_full_description, text, x))
+ if self.showNim(x):
+ if x.isCompatible("DVB-S"):
+ if nimConfig.configMode.value in ["loopthrough", "equal", "satposdepends"]:
+ text = { "loopthrough": _("loopthrough to"),
+ "equal": _("equal to"),
+ "satposdepends": _("second cable of motorized LNB") } [nimConfig.configMode.value]
+ text += " " + _("Tuner") + " " + ["A", "B", "C", "D"][int(nimConfig.connectedTo.value)]
+ elif nimConfig.configMode.value == "nothing":
+ text = _("nothing connected")
+ elif nimConfig.configMode.value == "simple":
+ if nimConfig.diseqcMode.value in ["single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
+ text = _("Sats") + ": "
+ if nimConfig.diseqcA.orbital_position != 3601:
+ text += nimmanager.getSatName(int(nimConfig.diseqcA.value))
+ if nimConfig.diseqcMode.value in ["toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
+ if nimConfig.diseqcB.orbital_position != 3601:
+ text += "," + nimmanager.getSatName(int(nimConfig.diseqcB.value))
+ if nimConfig.diseqcMode.value == "diseqc_a_b_c_d":
+ if nimConfig.diseqcC.orbital_position != 3601:
+ text += "," + nimmanager.getSatName(int(nimConfig.diseqcC.value))
+ if nimConfig.diseqcD.orbital_position != 3601:
+ text += "," + nimmanager.getSatName(int(nimConfig.diseqcD.value))
+ elif nimConfig.diseqcMode.value == "positioner":
+ text = _("Positioner") + ":"
+ if nimConfig.positionerMode.value == "usals":
+ text += _("USALS")
+ elif nimConfig.positionerMode.value == "manual":
+ text += _("manual")
+ else:
+ text = _("simple")
+ elif nimConfig.configMode.value == "advanced":
+ text = _("advanced")
+ elif x.isCompatible("DVB-T") or x.isCompatible("DVB-C"):
+ if nimConfig.configMode.value == "nothing":
+ text = _("nothing connected")
+ elif nimConfig.configMode.value == "enabled":
+ text = _("enabled")
+
+ self.list.append((slotid, x.friendly_full_description, text, x))
+ self["nimlist"].setList(self.list)
self["nimlist"].updateList(self.list)
\ No newline at end of file
--- /dev/null
+from Screens.Screen import Screen
+
+from Components.ActionMap import ActionMap
+from Components.Sources.StaticText import StaticText
+from Components.ScrollLabel import ScrollLabel
+
+class TextBox(Screen):
+ def __init__(self, session, text = ""):
+ Screen.__init__(self, session)
+
+ self.text = text
+ self["text"] = ScrollLabel(self.text)
+
+ self["actions"] = ActionMap(["OkCancelActions", "DirectionActions"],
+ {
+ "cancel": self.cancel,
+ "ok": self.ok,
+ "up": self["text"].pageUp,
+ "down": self["text"].pageDown,
+ }, -1)
+
+ def ok(self):
+ self.close()
+
+ def cancel(self):
+ self.close()
git.cweiske.de / enigma2.git / commitdiff