Support turbo2.

[vuplus_dvbapp] / lib / python / Screens / Satconfig.py

diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py
index 7d44965..564541b 100644 (file)
--- a/lib/python/Screens/Satconfig.py
+++ b/lib/python/Screens/Satconfig.py
@@ -1,28 +1,40 @@
-from enigma import eDVBDB
+from enigma import eDVBDB, getLinkedSlotID, isFBCLink

 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 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.config import getConfigListEntry, config, ConfigNothing, ConfigSelection, updateConfigElement
+from Components.config import getConfigListEntry, config, ConfigNothing, ConfigSelection, updateConfigElement,\
+       ConfigSatlist
+from Components.Sources.List import List

 from Screens.MessageBox import MessageBox
 from Screens.MessageBox import MessageBox

+from Screens.ChoiceBox import ChoiceBox
+from Screens.ServiceStopScreen import ServiceStopScreen

 
 from time import mktime, localtime
 from datetime import datetime
 
 
 from time import mktime, localtime
 from datetime import datetime
 

-class NimSetup(Screen, ConfigListScreen):
+from Components.PluginComponent import plugins
+from Plugins.Plugin import PluginDescriptor
+
+class NimSetup(Screen, ConfigListScreen, ServiceStopScreen):

        def createSimpleSetup(self, list, mode):
        def createSimpleSetup(self, list, mode):

+               nim = self.nimConfig

                if mode == "single":
                if mode == "single":

-                       list.append(getConfigListEntry(_("Satellite"), self.nimConfig.diseqcA))
+                       list.append(getConfigListEntry(_("Satellite"), nim.diseqcA))
+                       list.append(getConfigListEntry(_("Send DiSEqC"), nim.simpleSingleSendDiSEqC))

                else:
                else:

-                       list.append(getConfigListEntry(_("Port A"), self.nimConfig.diseqcA))
+                       list.append(getConfigListEntry(_("Port A"), nim.diseqcA))

 
 

-               if mode in ["toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
-                       list.append(getConfigListEntry(_("Port B"), self.nimConfig.diseqcB))
+               if mode in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
+                       list.append(getConfigListEntry(_("Port B"), nim.diseqcB))

                        if mode == "diseqc_a_b_c_d":
                        if mode == "diseqc_a_b_c_d":

-                               list.append(getConfigListEntry(_("Port C"), self.nimConfig.diseqcC))
-                               list.append(getConfigListEntry(_("Port D"), self.nimConfig.diseqcD))
+                               list.append(getConfigListEntry(_("Port C"), nim.diseqcC))
+                               list.append(getConfigListEntry(_("Port D"), nim.diseqcD))
+                       if mode != "toneburst_a_b":
+                               list.append(getConfigListEntry(_("Set Voltage and 22KHz"), nim.simpleDiSEqCSetVoltageTone))
+                               list.append(getConfigListEntry(_("Send DiSEqC only on satellite change"), nim.simpleDiSEqCOnlyOnSatChange))

 
        def createPositionerSetup(self, list):
                nim = self.nimConfig
 
        def createPositionerSetup(self, list):
                nim = self.nimConfig


@@ -48,24 +60,29 @@ class NimSetup(Screen, ConfigListScreen):
                                nim.powerMeasurement.save()
                
        def createConfigMode(self):
                                nim.powerMeasurement.save()
                
        def createConfigMode(self):

-               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)
-                                                       
+               if self.nim.isCompatible("DVB-S"):
+                       choices = { "nothing": _("not configured"),
+                                               "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")
+                       if isFBCLink(self.nim.slot):
+                               choices = { "nothing": _("not configured"),
+                                               "advanced": _("advanced")}
+                       self.nimConfig.configMode.setChoices(choices, default = "nothing")
+

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

+               self.multiType = None

                self.configMode = None
                self.diseqcModeEntry = None
                self.advancedSatsEntry = None
                self.configMode = None
                self.diseqcModeEntry = None
                self.advancedSatsEntry = None


@@ -80,15 +97,26 @@ class NimSetup(Screen, ConfigListScreen):
                self.uncommittedDiseqcCommand = None
                self.cableScanType = None
                self.have_advanced = False
                self.uncommittedDiseqcCommand = None
                self.cableScanType = None
                self.have_advanced = False

