- fix configMode for DVB-T and DVB-C

[enigma2.git] / lib / python / Screens / Satconfig.py

diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py
index e32c45fbd35fec6a243cd6717a3c6a052d5858b1..bf28463209a06b0598d3594e5e806c006d061fea 100644 (file)
--- a/lib/python/Screens/Satconfig.py
+++ b/lib/python/Screens/Satconfig.py
@@ -1,10 +1,12 @@
 from enigma import eDVBDB
 from Screen import Screen
 from enigma import eDVBDB
 from Screen import Screen

+from Components.SystemInfo import SystemInfo

 from Components.ActionMap import ActionMap
 from Components.ConfigList import ConfigListScreen
 from Components.MenuList import MenuList
 from Components.NimManager import nimmanager
 from Components.ActionMap import ActionMap
 from Components.ConfigList import ConfigListScreen
 from Components.MenuList import MenuList
 from Components.NimManager import nimmanager

-from Components.config import getConfigListEntry, config, ConfigNothing
+from Components.config import getConfigListEntry, config, ConfigNothing, ConfigSelection, updateConfigElement
+from Components.Sources.List import List

 from Screens.MessageBox import MessageBox
 
 from time import mktime, localtime
 from Screens.MessageBox import MessageBox
 
 from time import mktime, localtime


@@ -29,19 +31,39 @@ class NimSetup(Screen, ConfigListScreen):
                list.append(getConfigListEntry(" ", nim.longitudeOrientation))
                list.append(getConfigListEntry(_("Latitude"), nim.latitude))
                list.append(getConfigListEntry(" ", nim.latitudeOrientation))
                list.append(getConfigListEntry(" ", nim.longitudeOrientation))
                list.append(getConfigListEntry(_("Latitude"), nim.latitude))
                list.append(getConfigListEntry(" ", nim.latitudeOrientation))

-
-               self.advancedPowerMeasurement = getConfigListEntry(_("Use Power Measurement"), nim.powerMeasurement)
-               list.append(self.advancedPowerMeasurement)
-               if nim.powerMeasurement.value:
-                       list.append(getConfigListEntry(_("Power threshold in mA"), nim.powerThreshold))
-                       self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), nim.turningSpeed)
-                       list.append(self.turningSpeed)
-                       if nim.turningSpeed.value == "fast epoch":
-                               self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), nim.fastTurningBegin)
-                               self.turnFastEpochEnd = getConfigListEntry(_("End time"), nim.fastTurningEnd)
-                               list.append(self.turnFastEpochBegin)
-                               list.append(self.turnFastEpochEnd)
-
+               if SystemInfo["CanMeasureFrontendInputPower"]:
+                       self.advancedPowerMeasurement = getConfigListEntry(_("Use Power Measurement"), nim.powerMeasurement)
+                       list.append(self.advancedPowerMeasurement)
+                       if nim.powerMeasurement.value:
+                               list.append(getConfigListEntry(_("Power threshold in mA"), nim.powerThreshold))
+                               self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), nim.turningSpeed)
+                               list.append(self.turningSpeed)
+                               if nim.turningSpeed.value == "fast epoch":
+                                       self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), nim.fastTurningBegin)
+                                       self.turnFastEpochEnd = getConfigListEntry(_("End time"), nim.fastTurningEnd)
+                                       list.append(self.turnFastEpochBegin)
+                                       list.append(self.turnFastEpochEnd)
+               else:
+                       if nim.powerMeasurement.value:
+                               nim.powerMeasurement.value = False
+                               nim.powerMeasurement.save()
+               
+       def createConfigMode(self):
+               if self.nim.isCompatible("DVB-S"):
+                       choices = { "nothing": _("nothing connected"),
+                                               "simple": _("simple"),
+                                               "advanced": _("advanced")}
+                       #if len(nimmanager.getNimListOfType(nimmanager.getNimType(self.slotid), exception = x)) > 0:
+                       #       choices["equal"] = _("equal to")
+                       #       choices["satposdepends"] = _("second cable of motorized LNB")
+                       if len(nimmanager.canEqualTo(self.slotid)) > 0:
+                               choices["equal"] = _("equal to")
+                       if len(nimmanager.canDependOn(self.slotid)) > 0:
+                               choices["satposdepends"] = _("second cable of motorized LNB")
+                       if len(nimmanager.canConnectTo(self.slotid)) > 0:
+                               choices["loopthrough"] = _("loopthrough to")
+                       self.nimConfig.configMode.setChoices(choices)
+                                                       

        def createSetup(self):
                print "Creating setup"
                self.list = [ ]
        def createSetup(self):
                print "Creating setup"
                self.list = [ ]


