Index: trunk/src/lib/util/executor/executor.cc
===================================================================
--- trunk/src/lib/util/executor/executor.cc	(revision 8711)
+++ trunk/src/lib/util/executor/executor.cc	(revision 8894)
@@ -31,5 +31,7 @@
                    const MultiType& param2,
                    const MultiType& param3,
-                   const MultiType& param4)
+                   const MultiType& param4,
+                   const MultiType& param5,
+                   const MultiType& param6)
 {
   this->setClassID(CL_EXECUTOR, "Executor");
@@ -41,4 +43,6 @@
   this->defaultValue[3] = param3;
   this->defaultValue[4] = param4;
+  this->defaultValue[5] = param5;
+  this->defaultValue[6] = param6;
 
   this->paramCount = 0;
@@ -83,5 +87,7 @@
                                   const MultiType& value2,
                                   const MultiType& value3,
-                                  const MultiType& value4)
+                                  const MultiType& value4,
+                                  const MultiType& value5,
+                                  const MultiType& value6)
 {
   if (this == NULL)
@@ -94,5 +100,6 @@
   value[3] = &value3;
   value[4] = &value4;
-
+  value[5] = &value5;
+  value[6] = &value6;
   for (unsigned int i = 0; i < this->paramCount; i++)
   {
Index: trunk/src/lib/util/executor/executor.h
===================================================================
--- trunk/src/lib/util/executor/executor.h	(revision 8711)
+++ trunk/src/lib/util/executor/executor.h	(revision 8894)
@@ -47,5 +47,6 @@
     Executor* defaultValues(const MultiType& value0 = MT_NULL, const MultiType& value1 = MT_NULL,
                             const MultiType& value2 = MT_NULL, const MultiType& value3 = MT_NULL,
-                            const MultiType& value4 = MT_NULL);
+                            const MultiType& value4 = MT_NULL, const MultiType& param5 = MT_NULL,
+                            const MultiType& param6 = MT_NULL);
     /** @param i the i'th defaultValue, @returns reference to the MultiType */
     inline MultiType& getDefaultValue(unsigned int i) { return defaultValue[i]; };
@@ -68,5 +69,6 @@
     Executor(const MultiType& param0 = MT_NULL, const MultiType& param1 = MT_NULL,
              const MultiType& param2 = MT_NULL, const MultiType& param3 = MT_NULL,
-             const MultiType& param4 = MT_NULL);
+             const MultiType& param4 = MT_NULL, const MultiType& param5 = MT_NULL,
+             const MultiType& param6 = MT_NULL);
 
     void cloning(Executor* executor) const;
@@ -75,5 +77,5 @@
     short                       functorType;      //!< The type of Function we've got (either static or objective).
     unsigned int                paramCount;       //!< the count of parameters.
-    MultiType                   defaultValue[5];  //!< Default Values.
+    MultiType                   defaultValue[7];  //!< Default Values.
 };
 
Index: trunk/src/lib/util/executor/executor_functional.cc
===================================================================
--- trunk/src/lib/util/executor/executor_functional.cc	(revision 8711)
+++ trunk/src/lib/util/executor/executor_functional.cc	(revision 8894)
@@ -15,5 +15,5 @@
 
 #include "executor.h"
-std::string ExecutorFunctional_returningString_from[5];
+std::string ExecutorFunctional_returningString_from[7];
 
 
Index: trunk/src/lib/util/executor/executor_lua.cc
===================================================================
--- trunk/src/lib/util/executor/executor_lua.cc	(revision 8711)
+++ trunk/src/lib/util/executor/executor_lua.cc	(revision 8894)
@@ -20,5 +20,5 @@
 #include "lunar.h"
 
-std::string temp[5];
+std::string temp[7];
 
 template<typename type> type fromLua(lua_State* state, int index) { type *obj = Lunar<type>::check(state, 1); lua_remove(state, 1); return obj;};
Index: trunk/src/lib/util/executor/executor_lua.h
===================================================================
--- trunk/src/lib/util/executor/executor_lua.h	(revision 8711)
+++ trunk/src/lib/util/executor/executor_lua.h	(revision 8894)
@@ -233,4 +233,54 @@
 
 
+///////////
+//// 4 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4 : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua4(void(T::*function)(type0, type1, type2, type3))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 0;
+
+      (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4) );
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua4<T, type0, type1, type2, type3>(this->functionPointer);
+    }
+  private:
+    void          (T::*functionPointer)(type0, type1, type2, type3);
+};
 
 
@@ -388,3 +438,271 @@
 };
 