+               self.advancedUnicable = None
+               self.advancedType = None
+               self.advancedManufacturer = None
+               self.advancedSCR = None
+               self.advancedDiction = None
+               self.advancedConnected = None
+               
+               if self.nim.isMultiType():
+                       multiType = self.nimConfig.multiType
+                       self.multiType = getConfigListEntry(_("Tuner type"), multiType)
+                       self.list.append(self.multiType)

 
                if self.nim.isCompatible("DVB-S"):
                        self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
                        self.list.append(self.configMode)
 
                        if self.nimConfig.configMode.value == "simple":                 #simple setup
 
                if self.nim.isCompatible("DVB-S"):
                        self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
                        self.list.append(self.configMode)
 
                        if self.nimConfig.configMode.value == "simple":                 #simple setup

-                               self.diseqcModeEntry = getConfigListEntry(_("DiSEqC Mode"), self.nimConfig.diseqcMode)
+                               self.diseqcModeEntry = getConfigListEntry(_("Mode"), self.nimConfig.diseqcMode)

                                self.list.append(self.diseqcModeEntry)
                                self.list.append(self.diseqcModeEntry)

-                               if self.nimConfig.diseqcMode.value in ["single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
+                               if self.nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):

                                        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)


@@ -133,6 +161,8 @@ class NimSetup(Screen, ConfigListScreen):
                                        currSat = self.nimConfig.advanced.sat[cur_orb_pos]
                                        self.fillListWithAdvancedSatEntrys(currSat)
                                self.have_advanced = True
                                        currSat = self.nimConfig.advanced.sat[cur_orb_pos]
                                        self.fillListWithAdvancedSatEntrys(currSat)
                                self.have_advanced = True

+                       if self.nim.description == "Alps BSBE2" and config.usage.setup_level.index >= 2: # expert
+                               self.list.append(getConfigListEntry(_("Tone Amplitude"), self.nimConfig.toneAmplitude))

                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)


@@ -183,16 +213,25 @@ class NimSetup(Screen, ConfigListScreen):
                checkList = (self.configMode, self.diseqcModeEntry, self.advancedSatsEntry, \
                        self.advancedLnbsEntry, self.advancedDiseqcMode, self.advancedUsalsEntry, \
                        self.advancedLof, self.advancedPowerMeasurement, self.turningSpeed, \
                checkList = (self.configMode, self.diseqcModeEntry, self.advancedSatsEntry, \
                        self.advancedLnbsEntry, self.advancedDiseqcMode, self.advancedUsalsEntry, \
                        self.advancedLof, self.advancedPowerMeasurement, self.turningSpeed, \

-                       self.uncommittedDiseqcCommand, self.cableScanType)
+                       self.advancedType, self.advancedSCR, self.advancedDiction, self.advancedManufacturer, self.advancedUnicable, self.advancedConnected, \
+                       self.uncommittedDiseqcCommand, self.cableScanType, self.multiType)
+               if self["config"].getCurrent() == self.multiType:
+                       update_slots = [self.slotid]
+                       from Components.NimManager import InitNimManager
+                       InitNimManager(nimmanager, update_slots)
+                       self.nim = nimmanager.nim_slots[self.slotid]
+                       self.nimConfig = self.nim.config
+                       

                for x in checkList:
                        if self["config"].getCurrent() == x:
                                self.createSetup()
                for x in checkList:
                        if self["config"].getCurrent() == x:
                                self.createSetup()

+                               break

 
        def run(self):
                if self.have_advanced and self.nim.config_mode == "advanced":
                        self.fillAdvancedList()
                for x in self.list:
 
        def run(self):
                if self.have_advanced and self.nim.config_mode == "advanced":
                        self.fillAdvancedList()
                for x in self.list:

-                       if x in [self.turnFastEpochBegin, self.turnFastEpochEnd]:
+                       if x in (self.turnFastEpochBegin, self.turnFastEpochEnd):

                                # workaround for storing only hour*3600+min*60 value in configfile
                                # not really needed.. just for cosmetics..
                                tm = localtime(x[1].value)
                                # workaround for storing only hour*3600+min*60 value in configfile
                                # not really needed.. just for cosmetics..
                                tm = localtime(x[1].value)


@@ -203,25 +242,103 @@ class NimSetup(Screen, ConfigListScreen):
                self.saveAll()
 
        def fillListWithAdvancedSatEntrys(self, Sat):
                self.saveAll()
 
        def fillListWithAdvancedSatEntrys(self, Sat):

-               currLnb = self.nimConfig.advanced.lnb[int(Sat.lnb.value)]
-               
+               lnbnum = int(Sat.lnb.value)
+               currLnb = self.nimConfig.advanced.lnb[lnbnum]
+               diction = None

                if isinstance(currLnb, ConfigNothing):
                        currLnb = None
 
                if isinstance(currLnb, ConfigNothing):
                        currLnb = None
 