@@ -59,6 +81,7 @@ class NimSetup(Screen, ConfigListScreen):
                self.turnFastEpochEnd = None
                self.uncommittedDiseqcCommand = None
                self.cableScanType = None
                self.turnFastEpochEnd = None
                self.uncommittedDiseqcCommand = None
                self.cableScanType = None

+               self.have_advanced = False

 
                if self.nim.isCompatible("DVB-S"):
                        self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
 
                if self.nim.isCompatible("DVB-S"):
                        self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)


@@ -71,7 +94,34 @@ class NimSetup(Screen, ConfigListScreen):
                                        self.createSimpleSetup(self.list, self.nimConfig.diseqcMode.value)
                                if self.nimConfig.diseqcMode.value == "positioner":
                                        self.createPositionerSetup(self.list)
                                        self.createSimpleSetup(self.list, self.nimConfig.diseqcMode.value)
                                if self.nimConfig.diseqcMode.value == "positioner":
                                        self.createPositionerSetup(self.list)

-                       elif self.nimConfig.configMode.value in ["loopthrough", "satposdepends", "nothing", "equal"]:
+                       elif self.nimConfig.configMode.value == "equal":
+                               choices = []
+                               nimlist = nimmanager.canEqualTo(self.nim.slot)
+                               for id in nimlist:
+                                       #choices.append((str(id), str(chr(65 + id))))
+                                       choices.append((str(id), nimmanager.getNimDescription(id)))
+                               self.nimConfig.connectedTo.setChoices(choices)
+                               #self.nimConfig.connectedTo = updateConfigElement(self.nimConfig.connectedTo, ConfigSelection(choices = choices))
+                               self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo))
+                       elif self.nimConfig.configMode.value == "satposdepends":
+                               choices = []
+                               nimlist = nimmanager.canDependOn(self.nim.slot)
+                               for id in nimlist:
+                                       #choices.append((str(id), str(chr(65 + id))))
+                                       choices.append((str(id), nimmanager.getNimDescription(id)))
+                               self.nimConfig.connectedTo.setChoices(choices)
+                               #self.nimConfig.connectedTo = updateConfigElement(self.nimConfig.connectedTo, ConfigSelection(choices = choices))
+                               self.list.append(getConfigListEntry(_("Tuner"), self.nimConfig.connectedTo))
+                       elif self.nimConfig.configMode.value == "loopthrough":
+                               choices = []
+                               print "connectable to:", nimmanager.canConnectTo(self.slotid)
+                               connectable = nimmanager.canConnectTo(self.slotid)
+                               for id in connectable:
+                                       choices.append((str(id), nimmanager.getNimDescription(id)))
+                               self.nimConfig.connectedTo.setChoices(choices)
+                               #self.nimConfig.connectedTo = updateConfigElement(self.nimConfig.connectedTo, ConfigSelection(choices = choices))
+                               self.list.append(getConfigListEntry(_("Connected to"), self.nimConfig.connectedTo))
+                       elif self.nimConfig.configMode.value == "nothing":

                                pass
                        elif self.nimConfig.configMode.value == "advanced": # advanced
                                # SATs
                                pass
                        elif self.nimConfig.configMode.value == "advanced": # advanced
                                # SATs


