refs bug #485

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

diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py
index 3e71912..5dc3cb4 100644 (file)
--- a/lib/python/Screens/ScanSetup.py
+++ b/lib/python/Screens/ScanSetup.py
@@ -1,4 +1,5 @@
 from Screen import Screen
 from Screen import Screen

+from Screens.DefaultWizard import DefaultWizard

 from ServiceScan import ServiceScan
 from Components.config import config, ConfigSubsection, ConfigSelection, \
        ConfigYesNo, ConfigInteger, getConfigListEntry, ConfigSlider, ConfigEnableDisable
 from ServiceScan import ServiceScan
 from Components.config import config, ConfigSubsection, ConfigSelection, \
        ConfigYesNo, ConfigInteger, getConfigListEntry, ConfigSlider, ConfigEnableDisable


@@ -6,6 +7,8 @@ from Components.ActionMap import NumberActionMap, ActionMap
 from Components.ConfigList import ConfigListScreen
 from Components.NimManager import nimmanager, getConfigSatlist
 from Components.Label import Label
 from Components.ConfigList import ConfigListScreen
 from Components.NimManager import nimmanager, getConfigSatlist
 from Components.Label import Label

+from Tools.Directories import resolveFilename, SCOPE_DEFAULTPARTITIONMOUNTDIR, SCOPE_DEFAULTDIR, SCOPE_DEFAULTPARTITION
+from Tools.HardwareInfo import HardwareInfo

 from Screens.MessageBox import MessageBox
 from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, \
        eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, \
 from Screens.MessageBox import MessageBox
 from enigma import eTimer, eDVBFrontendParametersSatellite, eComponentScan, \
        eDVBSatelliteEquipmentControl, eDVBFrontendParametersTerrestrial, \


@@ -15,64 +18,17 @@ def buildTerTransponder(frequency,
                inversion=2, bandwidth = 3, fechigh = 6, feclow = 6,
                modulation = 2, transmission = 2, guard = 4,
                hierarchy = 4):
                inversion=2, bandwidth = 3, fechigh = 6, feclow = 6,
                modulation = 2, transmission = 2, guard = 4,
                hierarchy = 4):

-

 #      print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy
 #      print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy

-
-       # WARNING: normally, enums are working directly.
-       # Don't copy this (very bad)!! Instead either fix swig (good) or
-       # move this into a central place.
-       Bw8MHz = 0
-       Bw7MHz = 1
-       Bw6MHz = 2
-       #Bw5MHz = 3 #not implemented for e1 compatibilty
-       BwAuto = 3
-       
-       f1_2 = 0
-       f2_3 = 1
-       f3_4 = 2
-       f5_6 = 3
-       f7_8 = 4
-       fAuto = 5
-       
-       TM2k = 0
-       TM8k = 1
-       #TM4k = 2  #not implemented for e1 compatibilty
-       TMAuto = 2
-       
-       GI_1_32 = 0
-       GI_1_16 = 1
-       GI_1_8 = 2
-       GI_1_4 = 3
-       GI_Auto = 4
-       
-       HNone = 0
-       H1 = 1
-       H2 = 2
-       H4 = 3
-       HAuto = 4
-
-       QPSK = 0
-       QAM16 = 1
-       QAM64 = 2
-       Auto = 3
-       
-       Off = 0
-       On = 1
-       Unknown = 2
-

        parm = eDVBFrontendParametersTerrestrial()
        parm = eDVBFrontendParametersTerrestrial()

-

        parm.frequency = frequency
        parm.frequency = frequency

-
-       parm.inversion = [Off, On, Unknown][inversion]
-       parm.bandwidth = [Bw8MHz, Bw7MHz, Bw6MHz, BwAuto][bandwidth] # Bw5MHz unsupported
-       parm.code_rate_HP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][fechigh]
-       parm.code_rate_LP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][feclow]
-       parm.modulation = [QPSK, QAM16, QAM64, Auto][modulation]
-       parm.transmission_mode = [TM2k, TM8k, TMAuto][transmission] # TM4k unsupported
-       parm.guard_interval = [GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto][guard]
-       parm.hierarchy = [HNone, H1, H2, H4, HAuto][hierarchy]
-       
+       parm.inversion = inversion
+       parm.bandwidth = bandwidth
+       parm.code_rate_HP = fechigh
+       parm.code_rate_LP = feclow
+       parm.modulation = modulation
+       parm.transmission_mode = transmission
+       parm.guard_interval = guard
+       parm.hierarchy = hierarchy

        return parm
 
 def getInitialTransponderList(tlist, pos):
        return parm
 
 def getInitialTransponderList(tlist, pos):


@@ -84,10 +40,12 @@ def getInitialTransponderList(tlist, pos):
                        parm.symbol_rate = x[2]
                        parm.polarisation = x[3]
                        parm.fec = x[4]
                        parm.symbol_rate = x[2]
                        parm.polarisation = x[3]
                        parm.fec = x[4]

-                       parm.inversion = 2 # AUTO
+                       parm.inversion = x[7]

                        parm.orbital_position = pos
                        parm.system = x[5]
                        parm.modulation = x[6]
                        parm.orbital_position = pos
                        parm.system = x[5]
                        parm.modulation = x[6]

+                       parm.rolloff = x[8]
+                       parm.pilot = x[9]

                        tlist.append(parm)
 
 def getInitialCableTransponderList(tlist, nim):
                        tlist.append(parm)
 
 def getInitialCableTransponderList(tlist, nim):