-               self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage))
-               self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode))
-               if currLnb and currLnb.diseqcMode.value == "1_2":
-                       self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals)
-                       self.list.append(self.advancedUsalsEntry)
-                       if not Sat.usals.value:
-                               self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition))
-

                # LNBs
                self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb)
                self.list.append(self.advancedLnbsEntry)
                # LNBs
                self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb)
                self.list.append(self.advancedLnbsEntry)

+

                if currLnb:
                if currLnb:

-                       self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode)
-                       self.list.append(self.advancedDiseqcMode)
+                       if isFBCLink(self.nim.slot):
+                               if currLnb.lof.value != "unicable":
+                                       currLnb.lof.value = "unicable"
+
+                       self.list.append(getConfigListEntry(_("Priority"), currLnb.prio))
+                       self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof)
+                       self.list.append(self.advancedLof)
+                       if currLnb.lof.value == "user_defined":
+                               self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl))
+                               self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh))
+                               self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold))
+#                      self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v))
+                       
+                       if currLnb.lof.value == "unicable":
+                               self.advancedUnicable = getConfigListEntry("Unicable "+_("Configuration Mode"), currLnb.unicable)
+                               self.list.append(self.advancedUnicable)
+                               if currLnb.unicable.value == "unicable_user":
+                                       self.advancedDiction = getConfigListEntry(_("Diction"), currLnb.dictionuser)
+                                       self.list.append(self.advancedDiction)
+
+                                       if currLnb.dictionuser.value == "EN50494":
+                                               satcr = currLnb.satcruserEN50494
+                                               stcrvco = currLnb.satcrvcouserEN50494[currLnb.satcruserEN50494.index]
+                                       elif currLnb.dictionuser.value == "EN50607":
+                                               satcr = currLnb.satcruserEN50607
+                                               stcrvco = currLnb.satcrvcouserEN50607[currLnb.satcruserEN50607.index]
+
+                                       self.advancedSCR = getConfigListEntry(_("Channel"), satcr)
+                                       self.list.append(self.advancedSCR)
+                                       self.list.append(getConfigListEntry(_("Frequency"), stcrvco))
+
+                                       self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl))
+                                       self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh))
+                                       self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold))
+                               elif currLnb.unicable.value == "unicable_matrix":
+                                       manufacturer_name = currLnb.unicableMatrixManufacturer.value
+                                       manufacturer = currLnb.unicableMatrix[manufacturer_name]
+#                                      if "product" in manufacturer.content:
+                                       product_name = manufacturer.product.value
+                                       self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableMatrixManufacturer)
+                                       self.list.append(self.advancedManufacturer)
+                                       if product_name in manufacturer.scr:
+                                               diction = manufacturer.diction[product_name].value
+                                               self.advancedType = getConfigListEntry(_("Type"), manufacturer.product)
+                                               self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name])
+                                               self.list.append(self.advancedType)
+                                               self.list.append(self.advancedSCR)
+                                               self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index])) 
+                               elif currLnb.unicable.value == "unicable_lnb":
+                                       manufacturer_name = currLnb.unicableLnbManufacturer.value
+                                       manufacturer = currLnb.unicableLnb[manufacturer_name]
+#                                      if "product" in manufacturer.content:
+                                       product_name = manufacturer.product.value
+                                       self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableLnbManufacturer)
+                                       self.list.append(self.advancedManufacturer)
+                                       if product_name in manufacturer.scr:
+                                               diction = manufacturer.diction[product_name].value
+                                               self.advancedType = getConfigListEntry(_("Type"), manufacturer.product)
+                                               self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name])
+                                               self.list.append(self.advancedType)
+                                               self.list.append(self.advancedSCR)
+                                               self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index])) 
+
+                               choices = []
+                               connectable = nimmanager.canConnectTo(self.slotid)
+                               for id in connectable:
+                                       choices.append((str(id), nimmanager.getNimDescription(id)))
+                               if len(choices):
+                                       if isFBCLink(self.nim.slot):
+                                               if self.nimConfig.advanced.unicableconnected.value != True:
+                                                       self.nimConfig.advanced.unicableconnected.value = True
+
+                                       self.advancedConnected = getConfigListEntry(_("connected"), self.nimConfig.advanced.unicableconnected)
+                                       self.list.append(self.advancedConnected)
+                                       if self.nimConfig.advanced.unicableconnected.value == True:
+                                               self.nimConfig.advanced.unicableconnectedTo.setChoices(choices)
+                                               self.list.append(getConfigListEntry(_("Connected to"),self.nimConfig.advanced.unicableconnectedTo))
+
+                       else:   #kein Unicable
+                               self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage))
+                               self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage))
+                               self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode))
+
+                       if lnbnum < 65 and diction !="EN50607":
+                               self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode)
+                               self.list.append(self.advancedDiseqcMode)

                        if currLnb.diseqcMode.value != "none":
                                self.list.append(getConfigListEntry(_("Toneburst"), currLnb.toneburst))
                                self.list.append(getConfigListEntry(_("Committed DiSEqC command"), currLnb.commitedDiseqcCommand))
                        if currLnb.diseqcMode.value != "none":
                                self.list.append(getConfigListEntry(_("Toneburst"), currLnb.toneburst))
                                self.list.append(getConfigListEntry(_("Committed DiSEqC command"), currLnb.commitedDiseqcCommand))