@@ -79,11 +129,12 @@ class NimSetup(Screen, ConfigListScreen):
                                self.list.append(self.advancedSatsEntry)
                                cur_orb_pos = self.nimConfig.advanced.sats.orbital_position
                                satlist = self.nimConfig.advanced.sat.keys()
                                self.list.append(self.advancedSatsEntry)
                                cur_orb_pos = self.nimConfig.advanced.sats.orbital_position
                                satlist = self.nimConfig.advanced.sat.keys()

-                               if cur_orb_pos not in satlist:
-                                       cur_orb_pos = satlist[0]
-                               currSat = self.nimConfig.advanced.sat[cur_orb_pos]
-                               self.fillListWithAdvancedSatEntrys(currSat)
-                       self.have_advanced = True
+                               if cur_orb_pos is not None:
+                                       if cur_orb_pos not in satlist:
+                                               cur_orb_pos = satlist[0]
+                                       currSat = self.nimConfig.advanced.sat[cur_orb_pos]
+                                       self.fillListWithAdvancedSatEntrys(currSat)
+                               self.have_advanced = True

                elif self.nim.isCompatible("DVB-C"):
                        self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
                        self.list.append(self.configMode)
                elif self.nim.isCompatible("DVB-C"):
                        self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
                        self.list.append(self.configMode)


@@ -151,6 +202,7 @@ class NimSetup(Screen, ConfigListScreen):
                                x[1].value = int(mktime(dt.timetuple()))
                        x[1].save()
                nimmanager.sec.update()
                                x[1].value = int(mktime(dt.timetuple()))
                        x[1].save()
                nimmanager.sec.update()

+               self.saveAll()

 
        def fillListWithAdvancedSatEntrys(self, Sat):
                currLnb = self.nimConfig.advanced.lnb[int(Sat.lnb.value)]
 
        def fillListWithAdvancedSatEntrys(self, Sat):
                currLnb = self.nimConfig.advanced.lnb[int(Sat.lnb.value)]


@@ -199,17 +251,22 @@ class NimSetup(Screen, ConfigListScreen):
                                        self.list.append(getConfigListEntry(" ", currLnb.longitudeOrientation))
                                        self.list.append(getConfigListEntry(_("Latitude"), currLnb.latitude))
                                        self.list.append(getConfigListEntry(" ", currLnb.latitudeOrientation))
                                        self.list.append(getConfigListEntry(" ", currLnb.longitudeOrientation))
                                        self.list.append(getConfigListEntry(_("Latitude"), currLnb.latitude))
                                        self.list.append(getConfigListEntry(" ", currLnb.latitudeOrientation))

-                                       self.advancedPowerMeasurement = getConfigListEntry(_("Use Power Measurement"), currLnb.powerMeasurement)
-                                       self.list.append(self.advancedPowerMeasurement)
-                                       if currLnb.powerMeasurement.value:
-                                               self.list.append(getConfigListEntry(_("Power threshold in mA"), currLnb.powerThreshold))
-                                               self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), currLnb.turningSpeed)
-                                               self.list.append(self.turningSpeed)
-                                               if currLnb.turningSpeed.value == "fast epoch":
-                                                       self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), currLnb.fastTurningBegin)
-                                                       self.turnFastEpochEnd = getConfigListEntry(_("End time"), currLnb.fastTurningEnd)
-                                                       self.list.append(self.turnFastEpochBegin)
-                                                       self.list.append(self.turnFastEpochEnd)
+                                       if SystemInfo["CanMeasureFrontendInputPower"]:
+                                               self.advancedPowerMeasurement = getConfigListEntry(_("Use Power Measurement"), currLnb.powerMeasurement)
+                                               self.list.append(self.advancedPowerMeasurement)
+                                               if currLnb.powerMeasurement.value:
+                                                       self.list.append(getConfigListEntry(_("Power threshold in mA"), currLnb.powerThreshold))
+                                                       self.turningSpeed = getConfigListEntry(_("Rotor turning speed"), currLnb.turningSpeed)
+                                                       self.list.append(self.turningSpeed)
+                                                       if currLnb.turningSpeed.value == "fast epoch":
+                                                               self.turnFastEpochBegin = getConfigListEntry(_("Begin time"), currLnb.fastTurningBegin)
+                                                               self.turnFastEpochEnd = getConfigListEntry(_("End time"), currLnb.fastTurningEnd)
+                                                               self.list.append(self.turnFastEpochBegin)
+                                                               self.list.append(self.turnFastEpochEnd)
+                                       else:
+                                               if currLnb.powerMeasurement.value:
+                                                       currLnb.powerMeasurement.value = False
+                                                       currLnb.powerMeasurement.save()

                        self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof)
                        self.list.append(self.advancedLof)
                        if currLnb.lof.value == "user_defined":
                        self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof)
                        self.list.append(self.advancedLof)
                        if currLnb.lof.value == "user_defined":