@@ -99,7 +57,7 @@ def getInitialCableTransponderList(tlist, nim):
                        parm.symbol_rate = x[2]
                        parm.modulation = x[3]
                        parm.fec_inner = x[4]
                        parm.symbol_rate = x[2]
                        parm.modulation = x[3]
                        parm.fec_inner = x[4]

-                       parm.inversion = 2 # AUTO
+                       parm.inversion = parm.Inversion_Unknown

                        #print "frequency:", x[1]
                        #print "symbol_rate:", x[2]
                        #print "modulation:", x[3]
                        #print "frequency:", x[1]
                        #print "symbol_rate:", x[2]
                        #print "modulation:", x[3]


@@ -156,6 +114,9 @@ class CableTransponderSearchSupport:
 
        def cableTransponderSearchSessionClosed(self, *val):
                print "cableTransponderSearchSessionClosed, val", val
 
        def cableTransponderSearchSessionClosed(self, *val):
                print "cableTransponderSearchSessionClosed, val", val

+               self.resetTimeout()
+               self.cable_search_container.appClosed.remove(self.cableTransponderSearchClosed)
+               self.cable_search_container.dataAvail.remove(self.getCableTransponderData)

                self.cable_search_container = None
                self.cable_search_session = None
                if val and len(val) and val[0]:
                self.cable_search_container = None
                self.cable_search_session = None
                if val and len(val) and val[0]:


@@ -172,10 +133,23 @@ class CableTransponderSearchSupport:
                if len(data):
                        if data[0] == 'OK':
                                print str
                if len(data):
                        if data[0] == 'OK':
                                print str

-                               qam = { "QAM16" : 1, "QAM32" : 2, "QAM64" : 3, "QAM128" : 4, "QAM256" : 5 }
-                               inv = { "INVERSION_OFF" : 0, "INVERSION_ON" : 1 }
-                               fec = { "FEC_AUTO" : 0, "FEC_1_2" : 1, "FEC_2_3" : 2, "FEC_3_4" : 3, "FEC_5_6": 4, "FEC_7_8" : 5, "FEC_8_9" : 6, "FEC_NONE" : 15 }

                                parm = eDVBFrontendParametersCable()
                                parm = eDVBFrontendParametersCable()

+                               qam = { "QAM16" : parm.Modulation_QAM16,
+                                       "QAM32" : parm.Modulation_QAM32,
+                                       "QAM64" : parm.Modulation_QAM64,
+                                       "QAM128" : parm.Modulation_QAM128,
+                                       "QAM256" : parm.Modulation_QAM256 }
+                               inv = { "INVERSION_OFF" : parm.Inversion_Off,
+                                       "INVERSION_ON" : parm.Inversion_On,
+                                       "INVERSION_AUTO" : parm.Inversion_Unknown }
+                               fec = { "FEC_AUTO" : parm.FEC_Auto,
+                                       "FEC_1_2" : parm.FEC_1_2,
+                                       "FEC_2_3" : parm.FEC_2_3,
+                                       "FEC_3_4" : parm.FEC_3_4,
+                                       "FEC_5_6": parm.FEC_5_6,
+                                       "FEC_7_8" : parm.FEC_7_8,
+                                       "FEC_8_9" : parm.FEC_8_9,
+                                       "FEC_NONE" : parm.FEC_None }

                                parm.frequency = int(data[1])
                                parm.symbol_rate = int(data[2])
                                parm.fec_inner = fec[data[3]]
                                parm.frequency = int(data[1])
                                parm.symbol_rate = int(data[2])
                                parm.fec_inner = fec[data[3]]


@@ -188,6 +162,19 @@ class CableTransponderSearchSupport:
                tmpstr += " kHz "
                tmpstr += data[0]
                self.cable_search_session["text"].setText(tmpstr)
                tmpstr += " kHz "
                tmpstr += data[0]
                self.cable_search_session["text"].setText(tmpstr)

+               
+       def setTimeout(self):
+               try:
+                       self.oldtimeoutvalue = open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "r").readline()
+                       open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write("0")
+               except:
+                       print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"                
+               
+       def resetTimeout(self):
+               try:
+                       open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write(self.oldtimeoutvalue)
+               except:
+                       print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"

 
        def startCableTransponderSearch(self, nim_idx):
                if not self.tryGetRawFrontend(nim_idx):
 
        def startCableTransponderSearch(self, nim_idx):
                if not self.tryGetRawFrontend(nim_idx):


@@ -201,13 +188,16 @@ class CableTransponderSearchSupport:
                                        return
                self.__tlist = [ ]
                self.cable_search_container = eConsoleAppContainer()
                                        return
                self.__tlist = [ ]
                self.cable_search_container = eConsoleAppContainer()

-               self.cable_search_container.appClosed.get().append(self.cableTransponderSearchClosed)
-               self.cable_search_container.dataAvail.get().append(self.getCableTransponderData)
+               self.cable_search_container.appClosed.append(self.cableTransponderSearchClosed)
+               self.cable_search_container.dataAvail.append(self.getCableTransponderData)

                cableConfig = config.Nims[nim_idx].cable
                cmd = "tda1002x --init --scan --verbose --wakeup --inv 2 --bus "
                #FIXMEEEEEE hardcoded i2c devices for dm7025 and dm8000
                if nim_idx < 2:
                cableConfig = config.Nims[nim_idx].cable
                cmd = "tda1002x --init --scan --verbose --wakeup --inv 2 --bus "
                #FIXMEEEEEE hardcoded i2c devices for dm7025 and dm8000
                if nim_idx < 2:

-                       cmd += str(nim_idx)
+                       if HardwareInfo().get_device_name() == "dm500hd":
+                               cmd += "2"
+                       else:
+                               cmd += str(nim_idx)

                else:
                        if nim_idx == 2:
                                cmd += "2" # first nim socket on DM8000 use /dev/i2c/2
                else:
                        if nim_idx == 2:
                                cmd += "2" # first nim socket on DM8000 use /dev/i2c/2


@@ -271,8 +261,30 @@ class CableTransponderSearchSupport:
                self.cable_search_container.execute(cmd)
                tmpstr = _("Try to find used transponders in cable network.. please wait...")
                tmpstr += "\n\n..."
                self.cable_search_container.execute(cmd)
                tmpstr = _("Try to find used transponders in cable network.. please wait...")
                tmpstr += "\n\n..."

+               self.setTimeout()

                self.cable_search_session = self.session.openWithCallback(self.cableTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
 
                self.cable_search_session = self.session.openWithCallback(self.cableTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
 

+class DefaultSatLists(DefaultWizard):
+       def __init__(self, session, silent = True, showSteps = False):
+               self.xmlfile = "defaultsatlists.xml"
+               DefaultWizard.__init__(self, session, silent, showSteps, neededTag = "services")
+               print "configuredSats:", nimmanager.getConfiguredSats()
+
+       def setDirectory(self):
+               self.directory = []
+               self.directory.append(resolveFilename(SCOPE_DEFAULTDIR))
+               import os
+               os.system("mount %s %s" % (resolveFilename(SCOPE_DEFAULTPARTITION), resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR)))
+               self.directory.append(resolveFilename(SCOPE_DEFAULTPARTITIONMOUNTDIR))
+                               
+       def statusCallback(self, status, progress):
+               print "statusCallback:", status, progress
+               from Components.DreamInfoHandler import DreamInfoHandler
+               if status == DreamInfoHandler.STATUS_DONE:
+                       self["text"].setText(_("The installation of the default services lists is finished.") + "\n\n" + _("Please press OK to continue."))
+                       self.markDone()
+                       self.disableKeys = False        
+

 class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
        def __init__(self, session):
                Screen.__init__(self, session)
 class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
        def __init__(self, session):
                Screen.__init__(self, session)


@@ -303,9 +315,11 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
 
                self.list = []
                ConfigListScreen.__init__(self, self.list)
 
                self.list = []
                ConfigListScreen.__init__(self, self.list)

-               self.createSetup()
-
-               self["introduction"] = Label(_("Press OK to start the scan"))
+               if not self.scan_nims.value == "":
+                       self.createSetup()
+                       self["introduction"] = Label(_("Press OK to start the scan"))
+               else:
+                       self["introduction"] = Label(_("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."))

 
        def runAsync(self, finished_cb):
                self.finished_cb = finished_cb
 
        def runAsync(self, finished_cb):
                self.finished_cb = finished_cb


@@ -333,6 +347,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                
                self.typeOfScanEntry = None
                self.systemEntry = None
                
                self.typeOfScanEntry = None
                self.systemEntry = None

+               self.modulationEntry = None

                nim = nimmanager.nim_slots[index_to_scan]
                if nim.isCompatible("DVB-S"):
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
                nim = nimmanager.nim_slots[index_to_scan]
                if nim.isCompatible("DVB-S"):
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)


@@ -344,6 +359,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial)
                        self.list.append(self.typeOfScanEntry)
 
                        self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial)
                        self.list.append(self.typeOfScanEntry)
 

+               self.scan_networkScan.value = False

                if nim.isCompatible("DVB-S"):
                        if self.scan_type.value == "single_transponder":
                                self.updateSatList()
                if nim.isCompatible("DVB-S"):
                        if self.scan_type.value == "single_transponder":
                                self.updateSatList()


@@ -352,38 +368,36 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        self.list.append(self.systemEntry)
                                else:
                                        # downgrade to dvb-s, in case a -s2 config was active
                                        self.list.append(self.systemEntry)
                                else:
                                        # downgrade to dvb-s, in case a -s2 config was active

-                                       self.scan_sat.system.value = "dvb-s"
+                                       self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S

                                self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan]))
                                self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                                self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
                                self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))
                                self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan]))
                                self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency))
                                self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion))
                                self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate))
                                self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization))

-                               if self.scan_sat.system.value == "dvb-s":
+                               if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:

                                        self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))
                                        self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec))

-                               elif self.scan_sat.system.value == "dvb-s2":
+                               elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2:

                                        self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
                                        self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))

-                                       self.list.append(getConfigListEntry(_('Modulation'), self.scan_sat.modulation))
-                               self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
+                                       self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation)
+                                       self.list.append(self.modulationEntry)
+                                       self.list.append(getConfigListEntry(_('Rolloff'), self.scan_sat.rolloff))
+                                       self.list.append(getConfigListEntry(_('Pilot'), self.scan_sat.pilot))

                        elif self.scan_type.value == "single_satellite":
                                self.updateSatList()
                                print self.scan_satselection[index_to_scan]
                                self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan]))
                        elif self.scan_type.value == "single_satellite":
                                self.updateSatList()
                                print self.scan_satselection[index_to_scan]
                                self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[index_to_scan]))