@@ -265,14 +382,12 @@ class NimSetup(Screen, ConfigListScreen):
                                                if currLnb.powerMeasurement.value:
                                                        currLnb.powerMeasurement.value = False
                                                        currLnb.powerMeasurement.save()
                                                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.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl))
-                               self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh))
-                               self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold))
-#                      self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v))
-                       self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage))
+                                       self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals)
+                                       self.list.append(self.advancedUsalsEntry)
+                                       if not Sat.usals.value:
+                                               self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition))
+
+       

 
        def fillAdvancedList(self):
                self.list = [ ]
 
        def fillAdvancedList(self):
                self.list = [ ]


@@ -280,21 +395,57 @@ class NimSetup(Screen, ConfigListScreen):
                self.list.append(self.configMode)
                self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats)
                self.list.append(self.advancedSatsEntry)
                self.list.append(self.configMode)
                self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats)
                self.list.append(self.advancedSatsEntry)

-               for x in nimmanager.satList:
-                       Sat = self.nimConfig.advanced.sat[x[0]]
+               for x in self.nimConfig.advanced.sat.keys():
+                       Sat = self.nimConfig.advanced.sat[x]

                        self.fillListWithAdvancedSatEntrys(Sat)
                self["config"].list = self.list
 
                        self.fillListWithAdvancedSatEntrys(Sat)
                self["config"].list = self.list
 

+       def checkLoopthrough(self):
+               if self.nimConfig.configMode.value == "loopthrough":
+                       loopthrough_count = 0
+                       dvbs_slots = nimmanager.getNimListOfType('DVB-S')
+                       dvbs_slots_len = len(dvbs_slots)
+
+                       for x in dvbs_slots:
+                               try:
+                                       nim_slot = nimmanager.nim_slots[x]
+                                       if nim_slot == self.nimConfig:
+                                               self_idx = x
+                                       if nim_slot.config.configMode.value == "loopthrough":
+                                               loopthrough_count += 1
+                               except: pass
+                       if loopthrough_count >= dvbs_slots_len:
+                               return False
+
+               self.slot_dest_list = []
+               def checkRecursiveConnect(slot_id):
+                       if slot_id in self.slot_dest_list:
+                               return False
+                       self.slot_dest_list.append(slot_id)
+                       slot_config = nimmanager.nim_slots[slot_id].config
+                       if slot_config.configMode.value == "loopthrough":
+                               return checkRecursiveConnect(int(slot_config.connectedTo.value))
+                       return True
+
+               return checkRecursiveConnect(self.slotid)
+

        def keySave(self):
        def keySave(self):

+               if not self.checkLoopthrough():
+                       self.session.open(MessageBox, _("The loopthrough setting is wrong."),MessageBox.TYPE_ERROR,timeout=10)
+                       return
+

                old_configured_sats = nimmanager.getConfiguredSats()
                self.run()
                new_configured_sats = nimmanager.getConfiguredSats()
                self.unconfed_sats = old_configured_sats - new_configured_sats
                self.satpos_to_remove = None
                old_configured_sats = nimmanager.getConfiguredSats()
                self.run()
                new_configured_sats = nimmanager.getConfiguredSats()
                self.unconfed_sats = old_configured_sats - new_configured_sats
                self.satpos_to_remove = None

-               self.deleteConfirmed(False)
+               self.deleteConfirmed((None, "no"))

 
        def deleteConfirmed(self, confirmed):
 
        def deleteConfirmed(self, confirmed):

