config rewrite. some extensions still need to be updated.

22 files changed, 502 insertions, 647 deletions

diff --git a/lib/python/Screens/ChannelSelection.py b/lib/python/Screens/ChannelSelection.py
index a8d605ea..6c3abb5d 100644
--- a/lib/python/Screens/ChannelSelection.py
+++ b/lib/python/Screens/ChannelSelection.py
@@ -5,7 +5,7 @@ from Components.ActionMap import NumberActionMap, ActionMap
 from Components.MenuList import MenuList
 from EpgSelection import EPGSelection
 from enigma import eServiceReference, eEPGCache, eServiceCenter, eServiceCenterPtr, iMutableServiceListPtr, iStaticServiceInformationPtr, eTimer, eDVBDB
-from Components.config import config, configElement, ConfigSubsection, configText, currentConfigSelectionElement
+from Components.config import config, ConfigSubsection, ConfigText
 from Screens.FixedMenu import FixedMenu
 from Tools.NumericalTextInput import NumericalTextInput
 from Components.NimManager import nimmanager
@@ -87,7 +87,7 @@ class ChannelContextMenu(Screen):
 						menu.append((_("remove all new found flags"), self.removeAllNewFoundFlags))
 				if inBouquet:
 					menu.append((_("remove entry"), self.removeCurrentService))
-				if current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
+				if current_root is not None and current_root.getPath().find("flags == %d" %(FLAG_SERVICE_NEW_FOUND)) != -1:
 					menu.append((_("remove new found flag"), self.removeNewFoundFlag))
 			else:
 					menu.append((_("add bouquet"), self.showBouquetInputBox))
@@ -513,6 +513,7 @@ class ChannelSelectionBase(Screen):
 				"9": self.keyNumberGlobal,
 				"0": self.keyNumber0
 			})
+		self.recallBouquetMode()
 
 	def appendDVBTypes(self, ref):
 		path = ref.getPath()
@@ -553,13 +554,13 @@ class ChannelSelectionBase(Screen):
 	def recallBouquetMode(self):
 		if self.mode == MODE_TV:
 			self.service_types = self.service_types_tv
-			if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
+			if config.usage.multibouquet.value:
 				self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.tv" ORDER BY bouquet'
 			else:
 				self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.tv" ORDER BY bouquet'%(self.service_types)
 		else:
 			self.service_types = self.service_types_radio
-			if currentConfigSelectionElement(config.usage.multibouquet) == "yes":
+			if config.usage.multibouquet.value:
 				self.bouquet_rootstr = '1:7:1:0:0:0:0:0:0:0:(type == 1) FROM BOUQUET "bouquets.radio" ORDER BY bouquet'
 			else:
 				self.bouquet_rootstr = '%s FROM BOUQUET "userbouquet.favourites.radio" ORDER BY bouquet'%(self.service_types)
@@ -876,13 +877,13 @@ HISTORYSIZE = 20
 
 #config for lastservice
 config.tv = ConfigSubsection()
-config.tv.lastservice = configElement("config.tv.lastservice", configText, "", 0)
-config.tv.lastroot = configElement("config.tv.lastroot", configText, "", 0)
+config.tv.lastservice = ConfigText()
+config.tv.lastroot = ConfigText()
 config.radio = ConfigSubsection()
-config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0)
-config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0)
+config.radio.lastservice = ConfigText()
+config.radio.lastroot = ConfigText()
 config.servicelist = ConfigSubsection()
-config.servicelist.lastmode = configElement("config.servicelist.lastmode", configText, "tv", 0)
+config.servicelist.lastmode = ConfigText(default = "tv")
 
 class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelectionEPG):
 	def __init__(self, session):
@@ -932,7 +933,7 @@ class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelect
 	def setModeRadio(self):
 		if self.revertMode is None and config.servicelist.lastmode.value == "tv":
 			self.revertMode = MODE_TV
-		if currentConfigSelectionElement(config.usage.e1like_radio_mode) == "yes":
+		if config.usage.e1like_radio_mode.value == "yes":
 			self.history = self.history_radio
 			self.lastservice = config.radio.lastservice
 			self.lastroot = config.radio.lastroot