-                               self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
-                       elif self.scan_type.value == "multisat":
-                               # if (norotor)
+                               self.scan_networkScan.value = True
+                       elif self.scan_type.value.find("multisat") != -1:

                                tlist = []
                                SatList = nimmanager.getSatListForNim(index_to_scan)
                                tlist = []
                                SatList = nimmanager.getSatListForNim(index_to_scan)

-                               self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))

                                for x in SatList:
                                        if self.Satexists(tlist, x[0]) == 0:
                                                tlist.append(x[0])
                                for x in SatList:
                                        if self.Satexists(tlist, x[0]) == 0:
                                                tlist.append(x[0])

-                                               sat = ConfigEnableDisable(default = True)
+                                               sat = ConfigEnableDisable(default = self.scan_type.value.find("_yes") != -1 and True or False)

                                                configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat)
                                                self.list.append(configEntry)
                                                self.multiscanlist.append((x[0], sat))
                                                configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat)
                                                self.list.append(configEntry)
                                                self.multiscanlist.append((x[0], sat))

-                               # if (rotor):
-                          # for sat in nimmanager.satList:
-                               #       self.list.append(getConfigListEntry(sat[1], self.scan_scansat[sat[0]]))
+                               self.scan_networkScan.value = True

                elif nim.isCompatible("DVB-C"):
                        if self.scan_typecable.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency))
                elif nim.isCompatible("DVB-C"):
                        if self.scan_typecable.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency))


@@ -391,9 +405,6 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                self.list.append(getConfigListEntry(_("Symbol Rate"), self.scan_cab.symbolrate))
                                self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation))
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
                                self.list.append(getConfigListEntry(_("Symbol Rate"), self.scan_cab.symbolrate))
                                self.list.append(getConfigListEntry(_("Modulation"), self.scan_cab.modulation))
                                self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))

-                               self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
-                       elif self.scan_typecable.value == "complete":
-                               self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))

                elif nim.isCompatible("DVB-T"):
                        if self.scan_typeterrestrial.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
                elif nim.isCompatible("DVB-T"):
                        if self.scan_typeterrestrial.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))


@@ -405,23 +416,9 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
                                self.list.append(getConfigListEntry(_("Guard interval mode"), self.scan_ter.guard))
                                self.list.append(getConfigListEntry(_("Hierarchy mode"), self.scan_ter.hierarchy))
                                self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
                                self.list.append(getConfigListEntry(_("Guard interval mode"), self.scan_ter.guard))
                                self.list.append(getConfigListEntry(_("Hierarchy mode"), self.scan_ter.hierarchy))

-                               self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
-                       elif self.scan_typeterrestrial.value == "complete":
-                               self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
-
-#              if (nim.isCompatible("DVB-S") and self.scan_type.type == "single_transponder") or \
-#                      (nim.isCompatbile("DVB-C") and self.scan_typecable.type == "single_transponder") or \
-#                      (nim.isCompatible("DVB-T") and self.scan_typeterrestrial.type == "single_transponder"):
-#                              self.configElementSNR = getConfigListEntry(_("SNR"), self.scan_snr)
-#                              self.list.append(self.configElementSNR)
-#                              self.configElementACG = getConfigListEntry(_("AGC"), self.scan_agc)
-#                              self.list.append(self.configElementACG)
-#                              self.configElementBER = getConfigListEntry(_("BER"), self.scan_ber)
-#                              self.list.append(self.configElementBER)
-#                              self.statusTimer.start(500, False)
-#              else:
-#                      self.statusTimer.stop()
-
+               self.list.append(getConfigListEntry(_("Network scan"), self.scan_networkScan))
+               self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
+               self.list.append(getConfigListEntry(_("Only Free scan"), self.scan_onlyfree))

                self["config"].list = self.list
                self["config"].l.setList(self.list)
 
                self["config"].list = self.list
                self["config"].l.setList(self.list)
 


@@ -436,7 +433,8 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                print "cur is", cur
                if cur == self.typeOfScanEntry or \
                        cur == self.tunerEntry or \
                print "cur is", cur
                if cur == self.typeOfScanEntry or \
                        cur == self.tunerEntry or \

-                       cur == self.systemEntry:
+                       cur == self.systemEntry or \
+                       (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry):

                        self.createSetup()
 
        def createConfig(self, frontendData):
                        self.createSetup()
 
        def createConfig(self, frontendData):


@@ -470,48 +468,89 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                           #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT),
                                           #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT),
                                           #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT),
                                           #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT),
                                           #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT),
                                           #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT),

