Merge remote branch 'origin/pootle-import'

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

diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py
index 6bdedc8..f8bfeb7 100644 (file)
--- a/lib/python/Screens/ScanSetup.py
+++ b/lib/python/Screens/ScanSetup.py
@@ -1,11 +1,14 @@
 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

-from Components.ActionMap import NumberActionMap
+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]


@@ -149,6 +107,7 @@ class CableTransponderSearchSupport:
                        if raw_channel:
                                frontend = raw_channel.getFrontend()
                                if frontend:
                        if raw_channel:
                                frontend = raw_channel.getFrontend()
                                if frontend:

+                                       frontend.closeFrontend() # immediate close... 

                                        del frontend
                                        del raw_channel
                                        return True
                                        del frontend
                                        del raw_channel
                                        return True


@@ -156,10 +115,16 @@ class CableTransponderSearchSupport:
 
        def cableTransponderSearchSessionClosed(self, *val):
                print "cableTransponderSearchSessionClosed, val", val
 
        def cableTransponderSearchSessionClosed(self, *val):
                print "cableTransponderSearchSessionClosed, val", val

+               self.cable_search_container.appClosed.remove(self.cableTransponderSearchClosed)
+               self.cable_search_container.dataAvail.remove(self.getCableTransponderData)
+               if val and len(val):
+                       if val[0]:
+                               self.setCableTransponderSearchResult(self.__tlist)
+                       else:
+                               self.cable_search_container.sendCtrlC()
+                               self.setCableTransponderSearchResult(None)

                self.cable_search_container = None
                self.cable_search_session = None
                self.cable_search_container = None
                self.cable_search_session = None

-               if val and len(val) and val[0]:
-                       self.setCableTransponderSearchResult(self.__tlist)

                self.__tlist = None
                self.cableTransponderSearchFinished()
 
                self.__tlist = None
                self.cableTransponderSearchFinished()
 


@@ -172,22 +137,35 @@ 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.modulation = qam[data[4]]
                                parm.inversion = inv[data[5]]
                                self.__tlist.append(parm)
                                parm.frequency = int(data[1])
                                parm.symbol_rate = int(data[2])
                                parm.fec_inner = fec[data[3]]
                                parm.modulation = qam[data[4]]
                                parm.inversion = inv[data[5]]
                                self.__tlist.append(parm)

-               tmpstr = _("Try to find used Transponders in cable network.. please wait...")
-               tmpstr += "\n\n"
-               tmpstr += data[1]
-               tmpstr += " kHz "
-               tmpstr += data[0]
-               self.cable_search_session["text"].setText(tmpstr)
+                       tmpstr = _("Try to find used Transponders in cable network.. please wait...")
+                       tmpstr += "\n\n"
+                       tmpstr += data[1]
+                       tmpstr += " kHz "
+                       tmpstr += data[0]
+                       self.cable_search_session["text"].setText(tmpstr)

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


@@ -201,18 +179,20 @@ 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
                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)
+               tunername = nimmanager.getNimName(nim_idx)
+               bus = nimmanager.getI2CDevice(nim_idx)
+               if bus is None:
+                       print "ERROR: could not get I2C device for nim", nim_idx, "for cable transponder search"
+                       bus = 2
+
+               if tunername == "CXD1981":
+                       cmd = "cxd1978 --init --scan --verbose --wakeup --inv 2 --bus %d" % bus

                else:
                else:

-                       if nim_idx == 2:
-                               cmd += "2" # first nim socket on DM8000 use /dev/i2c/2
-                       else:
-                               cmd += "4" # second nim socket on DM8000 use /dev/i2c/4
+                       cmd = "tda1002x --init --scan --verbose --wakeup --inv 2 --bus %d" % bus
+               

                if cableConfig.scan_type.value == "bands":
                        cmd += " --scan-bands "
                        bands = 0
                if cableConfig.scan_type.value == "bands":
                        cmd += " --scan-bands "
                        bands = 0


@@ -273,6 +253,27 @@ class CableTransponderSearchSupport:
                tmpstr += "\n\n..."
                self.cable_search_session = self.session.openWithCallback(self.cableTransponderSearchSessionClosed, MessageBox, tmpstr, MessageBox.TYPE_INFO)
 
                tmpstr += "\n\n..."
                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)