-               if confirmed:
+               if confirmed is None:
+                       confirmed = (None, "no")
+
+               if confirmed[1] == "yes" or confirmed[1] == "yestoall":

                        eDVBDB.getInstance().removeServices(-1, -1, -1, self.satpos_to_remove)
 
                if self.satpos_to_remove is not None:
                        eDVBDB.getInstance().removeServices(-1, -1, -1, self.satpos_to_remove)
 
                if self.satpos_to_remove is not None:


@@ -314,21 +465,29 @@ class NimSetup(Screen, ConfigListScreen):
                                else:
                                        h = _("E")
                                sat_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)
                                else:
                                        h = _("E")
                                sat_name = ("%d.%d" + h) % (orbpos / 10, orbpos % 10)

-                       self.session.openWithCallback(self.deleteConfirmed, MessageBox, _("Delete no more configured satellite\n%s?") %(sat_name))
+                               
+                       if confirmed[1] == "yes" or confirmed[1] == "no":
+                               self.session.openWithCallback(self.deleteConfirmed, ChoiceBox, _("Delete no more configured satellite\n%s?") %(sat_name), [(_("Yes"), "yes"), (_("No"), "no"), (_("Yes to all"), "yestoall"), (_("No to all"), "notoall")])
+                       if confirmed[1] == "yestoall" or confirmed[1] == "notoall":
+                               self.deleteConfirmed(confirmed)

                        break
                        break

-               if not self.satpos_to_remove:
-                       self.close()
+               else:
+                       self.restoreService(_("Zap back to service before tuner setup?"))

 
        def __init__(self, session, slotid):
                Screen.__init__(self, session)
                self.list = [ ]
 
        def __init__(self, session, slotid):
                Screen.__init__(self, session)
                self.list = [ ]

+               
+               ServiceStopScreen.__init__(self)
+               self.stopService()

 
                ConfigListScreen.__init__(self, self.list)
 
 
                ConfigListScreen.__init__(self, self.list)
 

-               self["actions"] = ActionMap(["SetupActions"],
+               self["actions"] = ActionMap(["SetupActions", "SatlistShortcutAction"],

                {
                        "ok": self.keySave,
                        "cancel": self.keyCancel,
                {
                        "ok": self.keySave,
                        "cancel": self.keyCancel,

+                       "nothingconnected": self.nothingConnectedShortcut

                }, -2)
 
                self.slotid = slotid
                }, -2)
 
                self.slotid = slotid


@@ -338,13 +497,31 @@ class NimSetup(Screen, ConfigListScreen):
                self.createSetup()
 
        def keyLeft(self):
                self.createSetup()
 
        def keyLeft(self):

+               if isFBCLink(self.nim.slot):
+                       checkList = (self.advancedLof, self.advancedConnected)
+                       curEntry = self["config"].getCurrent()
+                       if curEntry in checkList:
+                               return
+

                ConfigListScreen.keyLeft(self)
                self.newConfig()
 
        def keyRight(self):
                ConfigListScreen.keyLeft(self)
                self.newConfig()
 
        def keyRight(self):

+               if isFBCLink(self.nim.slot):
+                       checkList = (self.advancedLof, self.advancedConnected)
+                       curEntry = self["config"].getCurrent()
+                       if curEntry in checkList:
+                               return
+

                ConfigListScreen.keyRight(self)
                self.newConfig()
                
                ConfigListScreen.keyRight(self)
                self.newConfig()
                

+       def keyCancel(self):
+               if self["config"].isChanged():
+                       self.session.openWithCallback(self.cancelConfirm, MessageBox, _("Really close without saving settings?"))
+               else:
+                       self.restoreService(_("Zap back to service before tuner setup?"))
+               

        def saveAll(self):
                if self.nim.isCompatible("DVB-S"):
                        # reset connectedTo to all choices to properly store the default value
        def saveAll(self):
                if self.nim.isCompatible("DVB-S"):
                        # reset connectedTo to all choices to properly store the default value


@@ -364,17 +541,23 @@ class NimSetup(Screen, ConfigListScreen):
                        x[1].cancel()
                # we need to call saveAll to reset the connectedTo choices
                self.saveAll()
                        x[1].cancel()
                # we need to call saveAll to reset the connectedTo choices
                self.saveAll()

-               self.close()
-                       
+               self.restoreService(_("Zap back to service before tuner setup?"))
+               
+       def nothingConnectedShortcut(self):
+               if type(self["config"].getCurrent()[1]) is ConfigSatlist:
+                       self["config"].getCurrent()[1].setValue("3601")
+                       self["config"].invalidateCurrent()
+

 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.loadFBCLinks()