-                       defaultSat = { "orbpos": 192, "system": "dvb-s", "frequency": 11836, "inversion": "auto", "symbolrate": 27500, "polarization": "horizontal", "fec": "auto", "fec_s2": "9_10", "modulation": "qpsk" }
-                       defaultCab = {"frequency": 466, "inversion": "auto", "modulation": "64qam", "fec": "auto", "symbolrate": 6900}
+                       defaultSat = {
+                               "orbpos": 192,
+                               "system": eDVBFrontendParametersSatellite.System_DVB_S,
+                               "frequency": 11836,
+                               "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown,
+                               "symbolrate": 27500,
+                               "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal,
+                               "fec": eDVBFrontendParametersSatellite.FEC_Auto,
+                               "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10,
+                               "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK }
+                       defaultCab = {
+                               "frequency": 466,
+                               "inversion": eDVBFrontendParametersCable.Inversion_Unknown,
+                               "modulation": eDVBFrontendParametersCable.Modulation_QAM64,
+                               "fec": eDVBFrontendParametersCable.FEC_Auto,
+                               "symbolrate": 6900 }
+                       defaultTer = {
+                               "frequency" : 466000,
+                               "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown,
+                               "bandwidth" : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz,
+                               "fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto,
+                               "feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto,
+                               "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto,
+                               "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto,
+                               "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto,
+                               "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto }
+

                        if frontendData is not None:
                                ttype = frontendData.get("tuner_type", "UNKNOWN")
                                if ttype == "DVB-S":
                        if frontendData is not None:
                                ttype = frontendData.get("tuner_type", "UNKNOWN")
                                if ttype == "DVB-S":

-                                       defaultSat["system"] = {"DVB-S": "dvb-s", "DVB-S2": "dvb-s2"}[frontendData.get("system", "DVB-S")]
-                                       defaultSat["frequency"] = int(frontendData.get("frequency", 0) / 1000)
-                                       defaultSat["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")]
-                                       defaultSat["symbolrate"] = int(frontendData.get("symbol_rate", 0) / 1000)
-                                       defaultSat["polarization"] = {"HORIZONTAL": "horizontal", "VERTICAL": "vertical", "CIRCULAR_LEFT": "circular_left", "CIRCULAR_RIGHT": "circular_right", "UNKNOWN": None}[frontendData.get("polarization", "HORIZONTAL")]
-                                       
-                                       if frontendData.get("system", "DVB-S") == "DVB-S2":
-                                               defaultSat["fec_s2"] = {"FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_4_5": "4_5", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_9_10": "9_10"} \
-                                                                                       [frontendData.get("fec_inner", "FEC_AUTO")]
+                                       defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S)
+                                       defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000
+                                       defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown)
+                                       defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
+                                       defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal)
+                                       if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2:
+                                               defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
+                                               defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35)
+                                               defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown)

                                        else:
                                        else:

-                                               defaultSat["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_NONE": "none"} \
-                                                       [frontendData.get("fec_inner", "FEC_AUTO")]
-
-                                       defaultSat["modulation"] = {"QPSK": "qpsk", "8PSK": "8psk"}[frontendData.get("modulation", "QPSK")]
+                                               defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto)
+                                       defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK)

                                        defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
                                elif ttype == "DVB-C":
                                        defaultSat["orbpos"] = frontendData.get("orbital_position", 0)
                                elif ttype == "DVB-C":

-                                       defaultCab["frequency"] = int(frontendData.get("frequency", 0) / 1000)
-                                       defaultCab["symbolrate"] = int(frontendData.get("symbol_rate", 0) / 1000)
-                                       defaultCab["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")]
-                                       defaultCab["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_NONE": "none"}[frontendData.get("fec_inner", "FEC_AUTO")]
-                                       defaultCab["modulation"] = {"QAM_AUTO": "auto", "QAM_16": "16qam", "QAM_32": "32qam", "QAM_64": "64qam", "QAM_128": "128qam", "QAM_256": "256qam"}[frontendData.get("modulation", "QAM_16")]
+                                       defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000
+                                       defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000
+                                       defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown)
+                                       defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto)
+                                       defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16)
+                               elif ttype == "DVB-T":
+                                       defaultTer["frequency"] = frontendData.get("frequency", 0)
+                                       defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown)
+                                       defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz)
+                                       defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto)
+                                       defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto)
+                                       defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto)
+                                       defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto)
+                                       defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto)
+                                       defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto)

 
                        self.scan_sat = ConfigSubsection()
                        self.scan_cab = ConfigSubsection()
                        self.scan_ter = ConfigSubsection()
 
 
                        self.scan_sat = ConfigSubsection()
                        self.scan_cab = ConfigSubsection()
                        self.scan_ter = ConfigSubsection()
 

-                       self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat"))])
+                       self.scan_type = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat")), ("multisat_yes", _("Multisat"))])

                        self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
                        self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
                        self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))])
                        self.scan_typecable = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
                        self.scan_typeterrestrial = ConfigSelection(default = "single_transponder", choices = [("single_transponder", _("Single transponder")), ("complete", _("Complete"))])
                        self.scan_clearallservices = ConfigSelection(default = "no", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))])

+                       self.scan_onlyfree = ConfigYesNo(default = False)

                        self.scan_networkScan = ConfigYesNo(default = False)
 
                        nim_list = []
                        # collect all nims which are *not* set to "nothing"
                        for n in nimmanager.nim_slots:
                        self.scan_networkScan = ConfigYesNo(default = False)
 
                        nim_list = []
                        # collect all nims which are *not* set to "nothing"
                        for n in nimmanager.nim_slots:

-                               if n.config_mode != "nothing":
-                                       nim_list.append((str(n.slot), n.friendly_full_description))
+                               if n.config_mode == "nothing":
+                                       continue
+                               if n.config_mode == "advanced" and len(nimmanager.getSatListForNim(n.slot)) < 1:
+                                       continue
+                               if n.config_mode in ("loopthrough", "satposdepends"):
+                                       root_id = nimmanager.sec.getRoot(n.slot_id, int(n.config.connectedTo.value))
+                                       if n.type == nimmanager.nim_slots[root_id].type: # check if connected from a DVB-S to DVB-S2 Nim or vice versa
+                                               continue
+                               nim_list.append((str(n.slot), n.friendly_full_description))

 
                        self.scan_nims = ConfigSelection(choices = nim_list)
 
 
                        self.scan_nims = ConfigSelection(choices = nim_list)
 


