update all Makefile.am files
[vuplus_dvbapp] / lib / python / Plugins / SystemPlugins / DiseqcTester / plugin.py
1 from Screens.Satconfig import NimSelection
2 from Screens.Screen import Screen
3 from Screens.TextBox import TextBox
4 from Screens.MessageBox import MessageBox
5
6 from Plugins.Plugin import PluginDescriptor
7
8 from Components.ActionMap import ActionMap, NumberActionMap
9 from Components.NimManager import nimmanager
10 from Components.ResourceManager import resourcemanager
11 from Components.Sources.FrontendStatus import FrontendStatus
12 from Components.TuneTest import TuneTest
13 from Components.Sources.List import List
14 from Components.Sources.Progress import Progress
15 from Components.Sources.StaticText import StaticText
16 from Components.ConfigList import ConfigListScreen
17 from Components.config import getConfigListEntry, ConfigSelection, ConfigYesNo
18 from Components.Harddisk import harddiskmanager
19
20 import random
21
22 # always use:
23 # setResultType(type)
24 # setResultParameter(parameter)
25 # getTextualResult()
26 class ResultParser:
27         def __init__(self):
28                 pass
29         
30         TYPE_BYORBPOS = 0
31         TYPE_BYINDEX = 1
32         TYPE_ALL = 2
33         def setResultType(self, type):
34                 self.type = type
35                 
36         def setResultParameter(self, parameter):
37                 if self.type == self.TYPE_BYORBPOS:
38                         self.orbpos = parameter
39                 elif self.type == self.TYPE_BYINDEX:
40                         self.index = parameter
41                         
42         def getTextualResultForIndex(self, index, logfulltransponders = False):
43                 text = ""
44                 text += "%s:\n" % self.getTextualIndexRepresentation(index)
45                 
46                 failed, successful = self.results[index]["failed"], self.results[index]["successful"]
47                 countfailed = len(failed)
48                 countsuccessful = len(successful)
49                 countall = countfailed + countsuccessful
50                 percentfailed = round(countfailed / float(countall + 0.0001) * 100)
51                 percentsuccessful = round(countsuccessful / float(countall + 0.0001) * 100)
52                 text += "Tested %d transponders\n%d (%d %%) transponders succeeded\n%d (%d %%) transponders failed\n" % (countall, countsuccessful, percentsuccessful, countfailed, percentfailed)
53                 reasons = {}
54                 if countfailed > 0:
55                         for transponder in failed:
56                                 reasons[transponder[2]] = reasons.get(transponder[2], [])
57                                 reasons[transponder[2]].append(transponder)
58                                 if transponder[2] == "pids_failed":
59                                         print transponder[2], "-", transponder[3]
60                                 
61                         text += "The %d unsuccessful tuning attempts failed for the following reasons:\n" % countfailed
62                         
63                         for reason in reasons.keys():
64                                 text += "%s: %d transponders failed\n" % (reason, len(reasons[reason]))
65                         
66                         for reason in reasons.keys():
67                                 text += "\n"
68                                 text += "%s previous planes:\n" % reason
69                                 for transponder in reasons[reason]:
70                                         if transponder[1] is not None:
71                                                 text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1]))
72                                         else:
73                                                 text += "No transponder tuned"
74                                         text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0]))
75                                         text += "\n"
76                                         if logfulltransponders:
77                                                 text += str(transponder[1])
78                                                 text += " ==> "
79                                                 text += str(transponder[0])
80                                                 text += "\n"
81                                         if reason == "pids_failed":
82                                                 text += "(tsid, onid): "
83                                                 text += str(transponder[3]['real'])
84                                                 text += "(read from sat) != "
85                                                 text += str(transponder[3]['expected'])
86                                                 text += "(read from file)"
87                                                 text += "\n"
88                                         text += "\n"
89                 if countsuccessful > 0:
90                         text += "\n"
91                         text += "Successfully tuned transponders' previous planes:\n" 
92                         for transponder in successful:
93                                 if transponder[1] is not None:
94                                         text += self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[1]))
95                                 else:
96                                         text += "No transponder tuned"
97                                 text += " ==> " + self.getTextualIndexRepresentation(self.getIndexForTransponder(transponder[0]))
98                                 text += "\n"
99                 return text
100
101         def getTextualResult(self):
102                 text = ""
103                 if self.type == self.TYPE_BYINDEX:
104                         text += self.getTextualResultForIndex(self.index)
105                 elif self.type == self.TYPE_BYORBPOS:
106                         for index in self.results.keys():
107                                 if index[2] == self.orbpos:
108                                         text += self.getTextualResultForIndex(index)
109                                         text += "\n-----------------------------------------------------\n"
110                 elif self.type == self.TYPE_ALL:
111                         orderedResults = {}
112                         for index in self.results.keys():
113                                 orbpos = index[2]
114                                 orderedResults[orbpos] = orderedResults.get(orbpos, [])
115                                 orderedResults[orbpos].append(index)
116                         ordered_orbpos = orderedResults.keys()
117                         ordered_orbpos.sort()
118                         for orbpos in ordered_orbpos:
119                                 text += "\n*****************************************\n"
120                                 text += "Orbital position %s:" % str(orbpos)
121                                 text += "\n*****************************************\n"
122                                 for index in orderedResults[orbpos]:
123                                         text += self.getTextualResultForIndex(index, logfulltransponders = True)
124                                         text += "\n-----------------------------------------------------\n"
125                         
126                                 
127                 return text
128
129 class DiseqcTester(Screen, TuneTest, ResultParser):
130         skin = """
131                 <screen position="90,100" size="520,400" title="DiSEqC Tester" >
132                 <!--ePixmap pixmap="skin_default/icons/dish_scan.png" position="5,25" zPosition="0" size="119,110" transparent="1" alphatest="on" />
133                 <widget source="Frontend" render="Label" position="190,10" zPosition="2" size="260,20" font="Regular;19" halign="center" valign="center" transparent="1">
134                         <convert type="FrontendInfo">SNRdB</convert>
135                 </widget>
136                 <eLabel name="snr" text="SNR:" position="120,35" size="60,22" font="Regular;21" halign="right" transparent="1" />
137                 <widget source="Frontend" render="Progress" position="190,35" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc">
138                         <convert type="FrontendInfo">SNR</convert>
139                 </widget>
140                 <widget source="Frontend" render="Label" position="460,35" size="60,22" font="Regular;21">
141                         <convert type="FrontendInfo">SNR</convert>
142                 </widget>
143                 <eLabel name="agc" text="AGC:" position="120,60" size="60,22" font="Regular;21" halign="right" transparent="1" />
144                 <widget source="Frontend" render="Progress" position="190,60" size="260,20" pixmap="skin_default/bar_snr.png" borderWidth="2" borderColor="#cccccc">
145                         <convert type="FrontendInfo">AGC</convert>
146                 </widget>
147                 <widget source="Frontend" render="Label" position="460,60" size="60,22" font="Regular;21">
148                         <convert type="FrontendInfo">AGC</convert>
149                 </widget>
150                 <eLabel name="ber" text="BER:" position="120,85" size="60,22" font="Regular;21" halign="right" transparent="1" />
151                 <widget source="Frontend" render="Progress" position="190,85" size="260,20" pixmap="skin_default/bar_ber.png" borderWidth="2" borderColor="#cccccc">
152                         <convert type="FrontendInfo">BER</convert>
153                 </widget>
154                 <widget source="Frontend" render="Label" position="460,85" size="60,22" font="Regular;21">
155                         <convert type="FrontendInfo">BER</convert>
156                 </widget>
157                 <eLabel name="lock" text="Lock:" position="120,115" size="60,22" font="Regular;21" halign="right" />
158                 <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_on.png" position="190,110" zPosition="1" size="38,31" alphatest="on">
159                         <convert type="FrontendInfo">LOCK</convert>
160                         <convert type="ConditionalShowHide" />
161                 </widget>
162                 <widget source="Frontend" render="Pixmap" pixmap="skin_default/icons/lock_off.png" position="190,110" zPosition="1" size="38,31" alphatest="on">
163                         <convert type="FrontendInfo">LOCK</convert>
164                         <convert type="ConditionalShowHide">Invert</convert>
165                 </widget-->
166                 <widget source="progress_list" render="Listbox" position="0,0" size="510,150" scrollbarMode="showOnDemand">
167                         <convert type="TemplatedMultiContent">
168                                 {"template": [
169                                                 MultiContentEntryText(pos = (10, 0), size = (330, 25), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the index name,
170                                                 MultiContentEntryText(pos = (330, 0), size = (150, 25), flags = RT_HALIGN_RIGHT, text = 2) # index 2 is the status,
171                                         ],
172                                  "fonts": [gFont("Regular", 20)],
173                                  "itemHeight": 25
174                                 }
175                         </convert>
176                 </widget>
177                 <eLabel name="overall_progress" text="Overall progress:" position="20,162" size="480,22" font="Regular;21" halign="center" transparent="1" />
178                 <widget source="overall_progress" render="Progress" position="20,192" size="480,20" borderWidth="2" backgroundColor="#254f7497" />
179                 <eLabel name="overall_progress" text="Progress:" position="20,222" size="480,22" font="Regular;21" halign="center" transparent="1" />
180                 <widget source="sub_progress" render="Progress" position="20,252" size="480,20" borderWidth="2" backgroundColor="#254f7497" />
181                 
182                 <eLabel name="" text="Failed:" position="20,282" size="140,22" font="Regular;21" halign="left" transparent="1" />
183                 <widget source="failed_counter" render="Label" position="160,282" size="100,20" font="Regular;21" />
184                 
185                 <eLabel name="" text="Succeeded:" position="20,312" size="140,22" font="Regular;21" halign="left" transparent="1" />
186                 <widget source="succeeded_counter" render="Label" position="160,312" size="100,20" font="Regular;21" />
187                 
188                 <eLabel name="" text="With errors:" position="20,342" size="140,22" font="Regular;21" halign="left" transparent="1" />
189                 <widget source="witherrors_counter" render="Label" position="160,342" size="100,20" font="Regular;21" />
190                 
191                 <eLabel name="" text="Not tested:" position="20,372" size="140,22" font="Regular;21" halign="left" transparent="1" />
192                 <widget source="untestable_counter" render="Label" position="160,372" size="100,20" font="Regular;21" />
193                 
194                 <widget source="CmdText" render="Label" position="300,282" size="180,200" font="Regular;21" />
195                 </screen>"""
196                 
197         TEST_TYPE_QUICK = 0
198         TEST_TYPE_RANDOM = 1
199         TEST_TYPE_COMPLETE = 2
200         def __init__(self, session, feid, test_type = TEST_TYPE_QUICK, loopsfailed = 3, loopssuccessful = 1, log = False):
201                 Screen.__init__(self, session)
202                 self.feid = feid
203                 self.test_type = test_type
204                 self.loopsfailed = loopsfailed
205                 self.loopssuccessful = loopssuccessful
206                 self.log = log
207                 
208                 self["actions"] = NumberActionMap(["SetupActions"],
209                 {
210                         "ok": self.select,
211                         "cancel": self.keyCancel,
212                 }, -2)
213                 
214                 TuneTest.__init__(self, feid, stopOnSuccess = self.loopssuccessful, stopOnError = self.loopsfailed)
215                 #self["Frontend"] = FrontendStatus(frontend_source = lambda : self.frontend, update_interval = 100)
216                 self["overall_progress"] = Progress()
217                 self["sub_progress"] = Progress()
218                 
219                 self["failed_counter"] = StaticText("0")
220                 self["succeeded_counter"] = StaticText("0")
221                 self["witherrors_counter"] = StaticText("0")
222                 self["untestable_counter"] = StaticText("0")
223                 
224                 self.list = []
225                 self["progress_list"] = List(self.list)
226                 self["progress_list"].onSelectionChanged.append(self.selectionChanged)
227                 
228                 self["CmdText"] = StaticText(_("Please wait while scanning is in progress..."))
229                                 
230                 self.indexlist = {}
231                 self.readTransponderList()
232                 
233                 self.running = False
234                 
235                 self.results = {}
236                 self.resultsstatus = {}
237                 
238                 self.onLayoutFinish.append(self.go)
239                 
240         def getProgressListComponent(self, index, status):
241                 return (index, self.getTextualIndexRepresentation(index), status)
242         
243         def clearProgressList(self):
244                 self.list = []
245                 self["progress_list"].list = self.list
246         
247         def addProgressListItem(self, index):
248                 if index in self.indexlist:
249                         for entry in self.list:
250                                 if entry[0] == index:
251                                         self.changeProgressListStatus(index, "working")
252                                         return
253                         self.list.append(self.getProgressListComponent(index, _("working")))
254                         self["progress_list"].list = self.list
255                         self["progress_list"].setIndex(len(self.list) - 1)
256
257         def changeProgressListStatus(self, index, status):
258                 self.newlist = []
259                 count = 0
260                 indexpos = 0
261                 for entry in self.list:
262                         if entry[0] == index:
263                                 self.newlist.append(self.getProgressListComponent(index, status))
264                                 indexpos = count
265                         else:
266                                 self.newlist.append(entry)
267                         count += 1
268                 self.list = self.newlist
269                 self["progress_list"].list = self.list
270                 self["progress_list"].setIndex(indexpos)
271
272         def readTransponderList(self):
273                 for sat in nimmanager.getSatListForNim(self.feid):
274                         for transponder in nimmanager.getTransponders(sat[0]):
275                                 #print transponder
276                                 mytransponder = (transponder[1] / 1000, transponder[2] / 1000, transponder[3], transponder[4], transponder[7], sat[0], transponder[5], transponder[6], transponder[8], transponder[9], transponder[10], transponder[11])
277                                 self.analyseTransponder(mytransponder)
278
279         def getIndexForTransponder(self, transponder):
280                 
281                 if transponder[0] < 11700:
282                         band = 1 # low
283                 else:
284                         band = 0 # high
285                 
286                 polarisation = transponder[2]
287                 
288                 sat = transponder[5]
289                 
290                 index = (band, polarisation, sat)
291                 return index
292
293         # sort the transponder into self.transponderlist
294         def analyseTransponder(self, transponder):
295                 index = self.getIndexForTransponder(transponder)
296                 if index not in self.indexlist:
297                         self.indexlist[index] = []
298                 self.indexlist[index].append(transponder)
299                 #print "self.indexlist:", self.indexlist
300         
301         # returns a string for the user representing a human readable output for index 
302         def getTextualIndexRepresentation(self, index):
303                 print "getTextualIndexRepresentation:", index
304                 text = ""
305                 
306                 text += nimmanager.getSatDescription(index[2]) + ", "
307                 
308                 if index[0] == 1:
309                         text += "Low Band, "
310                 else:
311                         text += "High Band, "
312                         
313                 if index[1] == 0:
314                         text += "H"
315                 else:
316                         text += "V"
317                 return text
318         
319         def fillTransponderList(self):
320                 self.clearTransponder()
321                 print "----------- fillTransponderList"
322                 print "index:", self.currentlyTestedIndex
323                 keys = self.indexlist.keys()
324                 if self.getContinueScanning():
325                         print "index:", self.getTextualIndexRepresentation(self.currentlyTestedIndex)
326                         for transponder in self.indexlist[self.currentlyTestedIndex]:
327                                 self.addTransponder(transponder)
328                         print "transponderList:", self.transponderlist
329                         return True
330                 else:
331                         return False
332                 
333         def progressCallback(self, progress):
334                 if progress[0] != self["sub_progress"].getRange():
335                         self["sub_progress"].setRange(progress[0])
336                 self["sub_progress"].setValue(progress[1])
337
338         # logic for scanning order of transponders
339         # on go getFirstIndex is called
340         def getFirstIndex(self):
341                 # TODO use other function to scan more randomly
342                 if self.test_type == self.TEST_TYPE_QUICK:
343                         self.myindex = 0
344                         keys = self.indexlist.keys()
345                         keys.sort(key = lambda a: a[2]) # sort by orbpos
346                         self["overall_progress"].setRange(len(keys))
347                         self["overall_progress"].setValue(self.myindex)
348                         return keys[0]
349                 elif self.test_type == self.TEST_TYPE_RANDOM:
350                         self.randomkeys = self.indexlist.keys()
351                         random.shuffle(self.randomkeys)
352                         self.myindex = 0
353                         self["overall_progress"].setRange(len(self.randomkeys))
354                         self["overall_progress"].setValue(self.myindex)
355                         return self.randomkeys[0]
356                 elif self.test_type == self.TEST_TYPE_COMPLETE:
357                         keys = self.indexlist.keys()
358                         print "keys:", keys
359                         successorindex = {}
360                         for index in keys:
361                                 successorindex[index] = []
362                                 for otherindex in keys:
363                                         if otherindex != index:
364                                                 successorindex[index].append(otherindex)
365                                 random.shuffle(successorindex[index])
366                         self.keylist = []
367                         stop = False
368                         currindex = None
369                         while not stop:
370                                 if currindex is None or len(successorindex[currindex]) == 0:
371                                         oldindex = currindex
372                                         for index in successorindex.keys():
373                                                 if len(successorindex[index]) > 0:
374                                                         currindex = index
375                                                         self.keylist.append(currindex)
376                                                         break
377                                         if currindex == oldindex:
378                                                 stop = True
379                                 else:
380                                         currindex = successorindex[currindex].pop()
381                                         self.keylist.append(currindex)
382                         print "self.keylist:", self.keylist
383                         self.myindex = 0
384                         self["overall_progress"].setRange(len(self.keylist))
385                         self["overall_progress"].setValue(self.myindex)
386                         return self.keylist[0]
387
388                                         
389         # after each index is finished, getNextIndex is called to get the next index to scan 
390         def getNextIndex(self):
391                 # TODO use other function to scan more randomly
392                 if self.test_type == self.TEST_TYPE_QUICK:
393                         self.myindex += 1
394                         keys = self.indexlist.keys()
395                         keys.sort(key = lambda a: a[2]) # sort by orbpos
396                         
397                         self["overall_progress"].setValue(self.myindex)
398                         if self.myindex < len(keys):
399                                 return keys[self.myindex]
400                         else:
401                                 return None
402                 elif self.test_type == self.TEST_TYPE_RANDOM:
403                         self.myindex += 1
404                         keys = self.randomkeys
405                         
406                         self["overall_progress"].setValue(self.myindex)
407                         if self.myindex < len(keys):
408                                 return keys[self.myindex]
409                         else:
410                                 return None
411                 elif self.test_type == self.TEST_TYPE_COMPLETE:
412                         self.myindex += 1
413                         keys = self.keylist
414                         
415                         self["overall_progress"].setValue(self.myindex)
416                         if self.myindex < len(keys):
417                                 return keys[self.myindex]
418                         else:
419                                 return None
420                                 
421         # after each index is finished and the next index is returned by getNextIndex
422         # the algorithm checks, if we should continue scanning
423         def getContinueScanning(self):
424                 if self.test_type == self.TEST_TYPE_QUICK or self.test_type == self.TEST_TYPE_RANDOM:
425                         return (self.myindex < len(self.indexlist.keys()))
426                 elif self.test_type == self.TEST_TYPE_COMPLETE:
427                         return (self.myindex < len(self.keylist))
428                 
429         def addResult(self, index, status, failedTune, successfullyTune):
430                 self.results[index] = self.results.get(index, {"failed": [], "successful": [], "status": None, "internalstatus": None})
431                 self.resultsstatus[status] = self.resultsstatus.get(status, [])
432
433                 oldstatus = self.results[index]["internalstatus"]
434                 if oldstatus is None:
435                         self.results[index]["status"] = status
436                 elif oldstatus == "successful":
437                         if status == "failed":
438                                 self.results[index]["status"] = "with_errors"
439                         elif status == "successful":
440                                 self.results[index]["status"] = oldstatus
441                         elif status == "with_errors":
442                                 self.results[index]["status"] = "with_errors"
443                         elif status == "not_tested":
444                                 self.results[index]["status"] = oldstatus
445                 elif oldstatus == "failed":
446                         if status == "failed":
447                                 self.results[index]["status"] = oldstatus
448                         elif status == "successful":
449                                 self.results[index]["status"] = "with_errors"
450                         elif status == "with_errors":
451                                 self.results[index]["status"] = "with_errors"
452                         elif status == "not_tested":
453                                 self.results[index]["status"] = oldstatus
454                 elif oldstatus == "with_errors":
455                         if status == "failed":
456                                 self.results[index]["status"] = oldstatus
457                         elif status == "successful":
458                                 self.results[index]["status"] = oldstatus
459                         elif status == "with_errors":
460                                 self.results[index]["status"] = oldstatus
461                         elif status == "not_tested":
462                                 self.results[index]["status"] = oldstatus
463                 elif oldstatus == "not_tested":
464                         self.results[index]["status"] = status
465                         
466                 if self.results[index]["status"] != "working":
467                         self.results[index]["internalstatus"] = self.results[index]["status"] 
468                 self.results[index]["failed"] = failedTune + self.results[index]["failed"]
469                 self.results[index]["successful"] = successfullyTune + self.results[index]["successful"]
470                 
471                 self.resultsstatus[status].append(index)
472         
473         def finishedChecking(self):
474                 print "finishedChecking"
475                 TuneTest.finishedChecking(self)
476
477                 if not self.results.has_key(self.currentlyTestedIndex):
478                         self.results[self.currentlyTestedIndex] = {"failed": [], "successful": [], "status": None, "internalstatus": None}
479                 
480                 if len(self.failedTune) > 0 and len(self.successfullyTune) > 0:
481                         self.changeProgressListStatus(self.currentlyTestedIndex, "with errors")
482                         self["witherrors_counter"].setText(str(int(self["witherrors_counter"].getText()) + 1))
483                         self.addResult(self.currentlyTestedIndex, "with_errors", self.failedTune, self.successfullyTune)
484                 elif len(self.failedTune) == 0 and len(self.successfullyTune) == 0:
485                         self.changeProgressListStatus(self.currentlyTestedIndex, "not tested")
486                         self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1))
487                         self.addResult(self.currentlyTestedIndex, "untestable", self.failedTune, self.successfullyTune)
488                 elif len(self.failedTune) > 0:
489                         self.changeProgressListStatus(self.currentlyTestedIndex, "failed")
490                         #self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune)))
491                         self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + 1))
492                         self.addResult(self.currentlyTestedIndex, "failed", self.failedTune, self.successfullyTune)
493                 else:
494                         self.changeProgressListStatus(self.currentlyTestedIndex, "successful")
495                         #self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune)))
496                         self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + 1))
497                         self.addResult(self.currentlyTestedIndex, "successful", self.failedTune, self.successfullyTune)
498                         
499                         
500                 #self["failed_counter"].setText(str(int(self["failed_counter"].getText()) + len(self.failedTune)))
501                 #self["succeeded_counter"].setText(str(int(self["succeeded_counter"].getText()) + len(self.successfullyTune)))
502                 #if len(self.failedTune) == 0 and len(self.successfullyTune) == 0:
503                         #self["untestable_counter"].setText(str(int(self["untestable_counter"].getText()) + 1))
504                         
505                 self.currentlyTestedIndex = self.getNextIndex()
506                 self.addProgressListItem(self.currentlyTestedIndex)
507                 
508                 if self.fillTransponderList():
509                         self.run(checkPIDs = True)
510                 else:
511                         self.running = False
512                         self["progress_list"].setIndex(0)
513                         print "results:", self.results
514                         print "resultsstatus:", self.resultsstatus
515                         if self.log:
516                                 file = open("/media/hdd/diseqctester.log", "w")
517                                 self.setResultType(ResultParser.TYPE_ALL)
518                                 file.write(self.getTextualResult())
519                                 file.close()
520                                 self.session.open(MessageBox, text=_("The results have been written to %s.") % "/media/hdd/diseqctester.log", type = MessageBox.TYPE_INFO)
521
522         def go(self):
523                 self.running = True
524                 self["failed_counter"].setText("0")
525                 self["succeeded_counter"].setText("0")
526                 self["untestable_counter"].setText("0")
527                 self.currentlyTestedIndex = self.getFirstIndex()
528                 
529                 self.clearProgressList()
530                 self.addProgressListItem(self.currentlyTestedIndex)
531                 
532                 if self.fillTransponderList():
533                         self.run(True)
534
535         def keyCancel(self):
536                 self.close()
537                 
538         def select(self):
539                 print "selectedIndex:", self["progress_list"].getCurrent()[0]
540                 if not self.running:
541                         index = self["progress_list"].getCurrent()[0]
542                         #self.setResultType(ResultParser.TYPE_BYORBPOS)
543                         #self.setResultParameter(index[2])
544                         self.setResultType(ResultParser.TYPE_BYINDEX)
545                         self.setResultParameter(index)
546                         #self.setResultType(ResultParser.TYPE_ALL)
547                         self.session.open(TextBox, self.getTextualResult())
548         
549         def selectionChanged(self):
550                 print "selection changed"
551                 if len(self.list) > 0 and not self.running:
552                         self["CmdText"].setText(_("Press OK to get further details for %s") % str(self["progress_list"].getCurrent()[1]))
553
554 class DiseqcTesterTestTypeSelection(Screen, ConfigListScreen):
555         skin = """<screen position="80,95" size="560,412" title="DiSEqC Tester Test Settings">
556                 <widget name="config" position="10,10" size="540,402" scrollbarMode="showOnDemand" />
557         </screen>
558         """
559         def __init__(self, session, feid):
560                 Screen.__init__(self, session)
561                 self.feid = feid
562                 
563                 self.list = []
564                 ConfigListScreen.__init__(self, self.list)
565                 
566                 self["actions"] = ActionMap(["SetupActions"],
567                 {
568                         "cancel": self.keyCancel
569                 }, -2)
570                 
571                 self.createSetup()
572                 
573         def createSetup(self):
574                 self.testtype = ConfigSelection(choices={"quick": _("Quick"), "random": _("Random"), "complete": _("Complete")}, default = "quick")
575                 self.testtypeEntry = getConfigListEntry(_("Test Type"), self.testtype)
576                 self.list.append(self.testtypeEntry)
577                 
578                 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")
579                 self.loopsfailedEntry = getConfigListEntry(_("Stop testing plane after # failed transponders"), self.loopsfailed)
580                 self.list.append(self.loopsfailedEntry)
581                 
582                 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")
583                 self.loopssuccessfulEntry = getConfigListEntry(_("Stop testing plane after # successful transponders"), self.loopssuccessful)
584                 self.list.append(self.loopssuccessfulEntry)
585                 
586                 self.log = ConfigYesNo(False)
587                 if harddiskmanager.HDDCount() > 0:
588                         self.logEntry = getConfigListEntry(_("Log results to harddisk"), self.log)
589                         self.list.append(self.logEntry)
590                                         
591                 self["config"].list = self.list
592                 self["config"].l.setList(self.list)
593                 
594         def keyOK(self):
595                 print self.testtype.getValue()
596                 testtype = DiseqcTester.TEST_TYPE_QUICK
597                 if self.testtype.getValue() == "quick":
598                         testtype = DiseqcTester.TEST_TYPE_QUICK
599                 elif self.testtype.getValue() == "random":
600                         testtype = DiseqcTester.TEST_TYPE_RANDOM
601                 elif self.testtype.getValue() == "complete":
602                         testtype = DiseqcTester.TEST_TYPE_COMPLETE
603                 self.session.open(DiseqcTester, feid = self.feid, test_type = testtype, loopsfailed = int(self.loopsfailed.value), loopssuccessful = int(self.loopssuccessful.value), log = self.log.value)
604         
605         def keyCancel(self):
606                 self.close()
607
608 class DiseqcTesterNimSelection(NimSelection):
609         skin = """
610                 <screen position="160,123" size="400,330" title="Choose Tuner">
611                 <widget source="nimlist" render="Listbox" position="0,0" size="380,300" scrollbarMode="showOnDemand">
612                         <convert type="TemplatedMultiContent">
613                                 {"template": [
614                                                 MultiContentEntryText(pos = (10, 5), size = (360, 30), flags = RT_HALIGN_LEFT, text = 1), # index 1 is the nim name,
615                                                 MultiContentEntryText(pos = (50, 30), size = (320, 30), font = 1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is a description of the nim settings,
616                                         ],
617                                  "fonts": [gFont("Regular", 20), gFont("Regular", 15)],
618                                  "itemHeight": 70
619                                 }
620                         </convert>
621                 </widget>
622         </screen>"""
623                 
624         def __init__(self, session, args = None):
625                 NimSelection.__init__(self, session)
626
627         def setResultClass(self):
628                 #self.resultclass = DiseqcTester
629                 self.resultclass = DiseqcTesterTestTypeSelection
630                 
631         def showNim(self, nim):
632                 nimConfig = nimmanager.getNimConfig(nim.slot)
633                 if nim.isCompatible("DVB-S"):
634                         if nimConfig.configMode.value in ("loopthrough", "equal", "satposdepends", "nothing"):
635                                 return False
636                         if nimConfig.configMode.value == "simple":
637                                 if nimConfig.diseqcMode.value == "positioner":
638                                         return True
639                         return True
640                 return False
641
642 def DiseqcTesterMain(session, **kwargs):
643         session.open(DiseqcTesterNimSelection)
644         
645 def autostart(reason, **kwargs):
646         resourcemanager.addResource("DiseqcTester", DiseqcTesterMain)
647
648 def Plugins(**kwargs):
649         return [ PluginDescriptor(name="DiSEqC Tester", description=_("Test DiSEqC settings"), where = PluginDescriptor.WHERE_PLUGINMENU, fnc=DiseqcTesterMain),
650                         PluginDescriptor(where = PluginDescriptor.WHERE_AUTOSTART, fnc = autostart)]