+               self.updateList()
+               
+               self.setResultClass()

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


@@ -382,8 +565,102 @@ class NimSelection(Screen):
                        "cancel": self.close
                }, -2)
 
                        "cancel": self.close
                }, -2)
 

+       def loadFBCLinks(self):
+               for x in nimmanager.nim_slots:
+                       slotid = x.slot
+                       nimConfig = nimmanager.getNimConfig(x.slot)
+                       configMode = nimConfig.configMode.value
+                       if self.showNim(x):
+                               if x.isCompatible("DVB-S"):
+                                       if isFBCLink(x.slot) and configMode != "advanced":
+                                               link = getLinkedSlotID(x.slot)
+
+                                               if link == -1:
+                                                       nimConfig.configMode.value = "nothing"
+                                               else:
+                                                       nimConfig.configMode.value = "loopthrough"
+                                                       nimConfig.connectedTo.value = str(link)
+               
+       def setResultClass(self):
+               self.resultclass = NimSetup
+

        def okbuttonClick(self):
                nim = self["nimlist"].getCurrent()
        def okbuttonClick(self):
                nim = self["nimlist"].getCurrent()

-               nim = nim and nim[1]
-               if nim is not None and not nim.empty:
-                       self.session.open(NimSetup, nim.slot)
+               nim = nim and nim[3]
+
+               nimConfig = nimmanager.getNimConfig(nim.slot)
+               if isFBCLink(nim.slot) and nimConfig.configMode.value == "loopthrough":
+                       return
+
+               if nim is not None and not nim.empty and nim.isSupported():
+                       self.session.openWithCallback(self.NimSetupCB, self.resultclass, nim.slot)
+
+       def NimSetupCB(self):
+               self.loadFBCLinks()
+               self.updateList()
+                       
+       def showNim(self, nim):
+               return True
+
+       def updateList(self):
+               self.list = [ ]
+               for x in nimmanager.nim_slots:
+                       slotid = x.slot
+                       nimConfig = nimmanager.getNimConfig(x.slot)
+                       text = nimConfig.configMode.value
+                       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") + " " + chr(ord('A')+int(nimConfig.connectedTo.value))
+                                       elif nimConfig.configMode.value == "nothing":
+                                               text = _("not configured")
+                                       elif nimConfig.configMode.value == "simple":
+                                               if nimConfig.diseqcMode.value in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
+                                                       text = {"single": _("Single"), "toneburst_a_b": _("Toneburst A/B"), "diseqc_a_b": _("DiSEqC A/B"), "diseqc_a_b_c_d": _("DiSEqC A/B/C/D")}[nimConfig.diseqcMode.value] + "\n"
+                                                       text += _("Sats") + ": " 
+                                                       satnames = []
+                                                       if nimConfig.diseqcA.orbital_position != 3601:
+                                                               satnames.append(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:
+                                                                       satnames.append(nimmanager.getSatName(int(nimConfig.diseqcB.value)))
+                                                       if nimConfig.diseqcMode.value == "diseqc_a_b_c_d":
+                                                               if nimConfig.diseqcC.orbital_position != 3601:
+                                                                       satnames.append(nimmanager.getSatName(int(nimConfig.diseqcC.value)))
+                                                               if nimConfig.diseqcD.orbital_position != 3601:
+                                                                       satnames.append(nimmanager.getSatName(int(nimConfig.diseqcD.value)))
+                                                       if len(satnames) <= 2:
+                                                               text += ", ".join(satnames)
+                                                       elif len(satnames) > 2:
+                                                               # we need a newline here, since multi content lists don't support automtic line wrapping
+                                                               text += ", ".join(satnames[:2]) + ",\n"
+                                                               text += "         " + ", ".join(satnames[2:])
+                                               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")
+                                       if isFBCLink(x.slot) and nimConfig.configMode.value != "advanced":
+                                               text += _("\n<This tuner is configured automatically>")
+                               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")
+                               if x.isMultiType():
+                                       text = _("Switchable tuner types:") + "(" + ','.join(x.getMultiTypeList().values()) + ")" + "\n" + text
+                               if not x.isSupported():
+                                       text = _("tuner is not supported")
+                                       
+                               self.list.append((slotid, x.friendly_full_description, text, x))
+               self["nimlist"].setList(self.list)
+               self["nimlist"].updateList(self.list)
+