@@ -524,34 +563,120 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        self.scan_ber.enabled = False
 
                        # sat
                        self.scan_ber.enabled = False
 
                        # sat

-                       self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [("dvb-s", _("DVB-S")), ("dvb-s2", _("DVB-S2"))])
+                       self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [
+                               (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")),
+                               (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))])

                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))
                        self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999))

-                       self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
+                       self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [
+                               (eDVBFrontendParametersSatellite.Inversion_Off, _("off")),
+                               (eDVBFrontendParametersSatellite.Inversion_On, _("on")),
+                               (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))])

                        self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))
                        self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999))

-                       self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [("horizontal", _("horizontal")), ("vertical", _("vertical")),  ("circular_left", _("circular left")), ("circular_right", _("circular right"))])
-                       self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("none", _("None"))])
-                       self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("3_5", "3/5"), ("4_5", "4/5"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("9_10", "9/10")])
-                       self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [("qpsk", "QPSK"), ("8psk", "8PSK")])
+                       self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [
+                               (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")),
+                               (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")),
+                               (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")),
+                               (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))])
+                       self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")),
+                               (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersSatellite.FEC_None, _("None"))])
+                       self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [
+                               (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"),
+                               (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"),
+                               (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"),
+                               (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")])
+                       self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [
+                               (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"),
+                               (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")])
+                       self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [
+                               (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"),
+                               (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"),
+                               (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")])
+                       self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [
+                               (eDVBFrontendParametersSatellite.Pilot_Off, _("off")),
+                               (eDVBFrontendParametersSatellite.Pilot_On, _("on")),
+                               (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))])

 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))
 
                        # cable
                        self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999))

-                       self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
-                       self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [("16qam", "16-QAM"), ("32qam", "32-QAM"), ("64qam", "64-QAM"), ("128qam", "128-QAM"), ("256qam", "256-QAM")])
-                       self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("none", _("None"))])
+                       self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [
+                               (eDVBFrontendParametersCable.Inversion_Off, _("off")),
+                               (eDVBFrontendParametersCable.Inversion_On, _("on")),
+                               (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))])
+                       self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [
+                               (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"),
+                               (eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")])
+                       self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [
+                               (eDVBFrontendParametersCable.FEC_Auto, _("Auto")),
+                               (eDVBFrontendParametersCable.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersCable.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersCable.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersCable.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersCable.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersCable.FEC_8_9, "8/9"),
+                               (eDVBFrontendParametersCable.FEC_None, _("None"))])

                        self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
 
                        # terrestial
                        self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000))
                        self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
 
                        # terrestial
                        self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000))

-                       self.scan_ter.inversion = ConfigSelection(default = "auto", choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
+                       self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Inversion_Off, _("off")),
+                               (eDVBFrontendParametersTerrestrial.Inversion_On, _("on")),
+                               (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))])

                        # WORKAROUND: we can't use BW-auto
                        # WORKAROUND: we can't use BW-auto

-                       self.scan_ter.bandwidth = ConfigSelection(default = "8MHz", choices = [("8MHz", "8MHz"), ("7MHz", "7MHz"), ("6MHz", "6MHz")])
-                       #, ("auto", _("Auto"))))
-                       self.scan_ter.fechigh = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))])
-                       self.scan_ter.feclow = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))])
-                       self.scan_ter.modulation = ConfigSelection(default = "auto", choices = [("qpsk", "QPSK"), ("qam16", "QAM16"), ("qam64", "QAM64"), ("auto", _("Auto"))])
-                       self.scan_ter.transmission = ConfigSelection(default = "auto", choices = [("2k", "2K"), ("8k", "8K"), ("auto", _("Auto"))])
-                       self.scan_ter.guard = ConfigSelection(default = "auto", choices = [("1_32", "1/32"), ("1_16", "1/16"), ("1_8", "1/8"), ("1_4", "1/4"), ("auto", _("Auto"))])
-                       self.scan_ter.hierarchy = ConfigSelection(default = "auto", choices = [("none", _("None")), ("1", "1"), ("2", "2"), ("4", "4"), ("auto", _("Auto"))])
+                       self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"),
+                               (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")])
+                       #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto"))))
+                       self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [
+                               (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
+                       self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [
+                               (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"),
+                               (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"),
+                               (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"),
+                               (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"),
+                               (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"),
+                               (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))])
+                       self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"),
+                               (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))])
+                       self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"),
+                               (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))])
+                       self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"),
+                               (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))])
+                       self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"),
+                               (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))])

 
                        self.scan_scansat = {}
                        for sat in nimmanager.satList:
 
                        self.scan_scansat = {}
                        for sat in nimmanager.satList:


@@ -561,7 +686,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        self.scan_satselection = []
                        for slot in nimmanager.nim_slots:
                                if slot.isCompatible("DVB-S"):
                        self.scan_satselection = []
                        for slot in nimmanager.nim_slots:
                                if slot.isCompatible("DVB-S"):

-                                       self.scan_satselection.append(getConfigSatlist(int(defaultSat["orbpos"]), self.satList[slot.slot]))
+                                       self.scan_satselection.append(getConfigSatlist(defaultSat["orbpos"], self.satList[slot.slot]))

                                else:
                                        self.scan_satselection.append(None)
 
                                else:
                                        self.scan_satselection.append(None)
 


@@ -578,34 +703,20 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
        def updateStatus(self):
                print "updatestatus"
 
        def updateStatus(self):
                print "updatestatus"
 