@@ -276,8 +333,10 @@ class NimSetup(Screen, ConfigListScreen):
                        "cancel": self.keyCancel,
                }, -2)
 
                        "cancel": self.keyCancel,
                }, -2)
 

+               self.slotid = slotid

                self.nim = nimmanager.nim_slots[slotid]
                self.nimConfig = self.nim.config
                self.nim = nimmanager.nim_slots[slotid]
                self.nimConfig = self.nim.config

+               self.createConfigMode()

                self.createSetup()
 
        def keyLeft(self):
                self.createSetup()
 
        def keyLeft(self):


@@ -287,16 +346,35 @@ class NimSetup(Screen, ConfigListScreen):
        def keyRight(self):
                ConfigListScreen.keyRight(self)
                self.newConfig()
        def keyRight(self):
                ConfigListScreen.keyRight(self)
                self.newConfig()

+               
+       def saveAll(self):
+               if self.nim.isCompatible("DVB-S"):
+                       # reset connectedTo to all choices to properly store the default value
+                       choices = []
+                       nimlist = nimmanager.getNimListOfType("DVB-S", self.slotid)
+                       for id in nimlist:
+                               choices.append((str(id), nimmanager.getNimDescription(id)))
+                       self.nimConfig.connectedTo.setChoices(choices)
+               for x in self["config"].list:
+                       x[1].save()
+                       
+       def cancelConfirm(self, result):
+               if not result:
+                       return

 
 

+               for x in self["config"].list:
+                       x[1].cancel()
+               # we need to call saveAll to reset the connectedTo choices
+               self.saveAll()
+               self.close()
+                       

 class NimSelection(Screen):
        def __init__(self, session):
                Screen.__init__(self, session)
                
 class NimSelection(Screen):
        def __init__(self, session):
                Screen.__init__(self, session)
                

-               menu = [ ]
-               for x in nimmanager.nim_slots:
-                       menu.append((x.friendly_full_description, x))
-
-               self["nimlist"] = MenuList(menu)
+               self.list = [None] * nimmanager.getSlotCount()
+               self["nimlist"] = List(self.list)
+               self.updateList()

 
                self["actions"] = ActionMap(["OkCancelActions"],
                {
 
                self["actions"] = ActionMap(["OkCancelActions"],
                {


@@ -306,6 +384,47 @@ class NimSelection(Screen):
 
        def okbuttonClick(self):
                nim = self["nimlist"].getCurrent()
 
        def okbuttonClick(self):
                nim = self["nimlist"].getCurrent()

-               nim = nim and nim[1]
+               nim = nim and nim[3]

                if nim is not None and not nim.empty:
                if nim is not None and not nim.empty:

-                       self.session.open(NimSetup, nim.slot)
+                       self.session.openWithCallback(self.updateList, NimSetup, nim.slot)
+
+       def updateList(self):
+               self.list = [ ]
+               for x in nimmanager.nim_slots:
+                       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") + ": " + nimmanager.getSatName(int(nimConfig.diseqcA.value))
+                                               if nimConfig.diseqcMode.value in ["toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
+                                                       text += "," + nimmanager.getSatName(int(nimConfig.diseqcB.value))
+                                               if nimConfig.diseqcMode.value == "diseqc_a_b_c_d":
+                                                       text += "," + nimmanager.getSatName(int(nimConfig.diseqcC.value))
+                                                       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"].updateList(self.list)
\ No newline at end of file