@@ -941,7 +942,7 @@ class ChannelSelection(ChannelSelectionBase, ChannelSelectionEdit, ChannelSelect
 			self.setMode()
 
 	def __onCreate(self):
-		if currentConfigSelectionElement(config.usage.e1like_radio_mode) == "yes":
+		if config.usage.e1like_radio_mode.value == "yes":
 			if config.servicelist.lastmode.value == "tv":
 				self.setModeTv()
 			else:
@@ -1130,8 +1131,8 @@ class ChannelSelectionRadio(ChannelSelectionBase, ChannelSelectionEdit, ChannelS
 		ChannelSelectionEPG.__init__(self)
 
 		config.radio = ConfigSubsection();
-		config.radio.lastservice = configElement("config.radio.lastservice", configText, "", 0);
-		config.radio.lastroot = configElement("config.radio.lastroot", configText, "", 0);
+		config.radio.lastservice = ConfigText()
+		config.radio.lastroot = ConfigText()
 		self.onLayoutFinish.append(self.onCreate)
 
 		self.info = session.instantiateDialog(RadioInfoBar)
diff --git a/lib/python/Screens/Ci.py b/lib/python/Screens/Ci.py
index b516ec70..f43ce0e0 100644
--- a/lib/python/Screens/Ci.py
+++ b/lib/python/Screens/Ci.py
@@ -8,7 +8,7 @@ from Components.Label import Label
 
 from Components.HTMLComponent import *
 from Components.GUIComponent import *
-from Components.config import *
+from Components.config import config, ConfigSubsection, ConfigSelection, ConfigSubList, getConfigListEntry, KEY_LEFT, KEY_RIGHT, KEY_0
 from Components.ConfigList import ConfigList
 
 from enigma import eTimer, eDVBCI_UI, eListboxPythonStringContent, eListboxPythonConfigContent
@@ -18,10 +18,10 @@ TYPE_CONFIG = 1
 MAX_NUM_CI = 4
 
 def InitCiConfig():
-	config.ci = [ ]
+	config.ci = ConfigSubList()
 	for slot in range(MAX_NUM_CI):
 		config.ci.append(ConfigSubsection())
-		config.ci[slot].canDescrambleMultipleServices = configElement("config.ci%d.canDescrambleMultipleServices"%(slot), configSelection, 0, (("auto", _("Auto")), ("no", _("No")), ("yes", _("Yes"))))
+		config.ci[slot].canDescrambleMultipleServices = ConfigSelection(choices = [("auto", _("Auto")), ("no", _("No")), ("yes", _("Yes"))], default = "auto")
 
 class CiMmi(Screen):
 	def __init__(self, session, slotid, action):
@@ -76,12 +76,12 @@ class CiMmi(Screen):
 			self.pinlength = entry[1]
 			if entry[3] == 1:
 				# masked pins:
-				x = configElement_nonSave("", configSequence, [1234], configsequencearg.get("PINCODE", (self.pinlength, "*")))
-			else:				
+				x = ConfigPIN(len = self.pinlength, censor = "*")
+			else:
 				# unmasked pins:
-				x = configElement_nonSave("", configSequence, [1234], configsequencearg.get("PINCODE", (self.pinlength, "")))
+				x = ConfigPIN(len = self.pinlength)
 			self["subtitle"].setText(entry[2])
-			self.pin = getConfigListEntry("",x)
+			self.pin = getConfigListEntry("", x)
 			list.append( self.pin )
 			self["bottom"].setText(_("please press OK when ready"))
 
@@ -143,15 +143,15 @@ class CiMmi(Screen):
 
 	def keyNumberGlobal(self, number):
 		self.timer.stop()
-		self.keyConfigEntry(config.key[str(number)])
+		self.keyConfigEntry(KEY_0 + number)
 
 	def keyLeft(self):
 		self.timer.stop()
-		self.keyConfigEntry(config.key["prevElement"])
+		self.keyConfigEntry(KEY_LEFT)
 
 	def keyRight(self):
 		self.timer.stop()
-		self.keyConfigEntry(config.key["nextElement"])
+		self.keyConfigEntry(KEY_RIGHT)
 
 	def updateList(self, list):
 		List = self["entries"]
@@ -302,10 +302,10 @@ class CiSelection(Screen):
 			pass
 
 	def keyLeft(self):
-		self.keyConfigEntry(config.key["prevElement"])
+		self.keyConfigEntry(KEY_LEFT)
 
 	def keyRight(self):
-		self.keyConfigEntry(config.key["nextElement"])
+		self.keyConfigEntry(KEY_RIGHT)
 
 	def appendEntries(self, slot, state):
 		self.state[slot] = state
diff --git a/lib/python/Screens/ConfigMenu.py b/lib/python/Screens/ConfigMenu.py
index 57bdda55..3bd0ac69 100644
--- a/lib/python/Screens/ConfigMenu.py
+++ b/lib/python/Screens/ConfigMenu.py
@@ -1,6 +1,6 @@
 from Screen import Screen
 from Components.ConfigList import ConfigList
-from Components.config import *
+from Components.config import config
 from Components.ActionMap import ActionMap
 
 class ConfigMenu(Screen):
diff --git a/lib/python/Screens/Dish.py b/lib/python/Screens/Dish.py
index c8e9b6c7..bcc35807 100644
--- a/lib/python/Screens/Dish.py
+++ b/lib/python/Screens/Dish.py
@@ -3,7 +3,7 @@ from Screen import Screen
 from Components.BlinkingPixmap import BlinkingPixmapConditional
 from Components.Pixmap import Pixmap
 from Components.Button import Button
-from Components.config import config, currentConfigSelectionElement
+from Components.config import config
 
 from enigma import *
 
@@ -14,7 +14,7 @@ class Dish(Screen):
 		self["transparent"] = Button("")
 		self["Dishpixmap"] = BlinkingPixmapConditional()
 		#self["Dishpixmap"] = Pixmap()
-		if currentConfigSelectionElement(config.usage.showdish) == "no":
+		if not config.usage.showdish.value:
 			self["Dishpixmap"].setConnect(lambda: False)
 		else:
 			self["Dishpixmap"].setConnect(eDVBSatelliteEquipmentControl.getInstance().isRotorMoving)
diff --git a/lib/python/Screens/EpgSelection.py b/lib/python/Screens/EpgSelection.py
index ba49f314..5d29df0d 100644
--- a/lib/python/Screens/EpgSelection.py
+++ b/lib/python/Screens/EpgSelection.py
@@ -13,7 +13,6 @@ from RecordTimer import RecordTimerEntry, parseEvent
 from TimerEdit import TimerEditList
 from TimerEntry import TimerEntry
 from ServiceReference import ServiceReference
-from Components.config import config, currentConfigSelectionElement
 from time import localtime, time
 
 import xml.dom.minidom
diff --git a/lib/python/Screens/ImageWizard.py b/lib/python/Screens/ImageWizard.py
index 5617e8f1..461fa318 100644
--- a/lib/python/Screens/ImageWizard.py
+++ b/lib/python/Screens/ImageWizard.py
@@ -1,6 +1,5 @@
 from Wizard import Wizard, wizardManager
 
-from Components.config import configElementBoolean, config
 from Components.Pixmap import *
 
 from LanguageSelection import LanguageSelection
diff --git a/lib/python/Screens/InfoBar.py b/lib/python/Screens/InfoBar.py
index 4a1f318a..41083777 100644
--- a/lib/python/Screens/InfoBar.py
+++ b/lib/python/Screens/InfoBar.py
@@ -8,7 +8,7 @@ from ServiceReference import ServiceReference
 
 from Components.Sources.Clock import Clock
 from Components.ActionMap import ActionMap, HelpableActionMap
-from Components.config import currentConfigSelectionElement, config
+from Components.config import config
 
 from Tools.Notifications import AddNotificationWithCallback
 
@@ -69,7 +69,7 @@ class InfoBar(InfoBarShowHide,
 		self.showTvChannelList(True)
 
 	def showRadio(self):
-		if currentConfigSelectionElement(config.usage.e1like_radio_mode) == "yes":
+		if config.usage.e1like_radio_mode.value:
 			self.showRadioChannelList(True)
 		else:
 			self.session.open(ChannelSelectionRadio)
diff --git a/lib/python/Screens/InfoBarGenerics.py b/lib/python/Screens/InfoBarGenerics.py
index c5018c2f..49d82477 100644
--- a/lib/python/Screens/InfoBarGenerics.py
+++ b/lib/python/Screens/InfoBarGenerics.py
@@ -16,8 +16,7 @@ from Components.Sources.FrontendStatus import FrontendStatus
 from Components.Sources.Boolean import Boolean
 from Components.Sources.Clock import Clock
 from Components.TimerList import TimerEntryComponent
-from Components.config import config, configElement, ConfigSubsection, configSequence, configElementBoolean, configSelection, configElement_nonSave, getConfigListEntry
-from Components.config import configfile, configsequencearg
+from Components.config import config, ConfigBoolean
 
 from EpgSelection import EPGSelection
 from Plugins.Plugin import PluginDescriptor
@@ -44,8 +43,6 @@ import time
 import os
 import bisect
 
-from Components.config import config, currentConfigSelectionElement
-
 # hack alert!
 from Menu import MainMenu, mdom
 
@@ -240,7 +237,7 @@ class InfoBarNumberZap:
 			self.servicelist.setCurrentSelection(service) #select the service in servicelist
 			self.servicelist.zap()
 
-config.misc.initialchannelselection = configElementBoolean("config.misc.initialchannelselection", 1);
+config.misc.initialchannelselection = ConfigBoolean(default = True)
 
 class InfoBarChannelSelection:
 	""" ChannelSelection - handles the channelSelection dialog and the initial 
@@ -249,7 +246,8 @@ class InfoBarChannelSelection:
 		#instantiate forever
 		self.servicelist = self.session.instantiateDialog(ChannelSelection)
 		
-		if config.misc.initialchannelselection.value == 1:
+		print "__init__: servicelist is", self.servicelist
+		if config.misc.initialchannelselection.value:
 			self.onShown.append(self.firstRun)
 
 		self["ChannelSelectActions"] = HelpableActionMap(self, "InfobarChannelSelection",
@@ -277,8 +275,9 @@ class InfoBarChannelSelection:
 
 	def firstRun(self):
 		self.onShown.remove(self.firstRun)
-		config.misc.initialchannelselection.value = 0
+		config.misc.initialchannelselection.value = False
 		config.misc.initialchannelselection.save()
+		print "servicelist is", self.servicelist
 		self.switchChannelDown()
 
 	def historyBack(self):
@@ -304,7 +303,7 @@ class InfoBarChannelSelection:
 			if prev:
 				prev = prev.toString()
 				while True:
-					if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes":
+					if config.usage.quickzap_bouquet_change.value:
 						if self.servicelist.atBegin():
 							self.servicelist.prevBouquet()
 					self.servicelist.moveUp()
@@ -322,7 +321,7 @@ class InfoBarChannelSelection:
 			if prev:
 				prev = prev.toString()
 				while True:
-					if currentConfigSelectionElement(config.usage.quickzap_bouquet_change) == "yes" and self.servicelist.atEnd():
+					if config.usage.quickzap_bouquet_change.value and self.servicelist.atEnd():
 						self.servicelist.nextBouquet()
 					else:
 						self.servicelist.moveDown()
@@ -827,6 +826,11 @@ class InfoBarSeek:
 		if seekable is not None:
 			seekable.seekRelative(1, diff)
 
+	def seekAbsolute(self, abs):
+		seekable = self.getSeek()
+		if seekable is not None:
+			seekable.seekTo(abs)
+
 from Screens.PVRState import PVRState, TimeshiftState
 
 class InfoBarPVRState:
@@ -1710,10 +1714,10 @@ class InfoBarCueSheetSupport:
 class InfoBarSummary(Screen):
 	skin = """
 	<screen position="0,0" size="132,64">
-		<widget source="CurrentTime" render="Label" position="50,46" size="82,18" font="Regular;16" >
+		<widget source="CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
 			<convert type="ClockToText">WithSeconds</convert>
 		</widget>
-		<widget source="CurrentService" render="Label" position="0,4" size="132,42" font="Regular;18" >
+		<widget source="CurrentService" render="Label" position="6,4" size="120,42" font="Regular;18" >
 			<convert type="ServiceName">Name</convert>
 		</widget>
 	</screen>"""
diff --git a/lib/python/Screens/Makefile.am b/lib/python/Screens/Makefile.am
index 2e998db7..0d253d5e 100644
--- a/lib/python/Screens/Makefile.am
+++ b/lib/python/Screens/Makefile.am
@@ -11,5 +11,4 @@ install_PYTHON = \
 	TutorialWizard.py PluginBrowser.py MinuteInput.py Scart.py PVRState.py \
 	Console.py InputBox.py ChoiceBox.py SimpleSummary.py ImageWizard.py \
 	MediaPlayer.py TimerSelection.py PictureInPicture.py TimeDateInput.py \
-	SubtitleDisplay.py SubservicesQuickzap.py
-
+	SubtitleDisplay.py SubservicesQuickzap.py NumericalTextInputHelpDialog.py
diff --git a/lib/python/Screens/Menu.py b/lib/python/Screens/Menu.py
index 1390b51a..6ef4cc4e 100644
--- a/lib/python/Screens/Menu.py
+++ b/lib/python/Screens/Menu.py
@@ -62,9 +62,9 @@ menuupdater = MenuUpdater()
 class MenuSummary(Screen):
 	skin = """
 	<screen position="0,0" size="132,64">
-		<widget name="MenuTitle" position="0,4" size="132,21" font="Regular;18" />
-		<widget name="MenuEntry" position="0,25" size="132,21" font="Regular;16" />
-		<widget source="CurrentTime" render="Label" position="50,46" size="82,18" font="Regular;16" >
+		<widget name="MenuTitle" position="6,4" size="120,21" font="Regular;18" />
+		<widget name="MenuEntry" position="6,25" size="120,21" font="Regular;16" />
+		<widget source="CurrentTime" render="Label" position="56,46" size="82,18" font="Regular;16" >
 			<convert type="ClockToText">WithSeconds</convert>
 		</widget>
 	</screen>"""
diff --git a/lib/python/Screens/NetworkSetup.py b/lib/python/Screens/NetworkSetup.py
index 03179758..3bdfe163 100644
--- a/lib/python/Screens/NetworkSetup.py
+++ b/lib/python/Screens/NetworkSetup.py
@@ -1,12 +1,11 @@
 from Screen import Screen
 from Components.ActionMap import NumberActionMap
-from Components.ConfigList import ConfigList
-from Components.config import config
-from Components.config import getConfigListEntry
+from Components.ConfigList import ConfigList, ConfigListScreen
+from Components.config import config, getConfigListEntry
 from Components.Network import iNetwork
 from Components.Label import Label
 
-class NetworkSetup(Screen):
+class NetworkSetup(Screen, ConfigListScreen):
 	def __init__(self, session):
 		Screen.__init__(self, session)
         
@@ -14,62 +13,45 @@ class NetworkSetup(Screen):
 		{
 			"ok": self.keySave,
 			"cancel": self.keyCancel,
-			"left": self.keyLeft,
-			"right": self.keyRight,
-			"1": self.keyNumberGlobal,
-			"2": self.keyNumberGlobal,
-			"3": self.keyNumberGlobal,
-			"4": self.keyNumberGlobal,
-			"5": self.keyNumberGlobal,
-			"6": self.keyNumberGlobal,
-			"7": self.keyNumberGlobal,
-			"8": self.keyNumberGlobal,
-			"9": self.keyNumberGlobal,
-			"0": self.keyNumberGlobal
 		}, -1)
 
 		self.list = []
-		self["config"] = ConfigList(self.list)
+		ConfigListScreen.__init__(self, self.list)
 		self.createSetup()
-        
+
 		self["introduction"] = Label(_("Press OK to activate the settings."))
-        
+
 	def createSetup(self):
 		self.list = []
-        
+
 		self.dhcpEntry = getConfigListEntry(_("Use DHCP"), config.network.dhcp)
 		self.list.append(self.dhcpEntry)
 		self.list.append(getConfigListEntry(_('IP Address'), config.network.ip))
-		if (config.network.dhcp.value == 0):
+		if not config.network.dhcp.value:
 			self.list.append(getConfigListEntry(_('Netmask'), config.network.netmask))
 			self.list.append(getConfigListEntry(_('Gateway'), config.network.gateway))
 			self.list.append(getConfigListEntry(_('Nameserver'), config.network.dns))
-        
+
 		self["config"].list = self.list
 		self["config"].l.setList(self.list)
-        
+
 	def newConfig(self):
 		print self["config"].getCurrent()
 		if self["config"].getCurrent() == self.dhcpEntry:
 			self.createSetup()
 
 	def keyLeft(self):
-		self["config"].handleKey(config.key["prevElement"])
-		self.newConfig()
+		ConfigListScreen.keyLeft(self)
+		self.createSetup()
 
 	def keyRight(self):
-		self["config"].handleKey(config.key["nextElement"])
-		self.newConfig()
-    
-	def keyNumberGlobal(self, number):
-		print "You pressed number " + str(number)
-		if (self["config"].getCurrent()[1].parent.enabled == True):
-			self["config"].handleKey(config.key[str(number)])
-        
+		ConfigListScreen.keyRight(self)
+		self.createSetup()
+
 	def keySave(self):
 		#for x in self["config"].list:
 			#x[1].save()
-        
+
 		iNetwork.writeNetworkConfig()    
 		iNetwork.activateNetworkConfig()
 		self.close()
diff --git a/lib/python/Screens/PictureInPicture.py b/lib/python/Screens/PictureInPicture.py
index fdb04185..ce959209 100644
--- a/lib/python/Screens/PictureInPicture.py
+++ b/lib/python/Screens/PictureInPicture.py
@@ -1,14 +1,14 @@
 from Screens.Screen import Screen
 from enigma import ePoint, eSize, eServiceCenter
 from Components.VideoWindow import VideoWindow
-from Components.config import config, configElement, configSequence, configsequencearg
+from Components.config import config, ConfigPosition
 
 class PictureInPicture(Screen):
 	def __init__(self, session):
 		Screen.__init__(self, session)
 		self["video"] = VideoWindow()
 		self.currentService = None
-		config.av.pip = configElement("config.av.pip", configSequence, [-1, -1, -1, -1], configsequencearg.get("POSITION", (719, 567, 720, 568)))
+		config.av.pip = ConfigPosition(default=[-1, -1, -1, -1], limits = (719, 567, 720, 568))
 		self.onLayoutFinish.append(self.LayoutFinished)
 
 	def LayoutFinished(self):
diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py
index 0a76e491..9e692e63 100644
--- a/lib/python/Screens/Satconfig.py
+++ b/lib/python/Screens/Satconfig.py
@@ -1,33 +1,31 @@
 from Screen import Screen
-from Components.ActionMap import NumberActionMap
 from Components.ActionMap import ActionMap
-from Components.ConfigList import ConfigList
-from Components.config import *
+from Components.ConfigList import ConfigList, ConfigListScreen
 from Components.MenuList import MenuList
 from Components.NimManager import nimmanager
-from Components.config import getConfigListEntry
+from Components.config import getConfigListEntry, config, ConfigDummy
 
-class NimSetup(Screen):
+class NimSetup(Screen, ConfigListScreen):
 	def createSimpleSetup(self, list, mode):
-		if mode == 0:			#single Sat
+		if mode == "single":
 			list.append(getConfigListEntry(_("Satellite"), self.nimConfig.diseqcA))
-		else:							# > 1 Sats
+		else:
 			list.append(getConfigListEntry(_("Port A"), self.nimConfig.diseqcA))
 
-		if mode >= 1:			# > 1 Sats
+		if mode in ["toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
 			list.append(getConfigListEntry(_("Port B"), self.nimConfig.diseqcB))
-			if mode >= 3:		# > 2 Sats
+			if mode == "diseqc_a_b_c_d":
 				list.append(getConfigListEntry(_("Port C"), self.nimConfig.diseqcC))
 				list.append(getConfigListEntry(_("Port D"), self.nimConfig.diseqcD))
 
 	def createPositionerSetup(self, list):
 #		list.append(getConfigListEntry(_("Positioner mode"), self.nimConfig.positionerMode))
-#		if (currentConfigSelectionElement(self.nimConfig.positionerMode) == "usals"): # USALS
+#		if self.nimConfig.positionerMode.value == "usals": # USALS
 		list.append(getConfigListEntry(_("Longitude"), self.nimConfig.longitude))
 		list.append(getConfigListEntry(" ", self.nimConfig.longitudeOrientation))
 		list.append(getConfigListEntry(_("Latitude"), self.nimConfig.latitude))
 		list.append(getConfigListEntry(" ", self.nimConfig.latitudeOrientation))
-#		elif (currentConfigSelectionElement(self.nimConfig.positionerMode) == "manual"): # manual
+#		elif self.nimConfig.positionerMode.value == "manual": # manual
 #			pass
 
 	def createSetup(self):
@@ -48,21 +46,22 @@ class NimSetup(Screen):
 		if self.nim_type == nimmanager.nimType["DVB-S"]:
 			self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode)
 			self.list.append(self.configMode)
-
-			if currentConfigSelectionElement(self.nimConfig.configMode) == "simple":			#simple setup
+			
+			if self.nimConfig.configMode.value == "simple":			#simple setup
 				self.diseqcModeEntry = getConfigListEntry(_("DiSEqC Mode"), self.nimConfig.diseqcMode)
 				self.list.append(self.diseqcModeEntry)
-				if (0 <= self.nimConfig.diseqcMode.value < 4):
+				if self.nimConfig.diseqcMode.value in ["single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"]:
 					self.createSimpleSetup(self.list, self.nimConfig.diseqcMode.value)
-				if (self.nimConfig.diseqcMode.value == 4):
+				if self.nimConfig.diseqcMode.value == "positioner":
 					self.createPositionerSetup(self.list)
-			elif currentConfigSelectionElement(self.nimConfig.configMode) in ["loopthrough", "satposdepends", "nothing", "equal"]:
+			elif self.nimConfig.configMode.value in ["loopthrough", "satposdepends", "nothing", "equal"]:
 				pass
-			elif currentConfigSelectionElement(self.nimConfig.configMode) == "advanced": # advanced
+			elif self.nimConfig.configMode.value == "advanced": # advanced
 				# SATs
 				self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats)
 				self.list.append(self.advancedSatsEntry)
-				currSat = self.nimConfig.advanced.sat[nimmanager.satList[self.nimConfig.advanced.sats.value][1]]
+				print "blub", self.nimConfig.advanced.sat
+				currSat = self.nimConfig.advanced.sat[self.nimConfig.advanced.sats.orbital_position]
 				self.fillListWithAdvancedSatEntrys(currSat)
 			self.have_advanced = True
 		elif self.nim_type == nimmanager.nimType["DVB-C"]:
@@ -84,66 +83,56 @@ class NimSetup(Screen):
 			if self["config"].getCurrent() == x:
 				self.createSetup()
 
-	def keyLeft(self):
-		self["config"].handleKey(config.key["prevElement"])
-		self.newConfig()
-
-	def keyRight(self):
-		self["config"].handleKey(config.key["nextElement"])
-		self.newConfig()
-
-	def keyNumberGlobal(self, number):
-		print "You pressed number " + str(number)
-		if (self["config"].getCurrent()[1].parent.enabled == True):
-			self["config"].handleKey(config.key[str(number)])
-
 	def run(self):
-		if self.have_advanced and currentConfigSelectionElement(config.Nims[self.nim.slotid].configMode) == "advanced":
+		if self.have_advanced and config.Nims[self.nim.slotid].configMode.value == "advanced":
 			self.fillAdvancedList()
 		for x in self["config"].list:
 			x[1].save()
 		nimmanager.sec.update()
 
 	def fillListWithAdvancedSatEntrys(self, Sat):
-		currLnb = self.nimConfig.advanced.lnb[Sat.lnb.value]
+		currLnb = self.nimConfig.advanced.lnb[int(Sat.lnb.value)]
+		
+		if isinstance(currLnb, ConfigDummy):
+			currLnb = None
 
 		self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage))
 		self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode))
-		if (currLnb != 0 and currentConfigSelectionElement(currLnb.diseqcMode) == "1_2"):
+		if currLnb and currLnb.diseqcMode.value == "1_2":
 			self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals)
 			self.list.append(self.advancedUsalsEntry)
-			if (currentConfigSelectionElement(Sat.usals) == "no"):
+			if not Sat.usals.value:
 				self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition))
 
 		# LNBs
 		self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb)
 		self.list.append(self.advancedLnbsEntry)
-		if currLnb != 0:
+		if currLnb:
 			self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode)
 			self.list.append(self.advancedDiseqcMode)
-			if currentConfigSelectionElement(currLnb.diseqcMode) != "none":
+			if currLnb.diseqcMode.value != "none":
 				self.list.append(getConfigListEntry(_("Toneburst"), currLnb.toneburst))
 				self.list.append(getConfigListEntry(_("Committed DiSEqC command"), currLnb.commitedDiseqcCommand))
 				self.list.append(getConfigListEntry(_("Fast DiSEqC"), currLnb.fastDiseqc))
 				self.list.append(getConfigListEntry(_("Sequence repeat"), currLnb.sequenceRepeat))
-				if currentConfigSelectionElement(currLnb.diseqcMode) == "1_0":
+				if currLnb.diseqcMode.value == "1_0":
 					self.list.append(getConfigListEntry(_("Command order"), currLnb.commandOrder1_0))
 				else:
 					self.list.append(getConfigListEntry(_("Command order"), currLnb.commandOrder))
 					self.list.append(getConfigListEntry(_("Uncommitted DiSEqC command"), currLnb.uncommittedDiseqcCommand))
 					self.list.append(getConfigListEntry(_("DiSEqC repeats"), currLnb.diseqcRepeats))
-				if currentConfigSelectionElement(currLnb.diseqcMode) == "1_2":
+				if currLnb.diseqcMode.value == "1_2":
 					self.list.append(getConfigListEntry(_("Longitude"), currLnb.longitude))
 					self.list.append(getConfigListEntry(" ", currLnb.longitudeOrientation))
 					self.list.append(getConfigListEntry(_("Latitude"), currLnb.latitude))
 					self.list.append(getConfigListEntry(" ", currLnb.latitudeOrientation))
 					self.advancedPowerMeasurement = getConfigListEntry("Use Power Measurement", currLnb.powerMeasurement)
 					self.list.append(self.advancedPowerMeasurement)
-					if currentConfigSelectionElement(currLnb.powerMeasurement) == "yes":
+					if currLnb.powerMeasurement.value == "yes":
 						self.list.append(getConfigListEntry("Power Threshold in mA", currLnb.powerThreshold))
 			self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof)
 			self.list.append(self.advancedLof)
-			if currentConfigSelectionElement(currLnb.lof) == "user_defined":
+			if currLnb.lof.value == "user_defined":
 				self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl))
 				self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh))
 				self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold))
@@ -157,7 +146,7 @@ class NimSetup(Screen):
 		self.advancedSatsEntry = getConfigListEntry(_("Satellite"), self.nimConfig.advanced.sats)
 		self.list.append(self.advancedSatsEntry)
 		for x in nimmanager.satList:
-			Sat = self.nimConfig.advanced.sat[x[1]]
+			Sat = self.nimConfig.advanced.sat[x[0]]
 			self.fillListWithAdvancedSatEntrys(Sat)
 		self["config"].list = self.list
 
@@ -172,31 +161,28 @@ class NimSetup(Screen):
 
 	def __init__(self, session, slotid):
 		Screen.__init__(self, session)
+		self.list = [ ]
+
+		ConfigListScreen.__init__(self, self.list)
 
-		self["actions"] = NumberActionMap(["SetupActions"],
+		self["actions"] = ActionMap(["SetupActions"],
 		{
 			"ok": self.keySave,
 			"cancel": self.keyCancel,
-			"left": self.keyLeft,
-			"right": self.keyRight,
-			"1": self.keyNumberGlobal,
-			"2": self.keyNumberGlobal,
-			"3": self.keyNumberGlobal,
-			"4": self.keyNumberGlobal,
-			"5": self.keyNumberGlobal,
-			"6": self.keyNumberGlobal,
-			"7": self.keyNumberGlobal,
-			"8": self.keyNumberGlobal,
-			"9": self.keyNumberGlobal,
-			"0": self.keyNumberGlobal
 		}, -1)
 
 		self.nim = nimmanager.nimList()[slotid][1]
 		self.nimConfig = config.Nims[self.nim.slotid]
-		self.list = [ ]
-		self["config"] = ConfigList(self.list)
 		self.createSetup()
 
+	def keyLeft(self):
+		ConfigListScreen.keyLeft(self)
+		self.newConfig()
+
+	def keyRight(self):
+		ConfigListScreen.keyRight(self)
+		self.newConfig()
+
 class NimSelection(Screen):
 	def __init__(self, session):
 		Screen.__init__(self, session)
diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py
index 3120a573..7aaca382 100644
--- a/lib/python/Screens/ScanSetup.py
+++ b/lib/python/Screens/ScanSetup.py
@@ -1,8 +1,8 @@
 from Screen import Screen
 from ServiceScan import *
-from Components.config import *
+from Components.config import config, ConfigSubsection, ConfigSelection, ConfigYesNo, ConfigInteger, getConfigListEntry, ConfigSlider, ConfigSatlist, ConfigEnableDisable
 from Components.ActionMap import NumberActionMap
-from Components.ConfigList import ConfigList
+from Components.ConfigList import ConfigList, ConfigListScreen
 from Components.NimManager import nimmanager
 from Components.Label import Label
 from Screens.MessageBox import MessageBox
@@ -115,7 +115,7 @@ def getInitialTerrestrialTransponderList(tlist, region):
 			tlist.append(parm)
 
 
-class ScanSetup(Screen):
+class ScanSetup(ConfigListScreen, Screen):
 	def __init__(self, session):
 		Screen.__init__(self, session)
 
@@ -135,26 +135,14 @@ class ScanSetup(Screen):
 		{
 			"ok": self.keyGo,
 			"cancel": self.keyCancel,
-			"left": self.keyLeft,
-			"right": self.keyRight,
-			"1": self.keyNumberGlobal,
-			"2": self.keyNumberGlobal,
-			"3": self.keyNumberGlobal,
-			"4": self.keyNumberGlobal,
-			"5": self.keyNumberGlobal,
-			"6": self.keyNumberGlobal,
-			"7": self.keyNumberGlobal,
-			"8": self.keyNumberGlobal,
-			"9": self.keyNumberGlobal,
-			"0": self.keyNumberGlobal
 		}, -1)
-		
+
 		self.statusTimer = eTimer()
 		self.statusTimer.timeout.get().append(self.updateStatus)
 		#self.statusTimer.start(5000, True)
 
 		self.list = []
-		self["config"] = ConfigList(self.list)
+		ConfigListScreen.__init__(self, self.list)
 		self.createSetup()
 
 		self["introduction"] = Label(_("Press OK to start the scan"))
@@ -173,95 +161,94 @@ class ScanSetup(Screen):
 	def createSetup(self):
 		self.list = []
 		self.multiscanlist = []
-		print "ID: " + str(config.scan.nims.value)
+		print "ID: ", self.scan_nims.index
 
-		self.tunerEntry = getConfigListEntry(_("Tuner"), config.scan.nims)
+		self.tunerEntry = getConfigListEntry(_("Tuner"), self.scan_nims)
 		self.list.append(self.tunerEntry)
 		
 		self.typeOfScanEntry = None
 		self.systemEntry = None
-		if (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-S"]):
-			self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), config.scan.type)
+		if nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-S"]:
+			self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_type)
 			self.list.append(self.typeOfScanEntry)
-		elif (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-C"]):
-			self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), config.scan.typecable)
+		elif nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-C"]:
+			self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typecable)
 			self.list.append(self.typeOfScanEntry)
-		elif (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-T"]):
-			self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), config.scan.typeterrestrial)
+		elif nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-T"]:
+			self.typeOfScanEntry = getConfigListEntry(_("Type of scan"), self.scan_typeterrestrial)
 			self.list.append(self.typeOfScanEntry)
 
+		if nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-S"]:
 
-		if (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-S"]):
-
-			if currentConfigSelectionElement(config.scan.type) == "single_transponder":
-				self.systemEntry = getConfigListEntry(_('Transpondertype'), config.scan.sat.system)
+			if self.scan_type.value == "single_transponder":
+				self.systemEntry = getConfigListEntry(_('Transpondertype'), self.scan_sat.system)
 				self.list.append(self.systemEntry)
-				self.list.append(getConfigListEntry(_('Satellite'), config.scan.satselection[config.scan.nims.value]))
-				self.list.append(getConfigListEntry(_('Frequency'), config.scan.sat.frequency))
-				self.list.append(getConfigListEntry(_('Inversion'), config.scan.sat.inversion))
-				self.list.append(getConfigListEntry(_('Symbol Rate'), config.scan.sat.symbolrate))
-				self.list.append(getConfigListEntry(_("Polarity"), config.scan.sat.polarization))
-				if currentConfigSelectionElement(config.scan.sat.system) == "dvb-s":
-					self.list.append(getConfigListEntry(_("FEC"), config.scan.sat.fec))
-				elif currentConfigSelectionElement(config.scan.sat.system) == "dvb-s2":
-					self.list.append(getConfigListEntry(_("FEC"), config.scan.sat.fec_s2))
-					self.list.append(getConfigListEntry(_('Modulation'), config.scan.sat.modulation))
-			elif currentConfigSelectionElement(config.scan.type) == "single_satellite":
+				self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[self.scan_nims.index]))
+				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(_("FEC"), self.scan_sat.fec))
+				elif self.scan_sat.system.value == "dvb-s2":
+					self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2))
+					self.list.append(getConfigListEntry(_('Modulation'), self.scan_sat.modulation))
+			elif self.scan_type.value == "single_satellite":
 				self.updateSatList()
-				print config.scan.satselection[config.scan.nims.value]
-				self.list.append(getConfigListEntry(_("Satellite"), config.scan.satselection[config.scan.nims.value]))
-				self.list.append(getConfigListEntry(_("Clear before scan"), config.scan.clearallservices))
-			elif currentConfigSelectionElement(config.scan.type) == "multisat":
+				print self.scan_satselection[self.scan_nims.index]
+				self.list.append(getConfigListEntry(_("Satellite"), self.scan_satselection[self.scan_nims.index]))
+				self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
+			elif self.scan_type.value == "multisat":
 				# if (norotor)
 				tlist = []
-				SatList = nimmanager.getSatListForNim(config.scan.nims.value)
-				self.list.append(getConfigListEntry(_("Clear before scan"), config.scan.clearallservices))
+				SatList = nimmanager.getSatListForNim(self.scan_nims.index)
+				self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
 				for x in SatList:
-					if self.Satexists(tlist, x[1]) == 0:
-						tlist.append(x[1])
-						sat = configElement_nonSave(x[1], configSelection, 0, (("enable", _("Enable")), ("disable", _("Disable"))))
-						configEntry = getConfigListEntry(nimmanager.getSatDescription(x[1]), sat)
+					if self.Satexists(tlist, x[0]) == 0:
+						tlist.append(x[0])
+						sat = ConfigEnableDisable(default = True)
+						configEntry = getConfigListEntry(nimmanager.getSatDescription(x[0]), sat)
 						self.list.append(configEntry)
-						self.multiscanlist.append(configEntry)
+						self.multiscanlist.append((x[0], sat))
 				# if (rotor):
     			   # for sat in nimmanager.satList:
-				#	self.list.append(getConfigListEntry(sat[0], config.scan.scansat[sat[1]]))
-
-
-		if (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-C"]):
-			if currentConfigSelectionElement(config.scan.typecable) == "single_transponder":
-				self.list.append(getConfigListEntry(_("Frequency"), config.scan.cab.frequency))
-				self.list.append(getConfigListEntry(_("Inversion"), config.scan.cab.inversion))
-				self.list.append(getConfigListEntry(_("Symbol Rate"), config.scan.cab.symbolrate))
-				self.list.append(getConfigListEntry(_("Modulation"), config.scan.cab.modulation))
-				self.list.append(getConfigListEntry(_("FEC"), config.scan.cab.fec))
-				self.list.append(getConfigListEntry(_("Network scan"), config.scan.cab.networkScan))
-			elif currentConfigSelectionElement(config.scan.typecable) == "complete":
-				self.list.append(getConfigListEntry(_("Clear before scan"), config.scan.clearallservices))
+				#	self.list.append(getConfigListEntry(sat[1], self.scan_scansat[sat[0]]))
+
+
+		if nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["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(_("Modulation"), self.scan_cab.modulation))
+				self.list.append(getConfigListEntry(_("FEC"), self.scan_cab.fec))
+				self.list.append(getConfigListEntry(_("Network scan"), self.scan_cab.networkScan))
+			elif self.scan_typecable.value == "complete":
+				self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
 				
-		if (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-T"]):
-			if currentConfigSelectionElement(config.scan.typeterrestrial) == "single_transponder":
-				self.list.append(getConfigListEntry(_("Frequency"), config.scan.ter.frequency))
-				self.list.append(getConfigListEntry(_("Network scan"), config.scan.ter.networkScan))
-				self.list.append(getConfigListEntry(_("Inversion"), config.scan.ter.inversion))
-				self.list.append(getConfigListEntry(_("Bandwidth"), config.scan.ter.bandwidth))
-				self.list.append(getConfigListEntry(_("Code rate high"), config.scan.ter.fechigh))
-				self.list.append(getConfigListEntry(_("Code rate low"), config.scan.ter.feclow))
-				self.list.append(getConfigListEntry(_("Modulation"), config.scan.ter.modulation))
-				self.list.append(getConfigListEntry(_("Transmission mode"), config.scan.ter.transmission))
-				self.list.append(getConfigListEntry(_("Guard interval mode"), config.scan.ter.guard))
-				self.list.append(getConfigListEntry(_("Hierarchy mode"), config.scan.ter.hierarchy))
-			elif currentConfigSelectionElement(config.scan.typeterrestrial) == "complete":
-				self.list.append(getConfigListEntry(_("Clear before scan"), config.scan.clearallservices))
-
-#		if (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-S"] and currentConfigSelectionElement(config.scan.type) == "single_transponder") or \
-#			(nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-C"] and currentConfigSelectionElement(config.scan.typecable) == "single_transponder") or \
-#			(nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-T"] and currentConfigSelectionElement(config.scan.typeterrestrial) == "single_transponder"):
-#				self.configElementSNR = getConfigListEntry(_("SNR"), config.scan.snr)
+		if nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-T"]:
+			if self.scan_typeterrestrial.value == "single_transponder":
+				self.list.append(getConfigListEntry(_("Frequency"), self.scan_ter.frequency))
+				self.list.append(getConfigListEntry(_("Network scan"), self.scan_ter.networkScan))
+				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(_("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))
+			elif self.scan_typeterrestrial.value == "complete":
+				self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
+
+#		if (nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-S"] and self.scan_type.type == "single_transponder") or \
+#			(nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-C"] and self.scan_typecable.type == "single_transponder") or \
+#			(nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["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"), config.scan.agc)
+#				self.configElementACG = getConfigListEntry(_("AGC"), self.scan_agc)
 #				self.list.append(self.configElementACG)
-#				self.configElementBER = getConfigListEntry(_("BER"), config.scan.ber)
+#				self.configElementBER = getConfigListEntry(_("BER"), self.scan_ber)
 #				self.list.append(self.configElementBER)
 #				self.statusTimer.start(500, False)
 #		else:
@@ -316,110 +303,105 @@ class ScanSetup(Screen):
 					   #("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": 0, "frequency": [11836], "inversion": 2, "symbolrate": [27500], "polarization": 0, "fec": 0, "fec_s2": 8, "modulation": 0 }
-			defaultCab = {"frequency": [466], "inversion": 2, "modulation": 2, "fec": 0, "symbolrate": [6900]}
+			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}
 			if frontendData is not None:
 				if frontendData["tuner_type"] == "DVB-S":
-					defaultSat["system"] = {"DVB-S": 0, "DVB-S2": 1}[frontendData["system"]]
-					defaultSat["frequency"] = [int(frontendData["frequency"] / 1000)]
-					defaultSat["inversion"] = {"INVERSION_OFF": 0, "INVERSION_ON": 1, "INVERSION_AUTO": 2}[frontendData["inversion"]]
-					defaultSat["symbolrate"] = [int(frontendData["symbol_rate"] / 1000)]
-					defaultSat["polarization"] = {"HORIZONTAL": 0, "VERTICAL": 1, "CIRCULAR_LEFT": 2, "CIRCULAR_RIGHT": 3, "UNKNOWN": 0}[frontendData["polarization"]]
-					defaultSat["fec"] = {"DVB-S": {"FEC_AUTO": 0, "FEC_1_2": 1, "FEC_2_3": 2, "FEC_3_4": 3, "FEC_5_6": 4, "FEC_7_8": 5, "FEC_NONE": 6}, "DVB-S2": {"FEC_1_2": 0, "FEC_2_3": 1, "FEC_3_4": 2, "FEC_4_5": 3, "FEC_5_6": 4, "FEC_7_8": 5, "FEC_8_9": 6, "FEC_9_10": 7}}[frontendData["system"]][frontendData["fec_inner"]]
-					defaultSat["modulation"] = {"QPSK": 0, "8PSK": 1}[frontendData["modulation"]]
+					defaultSat["system"] = {"DVB-S": "dvb-s", "DVB-S2": "dvb-s2"}[frontendData["system"]]
+					defaultSat["frequency"] = int(frontendData["frequency"] / 1000)
+					defaultSat["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData["inversion"]]
+					defaultSat["symbolrate"] = int(frontendData["symbol_rate"] / 1000)
+					defaultSat["polarization"] = {"HORIZONTAL": "horizontal", "VERTICAL": "vertical", "CIRCULAR_LEFT": "circular_left", "CIRCULAR_RIGHT": "circular_right", "UNKNOWN": None}[frontendData["polarization"]]
+					defaultSat["fec"] = {"DVB-S": {"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"}, "DVB-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["system"]][frontendData["fec_inner"]]
+					defaultSat["modulation"] = {"QPSK": "qpsk", "8PSK": "8psk"}[frontendData["modulation"]]
 					defaultSat["orbpos"] = frontendData["orbital_position"]
 				elif frontendData["tuner_type"] == "DVB-C":
-					defaultCab["frequency"] = [int(frontendData["frequency"] / 1000)]
-					defaultCab["symbolrate"] = [int(frontendData["symbol_rate"] / 1000)]
-					defaultSat["inversion"] = {"INVERSION_OFF": 0, "INVERSION_ON": 1, "INVERSION_AUTO": 2}[frontendData["inversion"]]
-					defaultSat["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": 7}[frontendData["fec_inner"]]
-					defaultSat["modulation"] = {"QAM_AUTO": 0, "QAM_16": 1, "QAM_16": 2, "QAM_32": 3, "QAM_64": 4, "QAM_128": 5, "QAM_256": 6}[frontendData["modulation"]]
-										
-			config.scan = ConfigSubsection()
-			config.scan.sat = ConfigSubsection()
-			config.scan.cab = ConfigSubsection()
-			config.scan.ter = ConfigSubsection()
-
-			config.scan.type = configElement_nonSave("config.scan.type", configSelection, 0, (("single_transponder", _("Single transponder")), ("single_satellite", _("Single satellite")), ("multisat", _("Multisat"))))
-			config.scan.typecable = configElement_nonSave("config.scan.typecable", configSelection, 0, (("single_transponder", _("Single transponder")), ("complete", _("Complete"))))
-			config.scan.typeterrestrial = configElement_nonSave("config.scan.typeterrestrial", configSelection, 0, (("single_transponder", _("Single transponder")), ("complete", _("Complete"))))
-			config.scan.clearallservices = configElement_nonSave("config.scan.clearallservices", configSelection, 0, (("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))))
+					defaultCab["frequency"] = int(frontendData["frequency"] / 1000)
+					defaultCab["symbolrate"] = int(frontendData["symbol_rate"] / 1000)
+					defaultSat["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData["inversion"]]
+					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_8_9": "8_9", "FEC_NONE": "none"}[frontendData["fec_inner"]]
+					defaultSat["modulation"] = {"QAM_AUTO": "auto", "QAM_16": "16qam", "QAM_32": "32qam", "QAM_64": "64qam", "QAM_128": "128qam", "QAM_256": "256qam"}[frontendData["modulation"]]
+
+			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_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)"))])
 
 			nimList = [ ]
 			for nim in nimmanager.nimList():
 				nimList.append(nim[0])
 			#nimList.append("all")
-			config.scan.nims = configElement_nonSave("config.scan.nims", configSelection, 0, nimList)
+			self.scan_nims = ConfigSelection(choices = nimList)
 			
 			# status
-			config.scan.snr = configElement_nonSave("config.scan.snr", configSlider, 0, (1, 100))
-			config.scan.snr.enabled = False
-			config.scan.agc = configElement_nonSave("config.scan.agc", configSlider, 0, (1, 100))
-			config.scan.agc.enabled = False
-			config.scan.ber = configElement_nonSave("config.scan.ber", configSlider, 0, (1, 100))
-			config.scan.ber.enabled = False
+			self.scan_snr = ConfigSlider()
+			self.scan_snr.enabled = False
+			self.scan_agc = ConfigSlider()
+			self.scan_agc.enabled = False
+			self.scan_ber = ConfigSlider()
+			self.scan_ber.enabled = False
 
 			# sat
-			config.scan.sat.system = configElement_nonSave("config.scan.sat.system", configSelection, defaultSat["system"], (("dvb-s", _("DVB-S")), ("dvb-s2", _("DVB-S2"))))
-			config.scan.sat.frequency = configElement_nonSave("config.scan.sat.frequency", configSequence, defaultSat["frequency"], configsequencearg.get("INTEGER", (1, 99999)))
-			config.scan.sat.inversion = configElement_nonSave("config.scan.sat.inversion", configSelection, defaultSat["inversion"], (("off", _("off")), ("on", _("on")), ("auto", _("Auto"))))
-			config.scan.sat.symbolrate = configElement_nonSave("config.scan.sat.symbolrate", configSequence, defaultSat["symbolrate"], configsequencearg.get("INTEGER", (1, 99999)))
-			config.scan.sat.polarization = configElement_nonSave("config.scan.sat.polarization", configSelection, defaultSat["polarization"], (("horizontal", _("horizontal")), ("vertical", _("vertical")),  ("circular_left", _("circular left")), ("circular_right", _("circular right"))))
-			config.scan.sat.fec = configElement_nonSave("config.scan.sat.fec", configSelection, defaultSat["fec"], (("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("none", _("None"))))
-			config.scan.sat.fec_s2 = configElement_nonSave("config.scan.sat.fec_s2", configSelection, defaultSat["fec_s2"], (("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")))
-			config.scan.sat.modulation = configElement_nonSave("config.scan.sat.modulation", configSelection, defaultSat["modulation"], (("qpsk", "QPSK"), ("8psk", "8PSK")))
+			self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [("dvb-s", _("DVB-S")), ("dvb-s2", _("DVB-S2"))])
+			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.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")])
 	
 			# cable
-			config.scan.cab.frequency = configElement_nonSave("config.scan.cab.frequency", configSequence, defaultCab["frequency"], configsequencearg.get("INTEGER", (50, 999)))
-			config.scan.cab.inversion = configElement_nonSave("config.scan.cab.inversion", configSelection, defaultCab["inversion"], (("off", _("off")), ("on", _("on")), ("auto", _("Auto"))))
-			config.scan.cab.modulation = configElement_nonSave("config.scan.cab.modulation", configSelection, defaultCab["modulation"], (("16qam", "16-QAM"), ("32qam", "32-QAM"), ("64qam", "64-QAM"), ("128qam", "128-QAM"), ("256qam", "256-QAM")))
-			config.scan.cab.fec = configElement_nonSave("config.scan.cab.fec", configSelection, defaultCab["fec"], (("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"))))
-			config.scan.cab.symbolrate = configElement_nonSave("config.scan.cab.symbolrate", configSequence, defaultCab["symbolrate"], configsequencearg.get("INTEGER", (1, 9999)))
-			config.scan.cab.networkScan = configElement_nonSave("config.scan.cab.networkScan", configSelection, 0, (("no", _("no")), ("yes", _("yes"))))
+			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.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999))
+			self.scan_cab.networkScan = ConfigYesNo(default = False)
 
 			# terrestial
-			config.scan.ter.frequency = configElement_nonSave("config.scan.ter.frequency", configSequence, [466], configsequencearg.get("INTEGER", (100, 900)))
-			config.scan.ter.inversion = configElement_nonSave("config.scan.ter.inversion", configSelection, 2, (("off", _("off")), ("on", _("on")), ("auto", _("Auto"))))
+			self.scan_ter.frequency = ConfigInteger(default = 466, limits = (100, 999))
+			self.scan_ter.inversion = ConfigSelection(default = "auto", choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))])
 			# WORKAROUND: we can't use BW-auto
-			config.scan.ter.bandwidth = configElement_nonSave("config.scan.ter.bandwidth", configSelection, 0, (("8MHz", "8MHz"), ("7MHz", "7MHz"), ("6MHz", "6MHz")))
+			self.scan_ter.bandwidth = ConfigSelection(default = "8MHz", choices = [("8MHz", "8MHz"), ("7MHz", "7MHz"), ("6MHz", "6MHz")])
 			#, ("auto", _("Auto"))))
-			config.scan.ter.fechigh = configElement_nonSave("config.scan.ter.fechigh", configSelection, 5, (("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))))
-			config.scan.ter.feclow = configElement_nonSave("config.scan.ter.feclow", configSelection, 5, (("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))))
-			config.scan.ter.modulation = configElement_nonSave("config.scan.ter.modulation", configSelection, 3, (("qpsk", "QPSK"), ("qam16", "QAM16"), ("qam64", "QAM64"), ("auto", _("Auto"))))
-			config.scan.ter.transmission = configElement_nonSave("config.scan.ter.transmission", configSelection, 2, (("2k", "2K"), ("8k", "8K"), ("auto", _("Auto"))))
-			config.scan.ter.guard = configElement_nonSave("config.scan.ter.guard", configSelection, 4, (("1_32", "1/32"), ("1_16", "1/16"), ("1_8", "1/8"), ("1_4", "1/4"), ("auto", _("Auto"))))
-			config.scan.ter.hierarchy = configElement_nonSave("config.scan.ter.hierarchy", configSelection, 4, (("none", _("None")), ("1", "1"), ("2", "2"), ("4", "4"), ("auto", _("Auto"))))
-			config.scan.ter.networkScan = configElement_nonSave("config.scan.cab.networkScan", configSelection, 0, (("no", _("no")), ("yes", _("yes"))))
-
-			config.scan.scansat = {}
+			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.networkScan = ConfigYesNo(default = False)
+
+			self.scan_scansat = {}
 			for sat in nimmanager.satList:
 				#print sat[1]
-				config.scan.scansat[sat[1]] = configElement_nonSave("config.scan.scansat[" + str(sat[1]) + "]", configSelection, 0, (("yes", _("yes")), ("no", _("no"))))
+				self.scan_scansat[sat[0]] = ConfigYesNo(default = False)
 
-			config.scan.satselection = []
+			self.scan_satselection = []
 			slotid = 0
 			for slot in nimmanager.nimslots:
 				if (nimmanager.getNimType(slot.slotid) == nimmanager.nimType["DVB-S"]):
 					print str(slot.slotid) + " : " + str(self.satList)
-					config.scan.satselection.append(configElement_nonSave("config.scan.satselection[" + str(slot.slotid) + "]", configSatlist, defaultSat["orbpos"], self.satList[slot.slotid]))
+					self.scan_satselection.append(ConfigSatlist(default = defaultSat["orbpos"], list = self.satList[slot.slotid]))
 				else:
-					config.scan.satselection.append(None)
+					self.scan_satselection.append(None)
+
 	def keyLeft(self):
-		self["config"].handleKey(config.key["prevElement"])
+		ConfigListScreen.keyLeft(self)
 		self.newConfig()
 
 	def keyRight(self):
-		self["config"].handleKey(config.key["nextElement"])
+		ConfigListScreen.keyRight(self)
 		self.newConfig()
 
 	def updateStatus(self):
 		print "updatestatus"
 
-	def keyNumberGlobal(self, number):
-		print "You pressed number " + str(number)
-		if (self["config"].getCurrent()[1].parent.enabled == True):
-			self["config"].handleKey(config.key[str(number)])
-
 	fecmap = { "auto": 0,
 			   "1_2": 1,
 			   "2_3": 2,
@@ -466,91 +448,91 @@ class ScanSetup(Screen):
 	def keyGo(self):
 		tlist = []
 		flags = 0
-		if (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-S"]):
-			if currentConfigSelectionElement(config.scan.type) == "single_transponder":
+		if nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-S"]:
+			if self.scan_type.value == "single_transponder":
 				l = len(self.satList)
-				if l and l > config.scan.nims.value:
-					nimsats=self.satList[config.scan.nims.value]
-					l = len(config.scan.satselection)
-					if l and l > config.scan.nims.value:
-						selsatidx=config.scan.satselection[config.scan.nims.value].value
+				if l and l > self.scan_nims.index:
+					nimsats=self.satList[self.scan_nims.index]
+					l = len(self.scan_satselection)
+					if l and l > self.scan_nims.index:
+						selsatidx=self.scan_satselection[self.scan_nims.index].index
 						l = len(nimsats)
 						if l and l > selsatidx:
-							orbpos=nimsats[selsatidx][1]
-							if currentConfigSelectionElement(config.scan.sat.system) == "dvb-s":
-								fec = currentConfigSelectionElement(config.scan.sat.fec)
+							orbpos=nimsats[selsatidx][0]
+							if self.scan_sat.system.value == "dvb-s":
+								fec = self.scan_sat.fec.value
 							else:
-								fec = currentConfigSelectionElement(config.scan.sat.fec_s2)
-							self.addSatTransponder(tlist, config.scan.sat.frequency.value[0],
-										config.scan.sat.symbolrate.value[0],
-										config.scan.sat.polarization.value,
+								fec = self.scan_sat.fec_s2.value
+							self.addSatTransponder(tlist, self.scan_sat.frequency.value,
+										self.scan_sat.symbolrate.value,
+										self.scan_sat.polarization.index,
 										fec,
-										config.scan.sat.inversion.value,
+										self.scan_sat.inversion.index,
 										orbpos,
-										config.scan.sat.system.value,
-										config.scan.sat.modulation.value)
-			elif currentConfigSelectionElement(config.scan.type) == "single_satellite":
-				sat = self.satList[config.scan.nims.value][config.scan.satselection[config.scan.nims.value].value]
-				getInitialTransponderList(tlist, int(sat[1]))
+										self.scan_sat.system.index,
+										self.scan_sat.modulation.index)
+			elif self.scan_type.value == "single_satellite":
+				sat = self.satList[self.scan_nims.index][self.scan_satselection[self.scan_nims.index].index]
+				getInitialTransponderList(tlist, sat[0])
 				flags |= eComponentScan.scanNetworkSearch
-				tmp = currentConfigSelectionElement(config.scan.clearallservices)
+				tmp = self.scan_clearallservices.value
 				if tmp == "yes":
 					flags |= eComponentScan.scanRemoveServices
 				elif tmp == "yes_hold_feeds":
 					flags |= eComponentScan.scanRemoveServices
 					flags |= eComponentScan.scanDontRemoveFeeds
-			elif currentConfigSelectionElement(config.scan.type) == "multisat":
-				SatList = nimmanager.getSatListForNim(config.scan.nims.value)
+			elif self.scan_type.value == "multisat":
+				SatList = nimmanager.getSatListForNim(self.scan_nims.index)
 				for x in self.multiscanlist:
-					if x[1].parent.value == 0:
-						print "   " + str(x[1].parent.configPath)
-						getInitialTransponderList(tlist, x[1].parent.configPath)
+					if x[1].value:
+						print "   " + str(x[0])
+						getInitialTransponderList(tlist, x[0])
 				flags |= eComponentScan.scanNetworkSearch
-				tmp = currentConfigSelectionElement(config.scan.clearallservices)
+				tmp = self.scan_clearallservices.value
 				if tmp == "yes":
 					flags |= eComponentScan.scanRemoveServices
 				elif tmp == "yes_hold_feeds":
 					flags |= eComponentScan.scanRemoveServices
 					flags |= eComponentScan.scanDontRemoveFeeds
 
-		elif (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-C"]):
-			if currentConfigSelectionElement(config.scan.typecable) == "single_transponder":
-				fec = currentConfigSelectionElement(config.scan.cab.fec)
-				self.addCabTransponder(tlist, config.scan.cab.frequency.value[0],
-											  config.scan.cab.symbolrate.value[0],
-											  config.scan.cab.modulation.value + 1,
+		elif (nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["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.scan_cab.modulation.index + 1,
 											  fec,
-											  config.scan.cab.inversion.value)
-				if currentConfigSelectionElement(config.scan.cab.networkScan) == "yes":
+											  self.scan_cab.inversion.index)
+				if self.scan_cab.networkScan.value:
 					flags |= eComponentScan.scanNetworkSearch
-			elif currentConfigSelectionElement(config.scan.typecable) == "complete":
-				getInitialCableTransponderList(tlist, nimmanager.getCableDescription(config.scan.nims.value))
+			elif self.scan_typecable.value == "complete":
+				getInitialCableTransponderList(tlist, nimmanager.getCableDescription(self.scan_nims.index))
 				flags |= eComponentScan.scanNetworkSearch
-				tmp = currentConfigSelectionElement(config.scan.clearallservices)
+				tmp = self.scan_clearallservices
 				if tmp == "yes":
 					flags |= eComponentScan.scanRemoveServices
 				elif tmp == "yes_hold_feeds":
 					flags |= eComponentScan.scanRemoveServices
 					flags |= eComponentScan.scanDontRemoveFeeds
 
-		elif (nimmanager.getNimType(config.scan.nims.value) == nimmanager.nimType["DVB-T"]):
-			if currentConfigSelectionElement(config.scan.typeterrestrial) == "single_transponder":
+		elif (nimmanager.getNimType(self.scan_nims.index) == nimmanager.nimType["DVB-T"]):
+			if self.scan_typeterrestrial.value == "single_transponder":
 				self.addTerTransponder(tlist,
-						config.scan.ter.frequency.value[0] * 1000000,
-						inversion = config.scan.ter.inversion.value,
-						bandwidth = config.scan.ter.bandwidth.value,
-						fechigh = config.scan.ter.fechigh.value,
-						feclow = config.scan.ter.feclow.value,
-						modulation = config.scan.ter.modulation.value,
-						transmission = config.scan.ter.transmission.value,
-						guard = config.scan.ter.guard.value,
-						hierarchy = config.scan.ter.hierarchy.value)
-				if currentConfigSelectionElement(config.scan.ter.networkScan) == "yes":
+						self.scan_ter.frequency.value * 1000000,
+						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)
+				if self.scan_ter.networkScan.value:
 					flags |= eComponentScan.scanNetworkSearch
-			elif currentConfigSelectionElement(config.scan.typeterrestrial) == "complete":
-				getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(config.scan.nims.value))
+			elif self.scan_typeterrestrial.value == "complete":
+				getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(self.scan_nims.index))
 				flags |= eComponentScan.scanNetworkSearch
-				tmp = currentConfigSelectionElement(config.scan.clearallservices)
+				tmp = self.scan_clearallservices.value
 				if tmp == "yes":
 					flags |= eComponentScan.scanRemoveServices
 				elif tmp == "yes_hold_feeds":
@@ -561,7 +543,7 @@ class ScanSetup(Screen):
 			x[1].save()
 
 		if len(tlist):
-			feid = config.scan.nims.value
+			feid = self.scan_nims.index
 			# flags |= eComponentScan.scanSearchBAT
 			self.session.openWithCallback(self.doNothing, ServiceScan, [{"transponders": tlist, "feid": feid, "flags": flags}])
 		else:
@@ -575,7 +557,41 @@ class ScanSetup(Screen):
 			x[1].cancel()
 		self.close()
 
-class ScanSimple(Screen):
+class ScanSimple(ConfigListScreen, Screen):
+	def __init__(self, session):
+		Screen.__init__(self, session)
+
+		self["actions"] = ActionMap(["SetupActions"],
+		{
+			"ok": self.keyGo,
+			"cancel": self.keyCancel,
+		}, -1)
+
+		self.list = []
+		tlist = []
+
+		nimcount = nimmanager.getNimSocketCount()
+		if nimcount > 0:
+			nimtype = nimmanager.getNimType(0)
+			scan_possible=True
+			self.scan_clearallservices = ConfigSelection(default = "yes", choices = [("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))])
+			self.list.append(getConfigListEntry(_("Clear before scan"), self.scan_clearallservices))
+			nim = ConfigYesNo(default = True)
+			nim.nim_index = 0
+			if nimtype == nimmanager.nimType["DVB-S"] and not len(nimmanager.getSatListForNim(0)):
+				scan_possible=False
+			if scan_possible:
+				self.list.append(getConfigListEntry(_("Scan NIM") + " 0 (" + nimmanager.getNimTypeName(0) + ")", nim))
+
+		if nimcount > 1 and self.ScanNimTwoNeeded():
+			nim = ConfigYesNo(default = True)
+			nim.nim_index = 1
+			self.list.append(getConfigListEntry(_("Scan NIM") + " 1 (" + nimmanager.getNimTypeName(1) + ")", nim))
+
+		ConfigListScreen.__init__(self, self.list)
+		self["header"] = Label(_("Automatic Scan"))
+		self["footer"] = Label(_("Press OK to scan"))
+
 	def run(self):
 		self.keyGo()
 
@@ -592,13 +608,14 @@ class ScanSimple(Screen):
 		else:
 			two_sat_tuners = False
 
-		for x in self.list:
-			slotid = x[1].parent.configPath
-			print "Scan Tuner", slotid, "-", currentConfigSelectionElement(x[1].parent)
-			if currentConfigSelectionElement(x[1].parent) == "yes":
+		for (x, c) in self.list[1:]:
+			slotid = c.nim_index
+			print "Scan Tuner", slotid, "-", c.value
+			if c.value:
 				scanPossible = False
 				tlist = [ ]
-				if nimmanager.getNimType(x[1].parent.configPath) == nimmanager.nimType["DVB-S"]:
+				if nimmanager.getNimType(slotid) == nimmanager.nimType["DVB-S"]:
+					print "is sat"
 					if two_sat_tuners:
 						if slotid > 0:
 							idx = exclusive_satellites[0]+1
@@ -608,19 +625,22 @@ class ScanSimple(Screen):
 						print "exclusive_nim_sats", exclusive_nim_sats
 					SatList = nimmanager.getSatListForNim(slotid)
 					for sat in SatList:
-						if not two_sat_tuners or (sat[1] in exclusive_nim_sats or slotid == 0):
+						if not two_sat_tuners or (sat[0] in exclusive_nim_sats or slotid == 0):
 							scanPossible = True
 							print sat
-							getInitialTransponderList(tlist, sat[1])
-				elif nimmanager.getNimType(x[1].parent.configPath) == nimmanager.nimType["DVB-C"]:
+							getInitialTransponderList(tlist, sat[0])
+				elif nimmanager.getNimType(slotid) == nimmanager.nimType["DVB-C"]:
 					scanPossible = True
 					getInitialCableTransponderList(tlist, nimmanager.getCableDescription(slotid))
-				elif nimmanager.getNimType(x[1].parent.configPath) == nimmanager.nimType["DVB-T"]:
+				elif nimmanager.getNimType(slotid) == nimmanager.nimType["DVB-T"]:
 					scanPossible = True
 					getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(slotid))
+				else:
+					assert False
+
 				if scanPossible:
 					flags=eComponentScan.scanNetworkSearch
-					tmp = currentConfigSelectionElement(config.scan.clearallservices)
+					tmp = self.scan_clearallservices.value
 					if tmp == "yes":
 						flags |= eComponentScan.scanRemoveServices
 					elif tmp == "yes_hold_feeds":
@@ -638,12 +658,6 @@ class ScanSimple(Screen):
 	def keyCancel(self):
 		self.close()
 
-	def keyLeft(self):
-		self["config"].handleKey(config.key["prevElement"])
-
-	def keyRight(self):
-		self["config"].handleKey(config.key["nextElement"])
-
 	def Satexists(self, tlist, pos):
 		for x in tlist:
 			if x == pos:
@@ -667,37 +681,3 @@ class ScanSimple(Screen):
 					return True
 		return False # two -C or two -T tuners
 
-	def __init__(self, session):
-		Screen.__init__(self, session)
-
-		self["actions"] = ActionMap(["SetupActions"],
-		{
-			"ok": self.keyGo,
-			"cancel": self.keyCancel,
-			"left": self.keyLeft,
-			"right": self.keyRight,
-		}, -1)
-
-		self.list = []
-		tlist = []
-
-		nimcount = nimmanager.getNimSocketCount()
-		if nimcount > 0:
-			nimtype = nimmanager.getNimType(0)
-			scan_possible=True
-			config.scan = ConfigSubsection()
-			config.scan.clearallservices = configElement_nonSave("config.scan.clearallservices", configSelection, 0, (("no", _("no")), ("yes", _("yes")), ("yes_hold_feeds", _("yes (keep feeds)"))))
-			self.list.append(getConfigListEntry(_("Clear before scan"), config.scan.clearallservices))
-			nim = configElement_nonSave(0, configSelection, 0, (("yes", _("yes")), ("no", _("no"))))
-			if nimtype == nimmanager.nimType["DVB-S"] and not len(nimmanager.getSatListForNim(0)):
-				scan_possible=False
-			if scan_possible:
-				self.list.append(getConfigListEntry(_("Scan NIM") + " 0 (" + nimmanager.getNimTypeName(0) + ")", nim))
-	
-		if nimcount > 1 and self.ScanNimTwoNeeded():
-			nim = configElement_nonSave(1, configSelection, 0, (("yes", _("yes")), ("no", _("no"))))
-			self.list.append(getConfigListEntry(_("Scan NIM") + " 1 (" + nimmanager.getNimTypeName(1) + ")", nim))
-
-		self["config"] = ConfigList(self.list)
-		self["header"] = Label(_("Automatic Scan"))
-		self["footer"] = Label(_("Press OK to scan"))
diff --git a/lib/python/Screens/Setup.py b/lib/python/Screens/Setup.py
index 746c26d3..b36a6b45 100644
--- a/lib/python/Screens/Setup.py
+++ b/lib/python/Screens/Setup.py
@@ -1,8 +1,7 @@
 from Screen import Screen
 from Components.ActionMap import NumberActionMap
-from Components.config import config				#global config instance
-from Components.config import configSelection
-from Components.ConfigList import ConfigList
+from Components.config import config, KEY_LEFT, KEY_RIGHT, KEY_OK
+from Components.ConfigList import ConfigList, ConfigListScreen
 from Components.Label import Label
 from Components.Pixmap import Pixmap
 
@@ -25,10 +24,10 @@ setupfile.close()
 
 class SetupSummary(Screen):
 	skin = """
-	<screen position="0,0" size="132,64">
-		<widget name="SetupTitle" position="0,0" size="132,16" font="Regular;12" />
-		<widget name="SetupEntry" position="0,16" size="132,32" font="Regular;12" />
-		<widget name="SetupValue" position="0,48" size="132,16" font="Regular;12" />
+	<screen position="6,0" size="120,64">
+		<widget name="SetupTitle" position="6,0" size="120,16" font="Regular;12" />
+		<widget name="SetupEntry" position="6,16" size="120,32" font="Regular;12" />
+		<widget name="SetupValue" position="6,48" size="120,16" font="Regular;12" />
 	</screen>"""
 
 	def __init__(self, session, parent):
@@ -53,7 +52,7 @@ class SetupSummary(Screen):
 		self["SetupEntry"].text = self.parent.getCurrentEntry()
 		self["SetupValue"].text = self.parent.getCurrentValue()
 
-class Setup(Screen):
+class Setup(ConfigListScreen, Screen):
 
 	ALLOW_SUSPEND = True
 
@@ -78,8 +77,6 @@ class Setup(Screen):
 
 		#check for list.entries > 0 else self.close
 		
-		self["config"] = ConfigList(list)
-
 		self.setup_title = myTitle
 		self["title"] = Label(_(self.setup_title))
 
@@ -91,22 +88,11 @@ class Setup(Screen):
 		self["actions"] = NumberActionMap(["SetupActions"], 
 			{
 				"cancel": self.keyCancel,
-				"ok": self.keyOk,
-				"left": self.keyLeft,
-				"right": self.keyRight,
 				"save": self.keySave,
-				"1": self.keyNumberGlobal,
-				"2": self.keyNumberGlobal,
-				"3": self.keyNumberGlobal,
-				"4": self.keyNumberGlobal,
-				"5": self.keyNumberGlobal,
-				"6": self.keyNumberGlobal,
-				"7": self.keyNumberGlobal,
-				"8": self.keyNumberGlobal,
-				"9": self.keyNumberGlobal,
-				"0": self.keyNumberGlobal
 			}, -1)
 
+		ConfigListScreen.__init__(self, list, session = session)
+
 		self.changedEntry()
 
 	# for summary:
@@ -118,7 +104,7 @@ class Setup(Screen):
 		return self["config"].getCurrent()[0]
 
 	def getCurrentValue(self):
-		return str(self["config"].getCurrent()[1].parent.value)
+		return str(self["config"].getCurrent()[1].value)
 
 	def createSummary(self):
 		return SetupSummary
@@ -130,32 +116,14 @@ class Setup(Screen):
 			elif x.tagName == 'item':
 				item_text = _(x.getAttribute("text").encode("UTF-8") or "??")
 				b = eval(XMLTools.mergeText(x.childNodes));
-				print "item " + item_text + " " + b.configPath
 				if b == "":
 					continue
 				#add to configlist
-				item = b.controlType(b)
-				
+				item = b
 				# the first b is the item itself, ignored by the configList.
 				# the second one is converted to string.
 				list.append( (item_text, item) )
 
-	def handleKey(self, key):
-		# ignore keys when not enabled
-		if self["config"].getCurrent()[1].parent.enabled:
-			self["config"].handleKey(config.key[key])
-			print self["config"].getCurrent()
-			self.changedEntry()
-
-	def keyOk(self):
-		self.handleKey("choseElement")
-
-	def keyLeft(self):
-		self.handleKey("prevElement")
-
-	def keyRight(self):
-		self.handleKey("nextElement")
-
 	def keySave(self):
 		print "save requested"
 		for x in self["config"].list:
@@ -168,9 +136,6 @@ class Setup(Screen):
 			x[1].cancel()
 		self.close()
 		
-	def keyNumberGlobal(self, number):
-		self.handleKey(str(number))
-
 def getSetupTitle(id):
 	xmldata = setupdom.childNodes[0].childNodes
 	for x in elementsWithTag(xmldata, "setup"):
diff --git a/lib/python/Screens/SimpleSummary.py b/lib/python/Screens/SimpleSummary.py
index f4502a76..1a5fe887 100644
--- a/lib/python/Screens/SimpleSummary.py
+++ b/lib/python/Screens/SimpleSummary.py
@@ -4,10 +4,10 @@ from Components.Sources.Clock import Clock
 class SimpleSummary(Screen):
 	skin = """
 	<screen position="0,0" size="132,64">
-		<widget name="Clock" position="50,46" size="82,18" font="Regular;16">
+		<widget name="Clock" position="56,46" size="82,18" font="Regular;16">
 			<convert type="ClockToText">WithSeconds</convert>
 		</widget>
-		<widget name="Title" position="0,4" size="132,42" font="Regular;18" />
+		<widget name="Title" position="6,4" size="120,42" font="Regular;18" />
 	</screen>"""
 	def __init__(self, session, root_screen):
 		from Components.Label import Label
diff --git a/lib/python/Screens/StartWizard.py b/lib/python/Screens/StartWizard.py
index 8fc4ecdf..b67ca9d4 100644
--- a/lib/python/Screens/StartWizard.py
+++ b/lib/python/Screens/StartWizard.py
@@ -1,12 +1,12 @@
 from Wizard import Wizard, wizardManager
 
 from Components.Pixmap import *
-from Components.config import configElementBoolean, config, configfile
+from Components.config import config, ConfigBoolean, configfile
 
 from LanguageSelection import LanguageSelection
 
-config.misc.firstrun = configElementBoolean("config.misc.firstrun", 1);
-config.misc.languageselected = configElementBoolean("config.misc.languageselected", 1);
+config.misc.firstrun = ConfigBoolean(default = True)
+config.misc.languageselected = ConfigBoolean(default = True)
 
 class StartWizard(Wizard):
 	skin = """
diff --git a/lib/python/Screens/TimeDateInput.py b/lib/python/Screens/TimeDateInput.py
index 4ea67b74..c7a66641 100644
--- a/lib/python/Screens/TimeDateInput.py
+++ b/lib/python/Screens/TimeDateInput.py
@@ -1,14 +1,14 @@
 from Screen import Screen
 from Components.config import *
 from Components.ActionMap import ActionMap, NumberActionMap
-from Components.ConfigList import ConfigList
+from Components.ConfigList import ConfigList, ConfigListScreen
 from Components.Button import Button
 from Components.Label import Label
 from Components.Pixmap import Pixmap
 import time
 import datetime
 
-class TimeDateInput(Screen):
+class TimeDateInput(Screen, ConfigListScreen):
 	def __init__(self, session):
 		Screen.__init__(self, session)
 
@@ -19,35 +19,22 @@ class TimeDateInput(Screen):
 
 		self.createConfig()
 
-		self["actions"] = NumberActionMap(["SetupActions", "TextEntryActions"],
+		self["actions"] = NumberActionMap(["SetupActions"],
 		{
 			"ok": self.keySelect,
 			"save": self.keyGo,
 			"cancel": self.keyCancel,
-			"left": self.keyLeft,
-			"right": self.keyRight,
-			"delete": self.keyDelete,
-			"1": self.keyNumberGlobal,
-			"2": self.keyNumberGlobal,
-			"3": self.keyNumberGlobal,
-			"4": self.keyNumberGlobal,
-			"5": self.keyNumberGlobal,
-			"6": self.keyNumberGlobal,
-			"7": self.keyNumberGlobal,
-			"8": self.keyNumberGlobal,
-			"9": self.keyNumberGlobal,
-			"0": self.keyNumberGlobal
 		}, -1)
 
 		self.list = []
-		self["config"] = ConfigList(self.list)
+		ConfigListScreen.__init__(self, self.list)
 		self.createSetup(self["config"])
 
 	def createConfig(self):
-			config.timeinput = ConfigSubsection()
-			nowtime = time.time()
-			config.timeinput.date = configElement_nonSave("config.timeinput.date", configDateTime, nowtime, (_("%d.%B %Y"), 86400))
-			config.timeinput.time = configElement_nonSave("config.timeinput.time", configSequence, [int(time.strftime("%H", time.localtime(nowtime))), int(time.strftime("%M", time.localtime(nowtime)))], configsequencearg.get("CLOCK"))
+		nowtime = time.time()
+		self.timeinput_date = ConfigDateTime(default = nowtime, formatstring = (_("%d.%B %Y"), 86400))
+#		self.timeinput_time = ConfigSequence(default = [int(time.strftime("%H", time.localtime(nowtime))), int(time.strftime("%M", time.localtime(nowtime)))]
+		assert False, "fixme"
 
 	def createSetup(self, configlist):
 		self.list = []
@@ -56,29 +43,15 @@ class TimeDateInput(Screen):
 		configlist.list = self.list
 		configlist.l.setList(self.list)
 
-	def keyLeft(self):
-		self["config"].handleKey(config.key["prevElement"])
-
-	def keyDelete(self):
-		self["config"].handleKey(config.key["delete"])
-
 	def keyRightCallback(self, configPath):
 		currentConfigPath = self["config"].getCurrent()[1].parent.getConfigPath()
 		# check if we are still on the same config entry
 		if (currentConfigPath == configPath):
 			self.keyRight()
 
-	def keyRight(self):
-		self["config"].handleKey(config.key["nextElement"])
-
 	def keySelect(self):
 		self.keyGo()
 
-	def keyNumberGlobal(self, number):
-		print "You pressed number " + str(number)
-		if (self["config"].getCurrent()[1].parent.enabled == True):
-			self["config"].handleKey(config.key[str(number)])
-
 	def getTimestamp(self, date, mytime):
 		d = time.localtime(date)
 		dt = datetime.datetime(d.tm_year, d.tm_mon, d.tm_mday, mytime[0], mytime[1])
diff --git a/lib/python/Screens/TimerEdit.py b/lib/python/Screens/TimerEdit.py
index 4a4185c3..ed11874e 100644
--- a/lib/python/Screens/TimerEdit.py
+++ b/lib/python/Screens/TimerEdit.py
@@ -1,6 +1,5 @@
 from Screen import Screen
 from Components.TimerList import TimerList, TimerEntryComponent
-from Components.ConfigList import ConfigList
 from Components.MenuList import MenuList
 from Components.ActionMap import ActionMap
 from Components.Label import Label
@@ -10,7 +9,6 @@ from TimerEntry import TimerEntry, TimerLog
 from RecordTimer import RecordTimerEntry, parseEvent, AFTEREVENT
 from time import *
 from ServiceReference import ServiceReference
-from Components.config import *
 from Components.TimerSanityCheck import TimerSanityCheck
 
 class TimerEditList(Screen):
diff --git a/lib/python/Screens/TimerEntry.py b/lib/python/Screens/TimerEntry.py
index 85f41fb2..fa75b5c0 100644
--- a/lib/python/Screens/TimerEntry.py
+++ b/lib/python/Screens/TimerEntry.py
@@ -1,9 +1,9 @@
 from Screen import Screen
 import ChannelSelection
 from ServiceReference import ServiceReference
-from Components.config import *
+from Components.config import ConfigSelection, ConfigText, ConfigSubList, ConfigSubsection, ConfigDateTime, ConfigClock, ConfigYesNo, getConfigListEntry
 from Components.ActionMap import ActionMap, NumberActionMap
-from Components.ConfigList import ConfigList
+from Components.ConfigList import ConfigList, ConfigListScreen
 from Components.MenuList import MenuList
 from Components.Button import Button
 from Components.NimManager import nimmanager
@@ -16,7 +16,7 @@ from enigma import eEPGCache
 import time
 import datetime
 
-class TimerEntry(Screen):
+class TimerEntry(Screen, ConfigListScreen):
 	def __init__(self, session, timer):
 		Screen.__init__(self, session)
 		self.timer = timer
@@ -28,93 +28,76 @@ class TimerEntry(Screen):
 
 		self.createConfig()
 
-		self["actions"] = NumberActionMap(["SetupActions", "TextEntryActions"],
+		self["actions"] = NumberActionMap(["SetupActions"],
 		{
 			"ok": self.keySelect,
 			"save": self.keyGo,
 			"cancel": self.keyCancel,
-			"left": self.keyLeft,
-			"right": self.keyRight,
-			"delete": self.keyDelete,
-			"1": self.keyNumberGlobal,
-			"2": self.keyNumberGlobal,
-			"3": self.keyNumberGlobal,
-			"4": self.keyNumberGlobal,
-			"5": self.keyNumberGlobal,
-			"6": self.keyNumberGlobal,
-			"7": self.keyNumberGlobal,
-			"8": self.keyNumberGlobal,
-			"9": self.keyNumberGlobal,
-			"0": self.keyNumberGlobal
 		}, -1)
 
 		self.list = []
-		self["config"] = ConfigList(self.list)
+		ConfigListScreen.__init__(self, self.list, session = session)
 		self.createSetup("config")
 
 	def createConfig(self):
-			config.timerentry = ConfigSubsection()
-			
-			if (self.timer.justplay):
-				justplay = 0
-			else:
-				justplay = 1
+			justplay = self.timer.justplay
 				
-			afterevent = { AFTEREVENT.NONE: 0, AFTEREVENT.DEEPSTANDBY: 1, AFTEREVENT.STANDBY: 2}[self.timer.afterEvent]
+			afterevent = { AFTEREVENT.NONE: "nothing", AFTEREVENT.DEEPSTANDBY: "deepstandby", AFTEREVENT.STANDBY: "standby"}[self.timer.afterEvent]
+			
+			weekday_table = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
 
 			# calculate default values
 			day = []
 			weekday = 0
 			for x in range(0,7):
-				day.append(1)
-			if (self.timer.repeated != 0): # repeated
-				type = 1 # repeated
+				day.append(0)
+			if self.timer.repeated: # repeated
+				type = "repeated"
 				if (self.timer.repeated == 31): # Mon-Fri
-					repeated = 2 # Mon - Fri
+					repeated = "weekdays"
 				elif (self.timer.repeated == 127): # daily
-					repeated = 0 # daily
+					repeated = "daily"
 				else:
 					flags = self.timer.repeated
-					repeated = 3 # user defined
+					repeated = "user"
 					count = 0
 					for x in range(0, 7):
-						if (flags == 1): # weekly
+						if flags == 1: # weekly
 							print "Set to weekday " + str(x)
 							weekday = x
-						if (flags & 1 == 1): # set user defined flags
-							day[x] = 0
+						if flags & 1 == 1: # set user defined flags
+							day[x] = 1
 							count += 1
 						else:
-							day[x] = 1
+							day[x] = 0
 						flags = flags >> 1
-					if (count == 1):
-						repeated = 1 # weekly
+					if count == 1:
+						repeated = "weekly"
 			else: # once
-				type = 0
-				repeated = 0
-				weekday = (int(strftime("%w", time.localtime(self.timer.begin))) - 1) % 7
-				day[weekday] = 0
+				type = "once"
+				repeated = None
+				weekday = (int(time.strftime("%w", time.localtime(self.timer.begin))) - 1) % 7
+				day[weekday] = 1
 			
-			config.timerentry.justplay = configElement_nonSave("config.timerentry.justplay", configSelection, justplay, (("zap", _("zap")), ("record", _("record"))))
-			config.timerentry.afterevent = configElement_nonSave("config.timerentry.afterevent", configSelection, afterevent, (("nothing", _("do nothing")), ("deepstandby", _("go to deep standby"))))
-			config.timerentry.type = configElement_nonSave("config.timerentry.type", configSelection, type, (_("once"), _("repeated")))
-			config.timerentry.name = configElement_nonSave("config.timerentry.name", configText, self.timer.name, (configText.extendableSize, self.keyRightCallback))
-			config.timerentry.description = configElement_nonSave("config.timerentry.description", configText, self.timer.description, (configText.extendableSize, self.keyRightCallback))
+			self.timerentry_justplay = ConfigSelection(choices = [("zap", _("zap")), ("record", _("record"))], default = {0: "record", 1: "record"}[justplay])
+			self.timerentry_afterevent = ConfigSelection(choices = [("nothing", _("do nothing")), ("deepstandby", _("go to deep standby"))], default = afterevent)
+			self.timerentry_type = ConfigSelection(choices = [("once",_("once")), ("repeated", _("repeated"))], default = type)
+			self.timerentry_name = ConfigText(default = self.timer.name, fixed_size = False)
+			self.timerentry_description = ConfigText(default = self.timer.description, fixed_size = False)
 
-			config.timerentry.repeated = configElement_nonSave("config.timerentry.repeated", configSelection, repeated, (_("daily"), _("weekly"), _("Mon-Fri"), _("user defined")))
+			self.timerentry_repeated = ConfigSelection(default = repeated, choices = [("daily", _("daily")), ("weekly", _("weekly")), ("weekdays", _("Mon-Fri")), ("user", _("user defined"))])
 
-			config.timerentry.startdate = configElement_nonSave("config.timerentry.startdate", configDateTime, self.timer.begin, (_("%d.%B %Y"), 86400))
-			config.timerentry.starttime = configElement_nonSave("config.timerentry.starttime", configSequence, [int(time.strftime("%H", time.localtime(self.timer.begin))), int(time.strftime("%M", time.localtime(self.timer.begin)))], configsequencearg.get("CLOCK"))
+			self.timerentry_startdate = ConfigDateTime(default = self.timer.begin, formatstring = _("%d.%B %Y"), increment = 86400)
+			self.timerentry_starttime = ConfigClock(default = [int(time.strftime("%H", time.localtime(self.timer.begin))), int(time.strftime("%M", time.localtime(self.timer.begin)))])
 
-			config.timerentry.enddate = configElement_nonSave("config.timerentry.enddate", configDateTime, self.timer.end, (_("%d.%B %Y"), 86400))
-			config.timerentry.endtime = configElement_nonSave("config.timerentry.endtime", configSequence, [int(time.strftime("%H", time.localtime(self.timer.end))), int(time.strftime("%M", time.localtime(self.timer.end)))], configsequencearg.get("CLOCK"))
+			self.timerentry_enddate = ConfigDateTime(default = self.timer.end, formatstring =  _("%d.%B %Y"), increment = 86400)
+			self.timerentry_endtime = ConfigClock(default = [int(time.strftime("%H", time.localtime(self.timer.end))), int(time.strftime("%M", time.localtime(self.timer.end)))])
 
-			config.timerentry.weekday = configElement_nonSave("config.timerentry.weekday", configSelection, weekday, (_("Monday"), _("Tuesday"), _("Wednesday"), _("Thursday"), _("Friday"), _("Saturday"), _("Sunday")))
+			self.timerentry_weekday = ConfigSelection(default = weekday_table[weekday], choices = [("mon",_("Monday")), ("tue", _("Tuesday")), ("wed",_("Wednesday")), ("thu", _("Thursday")), ("fri", _("Friday")), ("sat", _("Saturday")), ("sun", _("Sunday"))])
 
-			config.timerentry.day = []
+			self.timerentry_day = ConfigSubList()
 			for x in range(0,7):
-				config.timerentry.day.append(configElement_nonSave("config.timerentry.day[" + str(x) + "]", configSelection, day[x], (_("yes"), _("no"))))
-
+				self.timerentry_day.append(ConfigYesNo(default = day[x]))
 
 			# FIXME some service-chooser needed here
 			servicename = "N/A"
@@ -122,79 +105,72 @@ class TimerEntry(Screen):
 				servicename = str(self.timer.service_ref.getServiceName())
 			except:
 				pass
-			config.timerentry.service = configElement_nonSave("config.timerentry.service", configSelection, 0, ((servicename),))
+			self.timerentry_service = ConfigSelection([servicename])
 			
-			config.timerentry.startdate.addNotifier(self.checkDate)
-			config.timerentry.enddate.addNotifier(self.checkDate)
+			self.timerentry_startdate.addNotifier(self.checkDate)
+			self.timerentry_enddate.addNotifier(self.checkDate)
 
 	def checkDate(self, configElement):
-		if (configElement.getConfigPath() == "config.timerentry.startdate"):
-			if (config.timerentry.enddate.value < config.timerentry.startdate.value):
-				config.timerentry.enddate.value = config.timerentry.startdate.value
-				config.timerentry.enddate.change()
-				try:
-					self["config"].invalidate(config.timerentry.enddate)
-				except: # FIXME: what could go wrong here?
-					pass
-		if (configElement.getConfigPath() == "config.timerentry.enddate"):
-			if (config.timerentry.enddate.value < config.timerentry.startdate.value):
-				config.timerentry.startdate.value = config.timerentry.enddate.value
-				config.timerentry.startdate.change()
-				try:
-					self["config"].invalidate(config.timerentry.startdate)
-				except: # FIXME: what could go wrong here?
-					pass
+		if configElement is self.timerentry_startdate:
+			if self.timerentry_enddate.value < self.timerentry_startdate.value:
+				self.timerentry_enddate.value = self.timerentry_startdate.value
+				self["config"].invalidate(self.timerentry_enddate)
+		if configElement is self.timerentry_enddate:
+			if (self.timerentry_enddate.value < self.timerentry_startdate.value):
+				self.timerentry_startdate.value = self.timerentry_enddate.value
+				self["config"].invalidate(self.timerentry_startdate)
 
 	def createSetup(self, widget):
 		self.list = []
-		self.list.append(getConfigListEntry(_("Name"), config.timerentry.name))
-		self.list.append(getConfigListEntry(_("Description"), config.timerentry.description))
-		self.timerJustplayEntry = getConfigListEntry(_("Timer Type"), config.timerentry.justplay)
+		self.list.append(getConfigListEntry(_("Name"), self.timerentry_name))
+		self.list.append(getConfigListEntry(_("Description"), self.timerentry_description))
+		self.timerJustplayEntry = getConfigListEntry(_("Timer Type"), self.timerentry_justplay)
 		self.list.append(self.timerJustplayEntry)
-		self.timerTypeEntry = getConfigListEntry(_("Repeat Type"), config.timerentry.type)
+		self.timerTypeEntry = getConfigListEntry(_("Repeat Type"), self.timerentry_type)
 		self.list.append(self.timerTypeEntry)
 
-		if (config.timerentry.type.value == 0): # once
+		if self.timerentry_type.value == "once":
 			self.frequencyEntry = None
 		else: # repeated
-			self.frequencyEntry = getConfigListEntry(_("Frequency"), config.timerentry.repeated)
+			self.frequencyEntry = getConfigListEntry(_("Frequency"), self.timerentry_repeated)
 			self.list.append(self.frequencyEntry)
-			if (config.timerentry.repeated.value == 0): # daily
+			if self.timerentry_repeated.value == "daily":
 				pass
-			if (config.timerentry.repeated.value == 2): # Mon-Fri
+			if self.timerentry_repeated.value == "weekdays":
 				pass
-			if (config.timerentry.repeated.value == 1): # weekly
-				self.list.append(getConfigListEntry(_("Weekday"), config.timerentry.weekday))
-
-			if (config.timerentry.repeated.value == 3): # user defined
-				self.list.append(getConfigListEntry(_("Monday"), config.timerentry.day[0]))
-				self.list.append(getConfigListEntry(_("Tuesday"), config.timerentry.day[1]))
-				self.list.append(getConfigListEntry(_("Wednesday"), config.timerentry.day[2]))
-				self.list.append(getConfigListEntry(_("Thursday"), config.timerentry.day[3]))
-				self.list.append(getConfigListEntry(_("Friday"), config.timerentry.day[4]))
-				self.list.append(getConfigListEntry(_("Saturday"), config.timerentry.day[5]))
-				self.list.append(getConfigListEntry(_("Sunday"), config.timerentry.day[6]))
-
-			#self.list.append(getConfigListEntry("StartDate", config.timerentry.startdate))
-#		self.list.append(getConfigListEntry("Weekday", config.timerentry.weekday))
-
-		if (config.timerentry.type.value == 0): # once
-			self.list.append(getConfigListEntry(_("Start"), config.timerentry.startdate))
-			self.list.append(getConfigListEntry(" ", config.timerentry.starttime))
+			if self.timerentry_repeated.value == "weekly":
+				self.list.append(getConfigListEntry(_("Weekday"), self.timerentry_weekday))
+
+			if self.timerentry_repeated.value == "user":
+				self.list.append(getConfigListEntry(_("Monday"), self.timerentry_day[0]))
+				self.list.append(getConfigListEntry(_("Tuesday"), self.timerentry_day[1]))
+				self.list.append(getConfigListEntry(_("Wednesday"), self.timerentry_day[2]))
+				self.list.append(getConfigListEntry(_("Thursday"), self.timerentry_day[3]))
+				self.list.append(getConfigListEntry(_("Friday"), self.timerentry_day[4]))
+				self.list.append(getConfigListEntry(_("Saturday"), self.timerentry_day[5]))
+				self.list.append(getConfigListEntry(_("Sunday"), self.timerentry_day[6]))
+
+			#self.list.append(getConfigListEntry("StartDate", self.timerentry_startdate))
+#		self.list.append(getConfigListEntry("Weekday", self.timerentry_weekday))
+
+		if self.timerentry_type.value == "once":
+			self.list.append(getConfigListEntry(_("Start"), self.timerentry_startdate))
+			self.list.append(getConfigListEntry(" ", self.timerentry_starttime))
 		else:
-			self.list.append(getConfigListEntry(_("StartTime"), config.timerentry.starttime))
-		if (config.timerentry.type.value == 0): # once
-			if currentConfigSelectionElement(config.timerentry.justplay) != "zap":
-				self.list.append(getConfigListEntry(_("End"), config.timerentry.enddate))
-				self.list.append(getConfigListEntry(" ", config.timerentry.endtime))
+			self.list.append(getConfigListEntry(_("StartTime"), self.timerentry_starttime))
+
+		if self.timerentry_type.value == "once":
+			if self.timerentry_justplay.value != "zap":
+				self.list.append(getConfigListEntry(_("End"), self.timerentry_enddate))
+				self.list.append(getConfigListEntry(" ", self.timerentry_endtime))
 		else:
-			if currentConfigSelectionElement(config.timerentry.justplay) != "zap":
-				self.list.append(getConfigListEntry(_("EndTime"), config.timerentry.endtime))
+			if self.timerentry_justplay.value != "zap":
+				self.list.append(getConfigListEntry(_("EndTime"), self.timerentry_endtime))
 
-		if currentConfigSelectionElement(config.timerentry.justplay) != "zap":
-			self.list.append(getConfigListEntry(_("After event"), config.timerentry.afterevent))
+		if self.timerentry_justplay.value != "zap":
+			self.list.append(getConfigListEntry(_("After event"), self.timerentry_afterevent))
 
-		self.channelEntry = getConfigListEntry(_("Channel"), config.timerentry.service)
+		self.channelEntry = getConfigListEntry(_("Channel"), self.timerentry_service)
 		self.list.append(self.channelEntry)
 
 		self[widget].list = self.list
@@ -210,15 +186,12 @@ class TimerEntry(Screen):
 			self.createSetup("config")
 
 	def keyLeft(self):
-		if self["config"].getCurrent() == self.channelEntry:
+		if self["config"].getCurrent() is self.channelEntry:
 			self.keySelect()
 		else:
-			self["config"].handleKey(config.key["prevElement"])
+			ConfigListScreen.keyLeft(self)
 			self.newConfig()
 
-	def keyDelete(self):
-		self["config"].handleKey(config.key["delete"])
-			
 	def keyRightCallback(self, configPath):
 		currentConfigPath = self["config"].getCurrent()[1].parent.getConfigPath()
 		# check if we are still on the same config entry
@@ -226,10 +199,10 @@ class TimerEntry(Screen):
 			self.keyRight()
 
 	def keyRight(self):
-		if self["config"].getCurrent() == self.channelEntry:
+		if self["config"].getCurrent() is self.channelEntry:
 			self.keySelect()
 		else:
-			self["config"].handleKey(config.key["nextElement"])
+			ConfigListScreen.keyRight(self)
 			self.newConfig()
 		
 	def keySelect(self):
@@ -241,25 +214,20 @@ class TimerEntry(Screen):
 	def finishedChannelSelection(self, *args):
 		if len(args):
 			self.timer.service_ref = ServiceReference(args[0])
-			config.timerentry.service.vals = (str(self.timer.service_ref.getServiceName()),)
-			self["config"].invalidate(config.timerentry.service)
-
-	def keyNumberGlobal(self, number):
-		print "You pressed number " + str(number)
-		if (self["config"].getCurrent()[1].parent.enabled == True):
-			self["config"].handleKey(config.key[str(number)])
+			self.timerentry_service.vals = (str(self.timer.service_ref.getServiceName()),)
+			self["config"].invalidate(self.timerentry_service)
 
 	def getTimestamp(self, date, mytime):
 		d = time.localtime(date)
 		dt = datetime.datetime(d.tm_year, d.tm_mon, d.tm_mday, mytime[0], mytime[1])
-		return int(mktime(dt.timetuple()))
+		return int(time.mktime(dt.timetuple()))
 
 	def getBeginEnd(self):
-		enddate = config.timerentry.enddate.value
-		endtime = config.timerentry.endtime.value
+		enddate = self.timerentry_enddate.value
+		endtime = self.timerentry_endtime.value
 		
-		startdate = config.timerentry.startdate.value
-		starttime = config.timerentry.starttime.value
+		startdate = self.timerentry_startdate.value
+		starttime = self.timerentry_starttime.value
 		
 		begin = self.getTimestamp(startdate, starttime)
 		end = self.getTimestamp(enddate, endtime)
@@ -272,32 +240,33 @@ class TimerEntry(Screen):
 		return begin, end
 
 	def keyGo(self):
-		self.timer.name = config.timerentry.name.value
-		self.timer.description = config.timerentry.description.value
-		self.timer.justplay = (currentConfigSelectionElement(config.timerentry.justplay) == "zap")
+		self.timer.name = self.timerentry_name.value
+		self.timer.description = self.timerentry_description.value
+		self.timer.justplay = self.timerentry_justplay.value == "zap"
 		self.timer.resetRepeated()
-		self.timer.afterEvent = { 0: AFTEREVENT.NONE, 1: AFTEREVENT.DEEPSTANDBY, 2: AFTEREVENT.STANDBY}[config.timerentry.afterevent.value]
+		self.timer.afterEvent = {"nothing": AFTEREVENT.NONE, "deepstandby": AFTEREVENT.DEEPSTANDBY, "standby": AFTEREVENT.STANDBY}[self.timerentry_afterevent.value]
 		
-		if (config.timerentry.type.value == 0): # once
+		if self.timerentry_type.value == "once":
 			self.timer.begin, self.timer.end = self.getBeginEnd()
-		if (config.timerentry.type.value == 1): # repeated
-			if (config.timerentry.repeated.value == 0): # daily
+		if self.timerentry_type.value == "repeated":
+			if self.timerentry_repeated.value == "daily":
 				for x in range(0,7):
 					self.timer.setRepeated(x)
 
-			if (config.timerentry.repeated.value == 1): # weekly
-				self.timer.setRepeated(config.timerentry.weekday.value)
+			if self.timerentry_repeated.value == "weekly":
+				self.timer.setRepeated(self.timerentry_weekday.index)
 				
-			if (config.timerentry.repeated.value == 2): # Mon-Fri
+			if self.timerentry_repeated.value == "weekdays":
 				for x in range(0,5):
 					self.timer.setRepeated(x)
 				
-			if (config.timerentry.repeated.value == 3): # user defined
+			if self.timerentry_repeated.value == "user":
 				for x in range(0,7):
-					if (config.timerentry.day[x].value == 0): self.timer.setRepeated(x)
+					if self.timerentry_day[x].value:
+						self.timer.setRepeated(x)
 
-			self.timer.begin = self.getTimestamp(time.time(), config.timerentry.starttime.value)
-			self.timer.end = self.getTimestamp(time.time(), config.timerentry.endtime.value)
+			self.timer.begin = self.getTimestamp(time.time(), self.timerentry_starttime.value)
+			self.timer.end = self.getTimestamp(time.time(), self.timerentry_endtime.value)
 			
 			# when a timer end is set before the start, add 1 day
 			if self.timer.end < self.timer.begin:
@@ -368,7 +337,7 @@ class TimerLog(Screen):
 	def fillLogList(self):
 		self.list = [ ]
 		for x in self.log_entries:
-			self.list.append((str(strftime("%Y-%m-%d %H-%M", localtime(x[0])) + " - " + x[2]), x))
+			self.list.append((str(time.strftime("%Y-%m-%d %H-%M", localtime(x[0])) + " - " + x[2]), x))
 	
 	def clearLog(self):		
 		self.log_entries = []
diff --git a/lib/python/Screens/TutorialWizard.py b/lib/python/Screens/TutorialWizard.py
index 3febb1af..bab07f20 100644
--- a/lib/python/Screens/TutorialWizard.py
+++ b/lib/python/Screens/TutorialWizard.py
@@ -1,12 +1,11 @@
 from Wizard import Wizard, wizardManager
 
-from Components.config import configElementBoolean, config
+from Components.config import ConfigBoolean, config
 from Components.Pixmap import *
 
 from LanguageSelection import LanguageSelection
 
-
-config.misc.firstruntutorial = configElementBoolean("config.misc.firstruntutorial", 1);
+config.misc.firstruntutorial = ConfigBoolean(default = True)
 
 class TutorialWizard(Wizard):
 	skin = """
@@ -30,7 +29,7 @@ class TutorialWizard(Wizard):
 		self["arrowup2"] = MovingPixmap()
 		
 	def markDone(self):
-		config.misc.firstruntutorial.value = 1;
+		config.misc.firstruntutorial.value = False
 		config.misc.firstruntutorial.save()
-			
-#wizardManager.registerWizard(TutorialWizard, config.misc.firstruntutorial.value)
\ No newline at end of file
+
+#wizardManager.registerWizard(TutorialWizard, config.misc.firstruntutorial.value)
diff --git a/lib/python/Screens/Volume.py b/lib/python/Screens/Volume.py
index 0c1d4cea..1205748f 100644
--- a/lib/python/Screens/Volume.py
+++ b/lib/python/Screens/Volume.py
@@ -1,13 +1,14 @@
 from Screen import Screen
 from Components.VolumeBar import VolumeBar
-        
+		
 class Volume(Screen):
-    def __init__(self, session):
-        Screen.__init__(self, session)
-        
-        self.volumeBar = VolumeBar()
-        
-        self["Volume"] = self.volumeBar
-        
-    def setValue(self, vol):
-        self.volumeBar.setValue(vol)
+	def __init__(self, session):
+		Screen.__init__(self, session)
+		
+		self.volumeBar = VolumeBar()
+		
+		self["Volume"] = self.volumeBar
+		
+	def setValue(self, vol):
+		print "setValue", vol
+		self.volumeBar.setValue(vol)