-       fecmap = { "auto": 0,
-                          "1_2": 1,
-                          "2_3": 2,
-                          "3_4": 3,
-                          "5_6": 4,
-                          "7_8": 5,
-                          "8_9": 6,
-                          "3_5": 7,
-                          "4_5": 8,
-                          "9_10": 9,
-                          "none": 15
-                          }
-
-       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation):
-               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(self.fecmap[fec]) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system)
+       def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot):
+               print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot)

                print "orbpos: " + str(orbital_position)
                parm = eDVBFrontendParametersSatellite()
                print "orbpos: " + str(orbital_position)
                parm = eDVBFrontendParametersSatellite()

-               if modulation == 1:
-                       parm.modulation = 2 # eDVBFrontendParametersSatellite.Modulation.8PSK
-               else:
-                       parm.modulation = 1 # eDVBFrontendParametersSatellite.Modulation.QPSK
+               parm.modulation = modulation

                parm.system = system
                parm.frequency = frequency * 1000
                parm.symbol_rate = symbol_rate * 1000
                parm.polarisation = polarisation
                parm.system = system
                parm.frequency = frequency * 1000
                parm.symbol_rate = symbol_rate * 1000
                parm.polarisation = polarisation

-               parm.fec = self.fecmap[fec]
+               parm.fec = fec

                parm.inversion = inversion
                parm.inversion = inversion

-               parm.orbital_position = int(orbital_position)
+               parm.orbital_position = orbital_position
+               parm.rolloff = rolloff
+               parm.pilot = pilot

                tlist.append(parm)
 
        def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):
                tlist.append(parm)
 
        def addCabTransponder(self, tlist, frequency, symbol_rate, modulation, fec, inversion):


@@ -614,7 +725,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                parm.frequency = frequency * 1000
                parm.symbol_rate = symbol_rate * 1000
                parm.modulation = modulation
                parm.frequency = frequency * 1000
                parm.symbol_rate = symbol_rate * 1000
                parm.modulation = modulation

-               parm.fec = self.fecmap[fec]
+               parm.fec = fec

                parm.inversion = inversion
                tlist.append(parm)
 
                parm.inversion = inversion
                tlist.append(parm)
 


@@ -622,11 +733,12 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                tlist.append(buildTerTransponder(*args, **kwargs))
 
        def keyGo(self):
                tlist.append(buildTerTransponder(*args, **kwargs))
 
        def keyGo(self):

+               if self.scan_nims.value == "":
+                       return

                tlist = []
                flags = None
                tlist = []
                flags = None

-               extFlags = True
-               

                startScan = True
                startScan = True

+               removeAll = True

                index_to_scan = int(self.scan_nims.value)
                
                if self.scan_nims == [ ]:
                index_to_scan = int(self.scan_nims.value)
                
                if self.scan_nims == [ ]:


@@ -648,25 +760,26 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                # however, the satList itself could be empty. in that case, "index" is 0 (for "None").
                                if len(nimsats):
                                        orbpos = nimsats[selsatidx][0]
                                # however, the satList itself could be empty. in that case, "index" is 0 (for "None").
                                if len(nimsats):
                                        orbpos = nimsats[selsatidx][0]

-                                       if self.scan_sat.system.value == "dvb-s":
+                                       if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S:

                                                fec = self.scan_sat.fec.value
                                        else:
                                                fec = self.scan_sat.fec_s2.value
                                        print "add sat transponder"
                                        self.addSatTransponder(tlist, self.scan_sat.frequency.value,
                                                                self.scan_sat.symbolrate.value,
                                                fec = self.scan_sat.fec.value
                                        else:
                                                fec = self.scan_sat.fec_s2.value
                                        print "add sat transponder"
                                        self.addSatTransponder(tlist, self.scan_sat.frequency.value,
                                                                self.scan_sat.symbolrate.value,

-                                                               self.scan_sat.polarization.index,
+                                                               self.scan_sat.polarization.value,

                                                                fec,
                                                                fec,

-                                                               self.scan_sat.inversion.index,
+                                                               self.scan_sat.inversion.value,

                                                                orbpos,
                                                                orbpos,

-                                                               self.scan_sat.system.index,
-                                                               self.scan_sat.modulation.index)
-                               flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0
-                               extFlags = False
+                                                               self.scan_sat.system.value,
+                                                               self.scan_sat.modulation.value,
+                                                               self.scan_sat.rolloff.value,
+                                                               self.scan_sat.pilot.value)
+                               removeAll = False

                        elif self.scan_type.value == "single_satellite":
                                sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
                                getInitialTransponderList(tlist, sat[0])
                        elif self.scan_type.value == "single_satellite":
                                sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index]
                                getInitialTransponderList(tlist, sat[0])

-                       elif self.scan_type.value == "multisat":
+                       elif self.scan_type.value.find("multisat") != -1:

                                SatList = nimmanager.getSatListForNim(index_to_scan)
                                for x in self.multiscanlist:
                                        if x[1].value:
                                SatList = nimmanager.getSatListForNim(index_to_scan)
                                for x in self.multiscanlist:
                                        if x[1].value:


@@ -675,14 +788,12 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
 
                elif nim.isCompatible("DVB-C"):
                        if self.scan_typecable.value == "single_transponder":
 
                elif nim.isCompatible("DVB-C"):
                        if self.scan_typecable.value == "single_transponder":