+
+///////////
+//// 3 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2> class ExecutorLua3ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua3ret(ret (T::*function)(type0, type1, type2))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua3ret<T, ret, type0, type1, type2>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2);
+};
+
+
+///////////
+//// 4 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3> class ExecutorLua4ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua4ret(ret (T::*function)(type0, type1, type2, type3))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua4ret<T, ret, type0, type1, type2, type3>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2, type3);
+};
+
+///////////
+//// 5 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4> class ExecutorLua5ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua5ret(ret (T::*function)(type0, type1, type2, type3, type4))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(), ExecutorParamType<type2>(), ExecutorParamType<type3>(), ExecutorParamType<type4>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4),
+          fromLua<type4>(state, 5) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua5ret<T, ret, type0, type1, type2, type3, type4>(this->functionPointer);
+    }
+  private:
+    ret          (T::*functionPointer)(type0, type1, type2, type3, type4);
+};
+
+///////////
+//// 6 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5> class ExecutorLua6ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua6ret(ret (T::*function)(type0, type1, type2, type3, type4, type5))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
+             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
+             ExecutorParamType<type4>(), ExecutorParamType<type5>())
+    {
+      this->functionPointer = function;
+      this->functorType = Executor_Objective | Executor_NoLoadString;
+    }
+
+    /**
+     * @brief executes the Command on BaseObject
+     * @param object the BaseObject to execute this Executor on
+     * @param loadString ignored in this case
+     */
+    virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+    {
+      PRINTF(1)("no usefull executor\n");
+    }
+
+    virtual void operator()(BaseObject* object, int& count, void* values) const
+    {
+      lua_State* state = (lua_State*)values;
+      count = 1;
+
+      toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+          fromLua<type0>(state, 1),
+          fromLua<type1>(state, 2),
+          fromLua<type2>(state, 3),
+          fromLua<type3>(state, 4),
+          fromLua<type4>(state, 5),
+          fromLua<type5>(state, 6) ));
+    }
+
+    /**
+     * @returns a _new_ Copy of this Executor
+     */
+    virtual Executor* clone () const
+    {
+      return new ExecutorLua6ret<T, ret, type0, type1, type2, type3, type4, type5>(this->functionPointer);
+    }
+  private:
+    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5);
+};
+
+///////////
+//// 7 ////
+///////////
+//! Executes a Function with a lua_State* parameter.
+template<class T, typename ret, typename type0, typename type1, typename type2, typename type3, typename type4, typename type5, typename type6> class ExecutorLua7ret : public Executor
+{
+  public:
+    /**
+   * @brief Constructor of a ExecutorXML
+   * @param function a Function to call
+     */
+    ExecutorLua7ret(ret (T::*function)(type0, type1, type2, type3, type4, type5, type6))
+  : Executor(ExecutorParamType<type0>(), ExecutorParamType<type1>(),
+             ExecutorParamType<type2>(), ExecutorParamType<type3>(),
+             ExecutorParamType<type4>(), ExecutorParamType<type5>(),
+             ExecutorParamType<type6>())
+             {
+               this->functionPointer = function;
+               this->functorType = Executor_Objective | Executor_NoLoadString;
+             }
+
+    /**
+              * @brief executes the Command on BaseObject
+              * @param object the BaseObject to execute this Executor on
+              * @param loadString ignored in this case
+     */
+             virtual void operator()(BaseObject* object, const SubString& = SubString()) const
+             {
+               PRINTF(1)("no usefull executor\n");
+             }
+
+             virtual void operator()(BaseObject* object, int& count, void* values) const
+             {
+               lua_State* state = (lua_State*)values;
+               count = 1;
+
+               toLua<ret>(state, (dynamic_cast<T*>(object)->*(functionPointer))(
+                   fromLua<type0>(state, 1),
+                   fromLua<type1>(state, 2),
+                   fromLua<type2>(state, 3),
+                   fromLua<type3>(state, 4),
+                   fromLua<type4>(state, 5),
+                   fromLua<type5>(state, 6),
+                   fromLua<type6>(state, 7) ));
+             }
+
+    /**
+              * @returns a _new_ Copy of this Executor
+     */
+             virtual Executor* clone () const
+             {
+               return new ExecutorLua7ret<T, ret, type0, type1, type2, type3, type4, type5, type6>(this->functionPointer);
+             }
+  private:
+    ret           (T::*functionPointer)(type0, type1, type2, type3, type4, type5, type6);
+};
+
+
 #endif /* _EXECUTOR_LUA_H */
Index: trunk/src/lib/util/executor/functor_list.h
===================================================================
--- trunk/src/lib/util/executor/functor_list.h	(revision 8711)
+++ trunk/src/lib/util/executor/functor_list.h	(revision 8894)
@@ -29,5 +29,5 @@
 
 //! defines the maximum count of arguments function pointers might have
-#define FUNCTOR_MAX_ARGUMENTS                5
+#define FUNCTOR_MAX_ARGUMENTS                7
 #include "multi_type.h"
 
