Index: /trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.cc
===================================================================
--- /trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.cc	(revision 5654)
+++ /trunk/src/lib/gui/gl_gui/glmenu/glmenu_imagescreen.cc	(revision 5655)
@@ -123,5 +123,4 @@
 void GLMenuImageScreen::setPosScale(float offsetX, float offsetY, float scaleX, float scaleY)
 {
-  printf("IMG: %f %f %f %f\n", offsetX, offsetY,offsetX, offsetY);
   this->setPosition(offsetX, offsetY);
   this->setScale(scaleX, scaleY);
@@ -145,6 +144,4 @@
 void GLMenuImageScreen::setBarPosScale(float barX, float barY, float barW, float barH)
 {
-  printf("BAR: %f %f %f %f\n", barX, barY, barW, barH);
-
   this->barX = barX;
   this->barY = barY;
Index: /trunk/src/util/loading/load_param.cc
===================================================================
--- /trunk/src/util/loading/load_param.cc	(revision 5654)
+++ /trunk/src/util/loading/load_param.cc	(revision 5655)
@@ -24,88 +24,4 @@
 
 #include <stdarg.h>
-
-/**
- * @param object The object this Parameter is loaded too.
- * @param root: the XML-element to load this option from.
- * @param paramName: The name of the parameter loaded.
- * @param paramCount: how many parameters this loading-function takes
- * @param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
- * @param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
-*/
-LoadParamBase::LoadParamBase(const TiXmlElement* root, BaseObject* object, const char* paramName,
-                             int paramCount, bool multi, const void* pointerToParam, ...)
-{
-  this->setClassID(CL_LOAD_PARAM, "LoadParam");
-  this->executor = NULL;
-
-  this->loadString = NULL;
-  this->pointerToParam = pointerToParam;
-
-  if (paramCount == 0 || this->pointerToParam != NULL)
-    this->loadString = "none";
-  else
-    {
-      if (likely(!multi))
-        this->loadString = grabParameter(root, paramName);
-      else
-        {
-          if (!strcmp(root->Value(), paramName))
-            {
-              const TiXmlNode* val = root->FirstChild();
-              if( val->ToText())
-                this->loadString = val->Value();
-            }
-        }
-    }
-
-  this->paramDesc = NULL;
-  if (LoadClassDescription::parametersDescription)
-  {
-    // locating the class
-    this->classDesc = LoadClassDescription::addClass(object->getClassName());
-
-    if ((this->paramDesc = this->classDesc->addParam(paramName)) != NULL)
-    {
-
-      this->paramDesc->paramCount = paramCount;
-      this->paramDesc->types = new int[paramCount];
-      this->paramDesc->defaultValues = new char*[paramCount];
-
-      va_list types;
-      va_start (types, pointerToParam);
-      char defaultVal[512];
-      for(int i = 0; i < paramCount; i++)
-      {
-        defaultVal[0] = '\0';
-          // parameters parsed
-        int tmpType = va_arg (types, int);
-        this->paramDesc->types[i] = tmpType;
-        switch (tmpType)
-        {
-          case MT_INT:
-            sprintf(defaultVal, "%d", va_arg(types, int));
-            break;
-/*          case MT_LONG:
-            sprintf(defaultVal, "%0.3f", va_arg(types, l_LONG_TYPE));
-            break;*/
-          case MT_FLOAT:
-            sprintf(defaultVal, "%0.3f", va_arg(types, double));
-            break;
-          case MT_STRING:
-            sprintf(defaultVal, "%s", va_arg(types, l_STRING_TYPE));
-            break;
-          case MT_EXT1:
-            sprintf(defaultVal, "");
-            break;
-        }
-        this->paramDesc->defaultValues[i] = new char[strlen(defaultVal)+1];
-        strcpy(this->paramDesc->defaultValues[i], defaultVal);
-      }
-      va_end(types);
-
-      int argCount = 0;
-    }
-  }
-}
 
 /**
@@ -116,5 +32,5 @@
  * @param executor the Executor, that executes the loading procedure.
  */
-LoadParamBase::LoadParamBase(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
+LoadParam::LoadParam(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle)
 {
   this->paramName = paramName;
@@ -147,5 +63,5 @@
  * Execution-Conditions are met, they are executed here.
  */
-LoadParamBase::~LoadParamBase()
+LoadParam::~LoadParam()
 {
   if (likely(this->executor != NULL))
@@ -168,5 +84,5 @@
  * @param ... the default values !! must be at least count parameters!!
  */
-LoadParamBase* LoadParamBase::defaultValues(unsigned int count, ...)
+LoadParam* LoadParam::defaultValues(unsigned int count, ...)
 {
   if (this == NULL)
@@ -188,5 +104,5 @@
  * @returns a pointer to itself.
 */
-LoadParamBase* LoadParamBase::describe(const char* descriptionText)
+LoadParam* LoadParam::describe(const char* descriptionText)
 {
   if (LoadClassDescription::parametersDescription && this->paramDesc && !this->paramDesc->getDescription())
@@ -215,4 +131,103 @@
 // }
 
+
+
+
+/*
+ * @param object The object this Parameter is loaded too.
+ * @param root: the XML-element to load this option from.
+ * @param paramName: The name of the parameter loaded.
+ * @param paramCount: how many parameters this loading-function takes
+ * @param multi: if false LoadParam assumes only one occurence of this parameter in root, if true it assumes multiple occurences.
+ * @param ...: the parameter information (1. Parameter, 2. Default Value for the Parameter, ...)
+*/
+/*LoadParam::LoadParam(const TiXmlElement* root, BaseObject* object, const char* paramName,
+                             int paramCount, bool multi, const void* pointerToParam, ...)
+{
+  this->setClassID(CL_LOAD_PARAM, "LoadParam");
+  this->executor = NULL;
+
+  this->loadString = NULL;
+  this->pointerToParam = pointerToParam;
+
+  if (paramCount == 0 || this->pointerToParam != NULL)
+    this->loadString = "none";
+  else
+{
+      if (likely(!multi))
+        this->loadString = grabParameter(root, paramName);
+      else
+{
+          if (!strcmp(root->Value(), paramName))
+{
+              const TiXmlNode* val = root->FirstChild();
+              if( val->ToText())
+                this->loadString = val->Value();
+}
+}
+}
+
+  this->paramDesc = NULL;
+  if (LoadClassDescription::parametersDescription)
+{
+    // locating the class
+    this->classDesc = LoadClassDescription::addClass(object->getClassName());
+
+    if ((this->paramDesc = this->classDesc->addParam(paramName)) != NULL)
+{
+
+      this->paramDesc->paramCount = paramCount;
+      this->paramDesc->types = new int[paramCount];
+      this->paramDesc->defaultValues = new char*[paramCount];
+
+      va_list types;
+      va_start (types, pointerToParam);
+      char defaultVal[512];
+      for(int i = 0; i < paramCount; i++)
+{
+        defaultVal[0] = '\0';
+          // parameters parsed
+        int tmpType = va_arg (types, int);
+        this->paramDesc->types[i] = tmpType;
+        switch (tmpType)
+{
+  case MT_INT:
+            sprintf(defaultVal, "%d", va_arg(types, int));
+            break;
+//          case MT_LONG:
+//            sprintf(defaultVal, "%0.3f", va_arg(types, l_LONG_TYPE));
+//            break;
+  case MT_FLOAT:
+            sprintf(defaultVal, "%0.3f", va_arg(types, double));
+            break;
+  case MT_STRING:
+            sprintf(defaultVal, "%s", va_arg(types, l_STRING_TYPE));
+            break;
+  case MT_EXT1:
+            sprintf(defaultVal, "");
+            break;
+}
+        this->paramDesc->defaultValues[i] = new char[strlen(defaultVal)+1];
+        strcpy(this->paramDesc->defaultValues[i], defaultVal);
+}
+      va_end(types);
+
+      int argCount = 0;
+}
+}
+}*/
+
+
+
+
+
+
+
+
+
+
+//////////////////////
+// HELPER FUNCTIONS //
+//////////////////////
 /**
  * @param root: The XML-element to grab a parameter from
Index: /trunk/src/util/loading/load_param.h
===================================================================
--- /trunk/src/util/loading/load_param.h	(revision 5654)
+++ /trunk/src/util/loading/load_param.h	(revision 5655)
@@ -46,14 +46,14 @@
  */
 #define LoadParamNEW(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), false)
+         LoadParam(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), false)
 
 #define LoadParam_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), true)
+         LoadParam(ROOT, PARAMETER_NAME, OBJECT, ExecutorObjective<CLASS>(&CLASS::FUNCTION), true)
 
 #define LoadParamXML(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
+         LoadParam(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), false)
 
 #define LoadParamXML_CYCLE(ROOT, PARAMETER_NAME, OBJECT, CLASS, FUNCTION) \
-         LoadParamBase(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
+         LoadParam(ROOT, PARAMETER_NAME, OBJECT, ExecutorXML<CLASS>(&CLASS::FUNCTION, ROOT, PARAMETER_NAME), true)
 
 
@@ -81,24 +81,19 @@
 }
 
-
-
-
 /**************************
 **** REAL DECLARATIONS ****
 **************************/
 //! abstract Base class for a Loadable parameter
-class LoadParamBase : public BaseObject
+class LoadParam : public BaseObject
 {
   public:
-    LoadParamBase(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
-    ~LoadParamBase();
+    LoadParam(const TiXmlElement* root, const char* paramName, BaseObject* object, const Executor& executor, bool inLoadCycle = false);
+    ~LoadParam();
 
-    LoadParamBase* describe(const char* descriptionText);
-    LoadParamBase* defaultValues(unsigned int count, ...);
+    LoadParam* describe(const char* descriptionText);
+    LoadParam* defaultValues(unsigned int count, ...);
 
-  protected:
-    LoadParamBase(const TiXmlElement* root, BaseObject* object, const char* paramName, int paramCount, bool multi, const void* pointerToParam, ...);
 
-  protected:
+  private:
     bool                     inLoadCycle;
     Executor*                executor;
@@ -114,176 +109,4 @@
 };
 
-
-
-/*****************************************
-**** MACROS DEFINITIONS OF LOADABLES *****
-*****************************************/
-// 0. TYPES
-/**
- * a Macro to easily implement many different Constructors for the LoadParam-Class with no argument
- */
-#define LoadParam0() \
-LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(), bool multi = false) \
-  : LoadParamBase(root, pt2Object, paramName, 0, multi, NULL) \
-{ \
-  if (loadString != NULL && root != NULL) \
-    (*pt2Object.*function)(); \
-  else \
-    PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName());\
-}
-
-// 1. TYPE
-/**
- * a Macro to easily implement many different Constructors for the LoadParam-Class with 1 argument
- * @param type1 The type of the first functionParameter
- */
-#define LoadParam1(type1) \
- LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE), \
-           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT) \
-  : LoadParamBase(root, pt2Object, paramName, 1, multi, NULL, type1##_PARAM, default1) \
-{ \
-      if (loadString != NULL && root != NULL) \
-        (*pt2Object.*function)(type1##_FUNC(loadString, default1)); \
-      else \
-        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
-}
-
-// 2. TYPES
-/**
- * a Macro to easily implement many different Constructors for the LoadParam-Class with 2 arguments
- * @param type1 The type of the first functionParameter
- * @param type2 The type of the second functionParameter
- *
- * @TODO DEFAULT VALUES HACK
- */
-#define LoadParam2(type1, type2) \
- LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE), \
-           bool multi = false,  type1##_TYPE default1 = type1##_DEFAULT,  type2##_TYPE default2 = type2##_DEFAULT) \
-  : LoadParamBase(root, pt2Object, paramName, 2, multi, NULL, type1##_PARAM, default1, type2##_PARAM, default2) \
-{ \
-      if (loadString != NULL && root != NULL) \
-{ \
-          SubString subLoads(loadString); \
-          if (subLoads.getCount() >= 1) \
-            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2)); \
-          else \
-            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
-                      paramName, pt2Object->getClassName(), 2, subLoads.getCount()); \
-} \
-      else \
-        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
-}
-
-
-// 3. TYPES
-/**
- * a Macro to easily implement many different Constructors for the LoadParam-Class with 3 arguments
- * @param type1 The type of the first functionParameter
- * @param type2 The type of the second functionParameter
- * @param type3 The type of the third functionParameter
- */
-#define LoadParam3(type1, type2, type3) \
- LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE), \
-           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT, type2##_TYPE default2 = type2##_DEFAULT, type3##_TYPE default3 = type3##_DEFAULT)\
-  : LoadParamBase(root, pt2Object, paramName, 3, multi, NULL, type1##_PARAM, default1, type2##_PARAM, default2, type3##_PARAM, default3) \
-{ \
-      if (loadString != NULL && root != NULL) \
-{ \
-          SubString subLoads(loadString); \
-          if (subLoads.getCount() == 3) \
-            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2), type3##_FUNC(subLoads.getString(2), default3)); \
-          else \
-            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
-                      paramName, pt2Object->getClassName(), 3, subLoads.getCount()); \
-} \
-      else \
-        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
-}
-
-
-// 4. TYPES
-/**
- * a Macro to easily implement many different Constructors for the LoadParam-Class with 4 arguments
- * @param type1 The type of the first functionParameter
- * @param type2 The type of the second functionParameter
- * @param type3 The type of the third functionParameter
- * @param type4 The type of the forth functionParameter
- */
-#define LoadParam4(type1, type2, type3, type4) \
- LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE), \
-           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT, type2##_TYPE default2 = type2##_DEFAULT, type3##_TYPE default3 = type3##_DEFAULT, \
-           type4##_TYPE default4 = type4##_DEFAULT) \
-  : LoadParamBase(root, pt2Object, paramName, 4, multi, NULL, type1##_PARAM, default1, type2##_PARAM, default2, type3##_PARAM, default3, \
-                  type4##_PARAM, default4) \
-{ \
-      if (loadString != NULL && root != NULL) \
-{ \
-          SubString subLoads(loadString); \
-          if (subLoads.getCount() == 4) \
-            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2), type3##_FUNC(subLoads.getString(2), default3), type4##_FUNC(subLoads.getString(3), default4)); \
-          else \
-            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
-                      paramName, pt2Object->getClassName(), 4, subLoads.getCount()); \
-} \
-      else \
-        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
-}
-
-
-// 5. TYPES
-/**
- * a Macro to easily implement many different Constructors for the LoadParam-Class with 5 arguments
- * @param type1 The type of the first functionParameter
- * @param type2 The type of the second functionParameter
- * @param type3 The type of the third functionParameter
- * @param type4 The type of the forth functionParameter
- * @param type5 The type of the fifth functionParameter
- */
-#define LoadParam5(type1, type2, type3, type4, type5) \
- LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, \
-           void(T::*function)(type1##_TYPE, type2##_TYPE, type3##_TYPE, type4##_TYPE, type5##_TYPE), \
-           bool multi = false, type1##_TYPE default1 = type1##_DEFAULT, type2##_TYPE default2 = type2##_DEFAULT, type3##_TYPE default3 = type3##_DEFAULT, \
-           type4##_TYPE default4 = type4##_DEFAULT, type5##_TYPE default5 = type5##_DEFAULT ) \
-  : LoadParamBase(root, pt2Object, paramName, 5, multi, NULL, type1##_PARAM, default1, type2##_PARAM, default2, type3##_PARAM, default3, \
-                  type4##_PARAM, default4, type5##_PARAM, default5) \
-{ \
-      if (loadString != NULL && root != NULL) \
-{ \
-          SubString subLoads(loadString); \
-          if (subLoads.getCount() == 5) \
-            (*pt2Object.*function)(type1##_FUNC(subLoads.getString(0), default1), type2##_FUNC(subLoads.getString(1), default2), type3##_FUNC(subLoads.getString(2), default3), type4##_FUNC(subLoads.getString(3), default4), type5##_FUNC(subLoads.getString(4), default5)); \
-          else \
-            PRINTF(2)("Not loaded Parameter %s of %s, because wrong count of arguments.\n -> Should have %d but have %d\n", \
-                      paramName, pt2Object->getClassName(), 5, subLoads.getCount()); \
-} \
-      else \
-        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
-}
-
-// Pointer TYPE
-/**
- * a Macro to easily implement many different Constructors for the LoadParam-Class with one Pointer argument
- * @param type1 The type of the Pointer
- */
-#define LoadParamPT(type1) \
- LoadParam(const TiXmlElement* root, const char* paramName, T* pt2Object, void(T::*function)(type1##_TYPE), type1##_TYPE pointerToParam, bool multi = false) \
-  : LoadParamBase(root, pt2Object, paramName, 1, multi, pointerToParam, type1##_PARAM) \
-{ \
-      if (pointerToParam != NULL && root != NULL) \
-        (*pt2Object.*function)((type1##_TYPE) pointerToParam); \
-      else \
-        PRINTF(4)("Not loaded parameter %s of %s\n", paramName, pt2Object->getClassName()); \
-}
-
-//! derived template class, so all the Classes can load something.
-template<class T> class LoadParam : public LoadParamBase
-{
-  public:
-
-#define FUNCTOR_LIST(x)    LoadParam ## x
-#include "functor_list.h"
-#undef FUNCTOR_LIST
-};
-
 // helper function
 
Index: /trunk/src/util/loading/load_param_description.h
===================================================================
--- /trunk/src/util/loading/load_param_description.h	(revision 5654)
+++ /trunk/src/util/loading/load_param_description.h	(revision 5655)
@@ -34,5 +34,5 @@
 class LoadParamDescription
 {
-  friend class LoadParamBase;
+  friend class LoadParam;
   friend class LoadClassDescription;
  public:
@@ -56,5 +56,5 @@
 class LoadClassDescription
 {
-  friend class LoadParamBase;
+  friend class LoadParam;
  public:
   LoadClassDescription(const char* className);