@@ -298,14 +299,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                }, -2)
 
                self.statusTimer = eTimer()
                }, -2)
 
                self.statusTimer = eTimer()

-               self.statusTimer.timeout.get().append(self.updateStatus)
+               self.statusTimer.callback.append(self.updateStatus)

                #self.statusTimer.start(5000, True)
 
                self.list = []
                ConfigListScreen.__init__(self, self.list)
                #self.statusTimer.start(5000, True)
 
                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 +336,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 +348,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,76 +357,57 @@ 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(_('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":
+                               self.list.append(getConfigListEntry(_('Symbol rate'), self.scan_sat.symbolrate))
+                               self.list.append(getConfigListEntry(_('Polarization'), self.scan_sat.polarization))
+                               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(_('Roll-off'), 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))
                                self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion))
                elif nim.isCompatible("DVB-C"):
                        if self.scan_typecable.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_cab.frequency))
                                self.list.append(getConfigListEntry(_("Inversion"), self.scan_cab.inversion))

-                               self.list.append(getConfigListEntry(_("Symbol Rate"), self.scan_cab.symbolrate))
+                               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(_("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))
                                self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
                                self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))
                elif nim.isCompatible("DVB-T"):
                        if self.scan_typeterrestrial.value == "single_transponder":
                                self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
                                self.list.append(getConfigListEntry(_("Inversion"), self.scan_ter.inversion))
                                self.list.append(getConfigListEntry(_("Bandwidth"), self.scan_ter.bandwidth))

-                               self.list.append(getConfigListEntry(_("Code rate high"), self.scan_ter.fechigh))
-                               self.list.append(getConfigListEntry(_("Code rate low"), self.scan_ter.feclow))
+                               self.list.append(getConfigListEntry(_("Code rate HP"), self.scan_ter.fechigh))
+                               self.list.append(getConfigListEntry(_("Code rate LP"), self.scan_ter.feclow))

                                self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
                                self.list.append(getConfigListEntry(_("Transmission mode"), self.scan_ter.transmission))
                                self.list.append(getConfigListEntry(_("Modulation"), self.scan_ter.modulation))
                                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(_("Guard interval"), self.scan_ter.guard))
+                               self.list.append(getConfigListEntry(_("Hierarchy info"), self.scan_ter.hierarchy))
+               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 +422,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 +457,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 +552,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 +675,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 +692,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 +714,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 +722,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 +749,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 +777,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 +793,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
+
+               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 extFlags:
-                       tmp = self.scan_clearallservices.value
-                       if tmp == "yes":
-                               flags |= eComponentScan.scanRemoveServices
-                       elif tmp == "yes_hold_feeds":
-                               flags |= eComponentScan.scanRemoveServices
-                               flags |= eComponentScan.scanDontRemoveFeeds
+               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()


@@ -732,7 +835,10 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport):
                self.tlist = tlist
 
        def cableTransponderSearchFinished(self):
                self.tlist = tlist
 
        def cableTransponderSearchFinished(self):

-               self.startScan(self.tlist, self.flags, self.feid)
+               if self.tlist is None:
+                       self.tlist = []
+               else:
+                       self.startScan(self.tlist, self.flags, self.feid)

 
        def startScan(self, tlist, flags, feid):
                if len(tlist):
 
        def startScan(self, tlist, flags, feid):
                if len(tlist):


@@ -756,18 +862,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 +901,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)


@@ -906,7 +1004,8 @@ class ScanSimple(ConfigListScreen, Screen, CableTransponderSearchSupport):
                                self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
 
        def setCableTransponderSearchResult(self, tlist):
                                self.session.open(MessageBox, _("Nothing to scan!\nPlease setup your tuner settings before you start a service scan."), MessageBox.TYPE_ERROR)
 
        def setCableTransponderSearchResult(self, tlist):

-               self.scanList.append({"transponders": tlist, "feid": self.feid, "flags": self.flags})
+               if tlist is not None:
+                       self.scanList.append({"transponders": tlist, "feid": self.feid, "flags": self.flags})

 
        def cableTransponderSearchFinished(self):
                self.buildTransponderList()
 
        def cableTransponderSearchFinished(self):
                self.buildTransponderList()