-                               fec = self.scan_cab.fec.value

                                self.addCabTransponder(tlist, self.scan_cab.frequency.value,
                                                                                          self.scan_cab.symbolrate.value,
                                self.addCabTransponder(tlist, self.scan_cab.frequency.value,
                                                                                          self.scan_cab.symbolrate.value,

-                                                                                         self.scan_cab.modulation.index + 1,
-                                                                                         fec,
-                                                                                         self.scan_cab.inversion.index)
-                               flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0
-                               extFlags = False
+                                                                                         self.scan_cab.modulation.value,
+                                                                                         self.scan_cab.fec.value,
+                                                                                         self.scan_cab.inversion.value)
+                               removeAll = False

                        elif self.scan_typecable.value == "complete":
                                if config.Nims[index_to_scan].cable.scan_type.value == "provider":
                                        getInitialCableTransponderList(tlist, index_to_scan)
                        elif self.scan_typecable.value == "complete":
                                if config.Nims[index_to_scan].cable.scan_type.value == "provider":
                                        getInitialCableTransponderList(tlist, index_to_scan)


@@ -693,29 +804,32 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                        if self.scan_typeterrestrial.value == "single_transponder":
                                self.addTerTransponder(tlist,
                                                self.scan_ter.frequency.value * 1000,
                        if self.scan_typeterrestrial.value == "single_transponder":
                                self.addTerTransponder(tlist,
                                                self.scan_ter.frequency.value * 1000,

-                                               inversion = self.scan_ter.inversion.index,
-                                               bandwidth = self.scan_ter.bandwidth.index,
-                                               fechigh = self.scan_ter.fechigh.index,
-                                               feclow = self.scan_ter.feclow.index,
-                                               modulation = self.scan_ter.modulation.index,
-                                               transmission = self.scan_ter.transmission.index,
-                                               guard = self.scan_ter.guard.index,
-                                               hierarchy = self.scan_ter.hierarchy.index)
-                               flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0
-                               extFlags = False
+                                               inversion = self.scan_ter.inversion.value,
+                                               bandwidth = self.scan_ter.bandwidth.value,
+                                               fechigh = self.scan_ter.fechigh.value,
+                                               feclow = self.scan_ter.feclow.value,
+                                               modulation = self.scan_ter.modulation.value,
+                                               transmission = self.scan_ter.transmission.value,
+                                               guard = self.scan_ter.guard.value,
+                                               hierarchy = self.scan_ter.hierarchy.value)
+                               removeAll = False

                        elif self.scan_typeterrestrial.value == "complete":
                                getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
 
                        elif self.scan_typeterrestrial.value == "complete":
                                getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan))
 

-               if flags is None:
-                       flags = eComponentScan.scanNetworkSearch
+               flags = self.scan_networkScan.value and eComponentScan.scanNetworkSearch or 0

 
 

-               if extFlags:
-                       tmp = self.scan_clearallservices.value
-                       if tmp == "yes":
-                               flags |= eComponentScan.scanRemoveServices
-                       elif tmp == "yes_hold_feeds":
-                               flags |= eComponentScan.scanRemoveServices
-                               flags |= eComponentScan.scanDontRemoveFeeds
+               tmp = self.scan_clearallservices.value
+               if tmp == "yes":
+                       flags |= eComponentScan.scanRemoveServices
+               elif tmp == "yes_hold_feeds":
+                       flags |= eComponentScan.scanRemoveServices
+                       flags |= eComponentScan.scanDontRemoveFeeds
+
+               if tmp != "no" and not removeAll:
+                       flags |= eComponentScan.scanDontRemoveUnscanned
+
+               if self.scan_onlyfree.value:
+                       flags |= eComponentScan.scanOnlyFree

 
                for x in self["config"].list:
                        x[1].save()
 
                for x in self["config"].list:
                        x[1].save()


@@ -756,18 +870,6 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
        def getNetworksForNim(self, nim):
                if nim.isCompatible("DVB-S"):
                        networks = nimmanager.getSatListForNim(nim.slot)
        def getNetworksForNim(self, nim):
                if nim.isCompatible("DVB-S"):
                        networks = nimmanager.getSatListForNim(nim.slot)

-# the original code took "loopthrough" etc. into account. Do we need this?
-#                      if nimmanager.getNimConfigMode(1) in ["loopthrough", "satposdepends", "equal", "nothing"]:
-#                              return False
-#                      sec = eDVBSatelliteEquipmentControl.getInstance()
-#                      if sec is not None:
-#                              exclusive_satellites = sec.get_exclusive_satellites(0,1)
-#                              if len(exclusive_satellites) == 2:
-#                                      return False
-#                              idx = exclusive_satellites[0]+1
-#                              exclusive_nim_sats = exclusive_satellites[idx+1:idx+1+exclusive_satellites[idx]]
-#                              if len(exclusive_nim_sats):
-#                                      return True

                elif not nim.empty:
                        networks = [ nim.type ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that.
                else:
                elif not nim.empty:
                        networks = [ nim.type ] # "DVB-C" or "DVB-T". TODO: seperate networks for different C/T tuners, if we want to support that.
                else:


@@ -807,6 +909,10 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                        need_scan = True
                                        print x, "not in ", known_networks
                                        known_networks.append(x)
                                        need_scan = True
                                        print x, "not in ", known_networks
                                        known_networks.append(x)

+                                       
+                       # don't offer to scan nims if nothing is connected
+                       if not nimmanager.somethingConnected(nim.slot):
+                               need_scan = False                               

 
                        if need_scan:
                                nims_to_scan.append(nim)
 
                        if need_scan:
                                nims_to_scan.append(nim)