Index: code/branches/core/src/orxonox/core/BaseObject.cc
===================================================================
--- code/branches/core/src/orxonox/core/BaseObject.cc	(revision 845)
+++ code/branches/core/src/orxonox/core/BaseObject.cc	(revision 847)
@@ -34,4 +34,5 @@
 
 #include "BaseObject.h"
+#include "XMLPort.h"
 
 namespace orxonox
@@ -46,4 +47,6 @@
         RegisterRootObject(BaseObject);
 
+        this->bActive_ = true;
+        this->bVisible_ = true;
         this->level_ = 0;
     }
@@ -75,5 +78,5 @@
     Element& BaseObject::XMLPort(Element& xmlelement, bool loading)
     {
-//        XMLPortParam(BaseObject, "name", setName, getName, xmlelement, loading);
+        XMLPortParam(BaseObject, "name", setName, getName, xmlelement, loading);
 
         return xmlelement;
Index: code/branches/core/src/orxonox/core/BaseObject.h
===================================================================
--- code/branches/core/src/orxonox/core/BaseObject.h	(revision 845)
+++ code/branches/core/src/orxonox/core/BaseObject.h	(revision 847)
@@ -52,8 +52,34 @@
             virtual Element& XMLPort(Element& xmlelement, bool loading);
 
+            /** @brief Sets the name of the object. @param name The name */
+            inline void setName(const std::string& name) { this->name_ = name; this->changedName(); }
+            /** @brief Returns the name of the object. @return The name */
+            inline const std::string& getName() const { return this->name_; }
+            /** @brief This function gets called if the name of the object changes. */
+            virtual void changedName() {}
+
+            /** @brief Sets the state of the objects activity. @param bActive True = active */
+            inline void setActivity(bool bActive) { this->bActive_ = bActive; this->changedActivity(); }
+            /** @brief Returns the state of the objects activity. @return The state of the activity */
+            inline const bool isActive() const { return this->bActive_; }
+            /** @brief This function gets called if the activity of the object changes. */
+            virtual void changedActivity() {}
+
+            /** @brief Sets the state of the objects visibility. @param bVisible True = visible */
+            inline void setVisibility(bool bVisible) { this->bVisible_ = bVisible; this->changedVisibility(); }
+            /** @brief Returns the state of the objects visibility. @return The state of the visibility */
+            inline const bool isVisible() const { return this->bVisible_; }
+            /** @brief This function gets called if the visibility of the object changes. */
+            virtual void changedVisibility() {}
+
+            /** @brief Sets a pointer to the level that loaded this object. @param level The pointer to the level */
+            inline void setLevel(const Level* level) { this->level_ = level; }
             /** @brief Returns a pointer to the level that loaded this object. @return The level */
             inline const Level* getLevel() const { return this->level_; }
 
         private:
+            std::string name_;                          //!< The name of the object
+            bool bActive_;                              //!< True = the object is active
+            bool bVisible_;                             //!< True = the object is visible
             const Level* level_;                        //!< The level that loaded this object
     };
Index: code/branches/core/src/orxonox/core/CMakeLists.txt
===================================================================
--- code/branches/core/src/orxonox/core/CMakeLists.txt	(revision 845)
+++ code/branches/core/src/orxonox/core/CMakeLists.txt	(revision 847)
@@ -15,4 +15,6 @@
   ClassTreeMask.cc
   Loader.cc
+  Executor.cc
+  XMLPort.cc
 )
 
Index: code/branches/core/src/orxonox/core/ConfigValueContainer.cc
===================================================================
--- code/branches/core/src/orxonox/core/ConfigValueContainer.cc	(revision 845)
+++ code/branches/core/src/orxonox/core/ConfigValueContainer.cc	(revision 847)
@@ -957,5 +957,5 @@
         @return The description
     */
-    std::string ConfigValueContainer::getDescription() const
+    const std::string& ConfigValueContainer::getDescription() const
     {
         return GetLocalisation(this->description_);
Index: code/branches/core/src/orxonox/core/ConfigValueContainer.h
===================================================================
--- code/branches/core/src/orxonox/core/ConfigValueContainer.h	(revision 845)
+++ code/branches/core/src/orxonox/core/ConfigValueContainer.h	(revision 847)
@@ -100,5 +100,5 @@
 
             void description(const std::string& description);
-            std::string getDescription() const;
+            const std::string& getDescription() const;
 
             bool parseString(const std::string& input, MultiTypeMath& defvalue);
Index: code/branches/core/src/orxonox/core/CoreIncludes.h
===================================================================
--- code/branches/core/src/orxonox/core/CoreIncludes.h	(revision 845)
+++ code/branches/core/src/orxonox/core/CoreIncludes.h	(revision 847)
@@ -121,5 +121,5 @@
     { \
         container##varname = new orxonox::ConfigValueContainer(this->getIdentifier()->getName(), #varname, varname = defvalue); \
-        this->getIdentifier()->setConfigValueContainer(#varname, container##varname); \
+        this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
     } \
     container##varname->getValue(&varname)
Index: code/branches/core/src/orxonox/core/CorePrereqs.h
===================================================================
--- code/branches/core/src/orxonox/core/CorePrereqs.h	(revision 845)
+++ code/branches/core/src/orxonox/core/CorePrereqs.h	(revision 847)
@@ -82,4 +82,5 @@
   class DebugLevel;
   class Error;
+  class Executor;
   class Factory;
   class Identifier;
@@ -102,4 +103,7 @@
   template <class T>
   class SubclassIdentifier;
+  class XMLPortParamContainer;
+  template <class T>
+  class XMLPortClassParamContainer;
 }
 
Index: code/branches/core/src/orxonox/core/Executor.cc
===================================================================
--- code/branches/core/src/orxonox/core/Executor.cc	(revision 847)
+++ code/branches/core/src/orxonox/core/Executor.cc	(revision 847)
@@ -0,0 +1,118 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: Executor by Benjamin Grauer
+ */
+
+#include "Executor.h"
+#include "Language.h"
+#include "util/String.h"
+
+namespace orxonox
+{
+    Executor::Executor(Functor* functor, const std::string& name)
+    {
+        this->functor_ = functor;
+        this->name_ = name;
+        this->bAddedDescription_ = false;
+        this->bAddedDescriptionReturnvalue_ = false;
+        this->bAddedDescriptionParam_[0] = false;
+        this->bAddedDescriptionParam_[1] = false;
+        this->bAddedDescriptionParam_[2] = false;
+        this->bAddedDescriptionParam_[3] = false;
+        this->bAddedDescriptionParam_[4] = false;
+    }
+
+    Executor::~Executor()
+    {
+    }
+
+    void Executor::setName(const std::string name)
+    {
+        this->name_ = name;
+    }
+
+    const std::string& Executor::getName() const
+    {
+        return this->name_;
+    }
+
+    void Executor::description(const std::string& description)
+    {
+        if (!this->bAddedDescription_)
+        {
+            this->description_ = std::string("ExecutorDescription::" + this->name_ + "::function");
+            AddLanguageEntry(this->description_, description);
+            this->bAddedDescription_ = true;
+        }
+    }
+
+    const std::string& Executor::getDescription() const
+    {
+        return GetLocalisation(this->description_);
+    }
+
+    void Executor::descriptionParam(int param, const std::string& description)
+    {
+        if (param > 0 && param <= 5)
+        {
+            if (!this->bAddedDescriptionParam_[param])
+            {
+                std::string paramnumber;
+                if (!Convert::ToString(&paramnumber, param))
+                    return;
+
+                this->descriptionParam_[param] = std::string("ExecutorDescription::" + this->name_ + "::param" + paramnumber);
+                AddLanguageEntry(this->descriptionParam_[param], description);
+                this->bAddedDescriptionParam_[param] = true;
+            }
+        }
+    }
+
+    const std::string& Executor::getDescriptionParam(int param) const
+    {
+        if (param > 0 && param <= 5)
+        {
+            return GetLocalisation(this->descriptionParam_[param]);
+        }
+
+        return this->descriptionParam_[0];
+    }
+
+    void Executor::descriptionReturnvalue(const std::string& description)
+    {
+        if (!this->bAddedDescriptionReturnvalue_)
+        {
+            this->descriptionReturnvalue_ = std::string("ExecutorDescription::" + this->name_ + "::returnvalue");
+            AddLanguageEntry(this->descriptionReturnvalue_, description);
+            this->bAddedDescriptionReturnvalue_ = true;
+        }
+    }
+
+    const std::string& Executor::getDescriptionReturnvalue(int param) const
+    {
+        return GetLocalisation(this->descriptionReturnvalue_);
+    }
+}
Index: code/branches/core/src/orxonox/core/Executor.h
===================================================================
--- code/branches/core/src/orxonox/core/Executor.h	(revision 847)
+++ code/branches/core/src/orxonox/core/Executor.h	(revision 847)
@@ -0,0 +1,117 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: Executor by Benjamin Grauer
+ */
+
+#ifndef _Executor_H__
+#define _Executor_H__
+
+#include "CorePrereqs.h"
+#include "Functor.h"
+
+namespace orxonox
+{
+    class _CoreExport Executor
+    {
+        public:
+            Executor(Functor* functor, const std::string& name = "");
+            virtual ~Executor();
+
+            inline virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+                { (*this->functor_)(param1, param2, param3, param4, param5); }
+
+            void setName(const std::string name);
+            const std::string& getName() const;
+
+            void description(const std::string& description);
+            const std::string& getDescription() const;
+
+            void descriptionParam(int param, const std::string& description);
+            const std::string& getDescriptionParam(int param) const;
+
+            void descriptionReturnvalue(const std::string& description);
+            const std::string& getDescriptionReturnvalue(int param) const;
+
+            inline int getParamCount() const
+                { return this->functor_->getParamCount(); }
+            inline bool hasReturnvalue() const
+                { return this->functor_->hasReturnvalue(); }
+            inline FunctionType getType() const
+                { return this->functor_->getType(); }
+            inline MultiTypeMath getReturnvalue() const
+                { return this->functor_->getReturnvalue(); }
+            inline std::string getTypenameParam(int param) const
+                { return this->functor_->getTypenameParam(param); }
+            inline std::string getTypenameReturnvalue() const
+                { return this->functor_->getTypenameReturnvalue(); }
+
+        protected:
+            Functor* functor_;
+
+        private:
+            std::string name_;
+
+            LanguageEntryLabel description_;
+            LanguageEntryLabel descriptionReturnvalue_;
+            LanguageEntryLabel descriptionParam_[5];
+
+            bool bAddedDescription_;
+            bool bAddedDescriptionReturnvalue_;
+            bool bAddedDescriptionParam_[5];
+    };
+
+    class _CoreExport ExecutorStatic : public Executor
+    {
+        public:
+            ExecutorStatic(FunctorStatic* functor, const std::string& name = "") : Executor(functor, name) {}
+            virtual ~ExecutorStatic() {}
+
+            inline virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+                { (*this->functor_)(param1, param2, param3, param4, param5); }
+    };
+
+    template <class T>
+    class ExecutorMember : public Executor
+    {
+        public:
+            ExecutorMember(FunctorMember<T>* functor, const std::string& name = "") : Executor(functor, name) {}
+            virtual ~ExecutorMember() {}
+
+            inline virtual void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+                { (*this->functor_)(object, param1, param2, param3, param4, param5); }
+            inline virtual void operator()(const T* object, const MultiTypeMath param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+                { (*this->functor_)(object, param1, param2, param3, param4, param5); }
+            inline virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+                { (*this->functor_)(param1, param2, param3, param4, param5); }
+
+            inline void setObject(T* object)
+                { this->functor_->setObject(object); }
+            inline void setObject(const T* object)
+                { this->functor_->setObject(object); }
+    };
+}
+
+#endif /* _Executor_H__ */
Index: code/branches/core/src/orxonox/core/Functor.h
===================================================================
--- code/branches/core/src/orxonox/core/Functor.h	(revision 847)
+++ code/branches/core/src/orxonox/core/Functor.h	(revision 847)
@@ -0,0 +1,417 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ *   Inspiration: Functor by Benjamin Grauer
+ */
+
+#ifndef _Functor_H__
+#define _Functor_H__
+
+#include "util/MultiTypeMath.h"
+#include "Debug.h"
+
+#include "CorePrereqs.h"
+
+
+enum FunctionType
+{
+    FT_MEMBER,
+    FT_CONSTMEMBER,
+    FT_STATIC
+};
+
+
+template <class T>
+inline std::string typeToString();
+
+#define CreateTypeToStringTemplate(type) \
+    template <> \
+    inline std::string typeToString<type>() { return #type; }
+
+CreateTypeToStringTemplate(int);
+CreateTypeToStringTemplate(unsigned int);
+CreateTypeToStringTemplate(char);
+CreateTypeToStringTemplate(unsigned char);
+CreateTypeToStringTemplate(short);
+CreateTypeToStringTemplate(unsigned short);
+CreateTypeToStringTemplate(long);
+CreateTypeToStringTemplate(unsigned long);
+CreateTypeToStringTemplate(float);
+CreateTypeToStringTemplate(double);
+CreateTypeToStringTemplate(long double);
+CreateTypeToStringTemplate(bool);
+CreateTypeToStringTemplate(std::string);
+CreateTypeToStringTemplate(orxonox::Vector2);
+CreateTypeToStringTemplate(orxonox::Vector3);
+CreateTypeToStringTemplate(orxonox::Quaternion);
+CreateTypeToStringTemplate(orxonox::ColourValue);
+CreateTypeToStringTemplate(orxonox::Radian);
+CreateTypeToStringTemplate(orxonox::Degree);
+
+
+class _CoreExport Functor
+{
+    public:
+        Functor() {}
+        virtual ~Functor() {}
+
+        virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+
+        inline int getParamCount() const { return this->numParams_; }
+        inline bool hasReturnvalue() const { return this->hasReturnValue_; }
+        inline FunctionType getType() const { return this->type_; }
+        inline MultiTypeMath getReturnvalue() const { return this->returnedValue_; }
+
+        std::string getTypenameParam(int param) const { return (param > 0 && param <= 5) ? this->typeParam_[param-1] : ""; }
+        std::string getTypenameReturnvalue() const { return this->typeReturnvalue_; }
+
+    protected:
+        int numParams_;
+        bool hasReturnValue_;
+        FunctionType type_;
+        MultiTypeMath returnedValue_;
+
+        std::string typeReturnvalue_;
+        std::string typeParam_[5];
+};
+
+class _CoreExport FunctorStatic : public Functor
+{
+    public:
+        virtual ~FunctorStatic() {}
+        virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+};
+
+template <class T>
+class FunctorMember : public Functor
+{
+    public:
+        FunctorMember()
+        {
+            constObject_ = 0;
+            object_ = 0;
+            bConstObject_ = false;
+        }
+        virtual ~FunctorMember() {}
+
+        virtual void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+        virtual void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+
+        virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+        {
+            if (this->bConstObject_)
+            {
+                if (this->constObject_)
+                    (*this)(this->constObject_, param1, param2, param3, param4, param5);
+                else
+                {
+                    COUT(1) << "An error occurred in Functor.h:" << std::endl;
+                    COUT(1) << "Error: No const object set." << std::endl;
+                }
+            }
+            else
+            {
+                if (this->object_)
+                    (*this)(this->object_, param1, param2, param3, param4, param5);
+                else
+                {
+                    COUT(1) << "An error occurred in Functor.h:" << std::endl;
+                    COUT(1) << "Error: No object set." << std::endl;
+                }
+            }
+        }
+
+        void setObject(T* object)
+        {
+            this->bConstObject_ = false;
+            this->object_ = object;
+        }
+
+        void setObject(const T* object)
+        {
+            this->bConstObject_ = true;
+            this->constObject_ = object;
+        }
+
+    private:
+        const T* constObject_;
+        T* object_;
+        bool bConstObject_;
+};
+
+
+
+#define MAKE_COMMA(x) MAKE_COMMA##x
+#define MAKE_COMMA0
+#define MAKE_COMMA1 ,
+#define MAKE_COMMA2 ,
+#define MAKE_COMMA3 ,
+#define MAKE_COMMA4 ,
+#define MAKE_COMMA5 ,
+
+
+
+#define FUNCTOR_TEMPLATE(ismember, returnvalue, numparams) FUNCTOR_TEMPLATE##ismember##returnvalue##numparams
+#define FUNCTOR_TEMPLATE000
+#define FUNCTOR_TEMPLATE001 template <class P1>
+#define FUNCTOR_TEMPLATE002 template <class P1, class P2>
+#define FUNCTOR_TEMPLATE003 template <class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE004 template <class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE005 template <class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE010 template <class R>
+#define FUNCTOR_TEMPLATE011 template <class R, class P1>
+#define FUNCTOR_TEMPLATE012 template <class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE013 template <class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE014 template <class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE015 template <class R, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE100 template <class T>
+#define FUNCTOR_TEMPLATE101 template <class T, class P1>
+#define FUNCTOR_TEMPLATE102 template <class T, class P1, class P2>
+#define FUNCTOR_TEMPLATE103 template <class T, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE104 template <class T, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE105 template <class T, class P1, class P2, class P3, class P4, class P5>
+#define FUNCTOR_TEMPLATE110 template <class T, class R>
+#define FUNCTOR_TEMPLATE111 template <class T, class R, class P1>
+#define FUNCTOR_TEMPLATE112 template <class T, class R, class P1, class P2>
+#define FUNCTOR_TEMPLATE113 template <class T, class R, class P1, class P2, class P3>
+#define FUNCTOR_TEMPLATE114 template <class T, class R, class P1, class P2, class P3, class P4>
+#define FUNCTOR_TEMPLATE115 template <class T, class R, class P1, class P2, class P3, class P4, class P5>
+
+
+
+#define FUNCTOR_TEMPLATE_CLASSES(ismember, returnvalue, numparams) FUNCTOR_TEMPLATE_CLASSES##ismember##returnvalue##numparams
+#define FUNCTOR_TEMPLATE_CLASSES000
+#define FUNCTOR_TEMPLATE_CLASSES001 <P1>
+#define FUNCTOR_TEMPLATE_CLASSES002 <P1, P2>
+#define FUNCTOR_TEMPLATE_CLASSES003 <P1, P2, P3>
+#define FUNCTOR_TEMPLATE_CLASSES004 <P1, P2, P3, P4>
+#define FUNCTOR_TEMPLATE_CLASSES005 <P1, P2, P3, P4, P5>
+#define FUNCTOR_TEMPLATE_CLASSES010 <R>
+#define FUNCTOR_TEMPLATE_CLASSES011 <R, P1>
+#define FUNCTOR_TEMPLATE_CLASSES012 <R, P1, P2>
+#define FUNCTOR_TEMPLATE_CLASSES013 <R, P1, P2, P3>
+#define FUNCTOR_TEMPLATE_CLASSES014 <R, P1, P2, P3, P4>
+#define FUNCTOR_TEMPLATE_CLASSES015 <R, P1, P2, P3, P4, P5>
+#define FUNCTOR_TEMPLATE_CLASSES100 <T>
+#define FUNCTOR_TEMPLATE_CLASSES101 <T, P1>
+#define FUNCTOR_TEMPLATE_CLASSES102 <T, P1, P2>
+#define FUNCTOR_TEMPLATE_CLASSES103 <T, P1, P2, P3>
+#define FUNCTOR_TEMPLATE_CLASSES104 <T, P1, P2, P3, P4>
+#define FUNCTOR_TEMPLATE_CLASSES105 <T, P1, P2, P3, P4, P5>
+#define FUNCTOR_TEMPLATE_CLASSES110 <T, R>
+#define FUNCTOR_TEMPLATE_CLASSES111 <T, R, P1>
+#define FUNCTOR_TEMPLATE_CLASSES112 <T, R, P1, P2>
+#define FUNCTOR_TEMPLATE_CLASSES113 <T, R, P1, P2, P3>
+#define FUNCTOR_TEMPLATE_CLASSES114 <T, R, P1, P2, P3, P4>
+#define FUNCTOR_TEMPLATE_CLASSES115 <T, R, P1, P2, P3, P4, P5>
+
+
+
+#define FUNCTOR_TYPENAME_PARAMS(numparams) FUNCTOR_TYPENAME_PARAMS##numparams
+#define FUNCTOR_TYPENAME_PARAMS0
+#define FUNCTOR_TYPENAME_PARAMS1 this->typeParam_[0] = typeToString<P1>();
+#define FUNCTOR_TYPENAME_PARAMS2 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>();
+#define FUNCTOR_TYPENAME_PARAMS3 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>(); this->typeParam_[2] = typeToString<P3>();
+#define FUNCTOR_TYPENAME_PARAMS4 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>(); this->typeParam_[2] = typeToString<P3>(); this->typeParam_[3] = typeToString<P4>();
+#define FUNCTOR_TYPENAME_PARAMS5 this->typeParam_[0] = typeToString<P1>(); this->typeParam_[1] = typeToString<P2>(); this->typeParam_[2] = typeToString<P3>(); this->typeParam_[3] = typeToString<P4>(); this->typeParam_[4] = typeToString<P5>();
+
+#define FUNCTOR_TYPENAME_RETURN(returnvalue) FUNCTOR_TYPENAME_RETURN##returnvalue
+#define FUNCTOR_TYPENAME_RETURN0
+#define FUNCTOR_TYPENAME_RETURN1 this->typeReturnvalue_ = typeToString<R>();
+
+
+
+#define FUNCTOR_FUNCTION_PARAMS(numparams) FUNCTOR_FUNCTION_PARAMS##numparams
+#define FUNCTOR_FUNCTION_PARAMS0
+#define FUNCTOR_FUNCTION_PARAMS1 P1 param1
+#define FUNCTOR_FUNCTION_PARAMS2 P1 param1, P2 param2
+#define FUNCTOR_FUNCTION_PARAMS3 P1 param1, P2 param2, P3 param3
+#define FUNCTOR_FUNCTION_PARAMS4 P1 param1, P2 param2, P3 param3, P4 param4
+#define FUNCTOR_FUNCTION_PARAMS5 P1 param1, P2 param2, P3 param3, P4 param4, P5 param5
+
+#define FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) FUNCTOR_FUNCTION_RETURNVALUE##returnvalue
+#define FUNCTOR_FUNCTION_RETURNVALUE0 void
+#define FUNCTOR_FUNCTION_RETURNVALUE1 R
+
+
+
+#define FUNCTOR_FUNCTION_CALL(numparams) FUNCTOR_FUNCTION_CALL##numparams
+#define FUNCTOR_FUNCTION_CALL0
+#define FUNCTOR_FUNCTION_CALL1 param1
+#define FUNCTOR_FUNCTION_CALL2 param1, param2
+#define FUNCTOR_FUNCTION_CALL3 param1, param2, param3
+#define FUNCTOR_FUNCTION_CALL4 param1, param2, param3, param4
+#define FUNCTOR_FUNCTION_CALL5 param1, param2, param3, param4, param5
+
+#define FUNCTOR_STORE_RETURNVALUE(returnvalue, functioncall) FUNCTOR_STORE_RETURNVALUE##returnvalue(functioncall)
+#define FUNCTOR_STORE_RETURNVALUE0(functioncall) functioncall
+#define FUNCTOR_STORE_RETURNVALUE1(functioncall) this->returnedValue_ = functioncall
+
+
+
+
+
+#define CREATE_STATIC_FUNCTOR(returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
+    class FunctorStatic##returnvalue##numparams : public FunctorStatic \
+    { \
+        public: \
+            FunctorStatic##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
+            { \
+                this->numParams_ = numparams; \
+                this->hasReturnValue_ = returnvalue; \
+                this->type_ = FT_STATIC; \
+                this->functionPointer_ = functionPointer; \
+                \
+                FUNCTOR_TYPENAME_PARAMS(numparams); \
+                FUNCTOR_TYPENAME_RETURN(returnvalue); \
+            } \
+    \
+            void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            { \
+                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
+            } \
+    \
+        private: \
+            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
+    }; \
+    \
+    \
+    FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
+    inline FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
+    { \
+        return new FunctorStatic##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(0, returnvalue, numparams) (functionPointer); \
+    }
+
+
+
+
+
+#define CREATE_MEMBER_FUNCTOR(returnvalue, numparams) \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    class FunctorMember##returnvalue##numparams : public FunctorMember<T> \
+    { \
+        public: \
+            FunctorMember##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
+            { \
+                this->numParams_ = numparams; \
+                this->hasReturnValue_ = returnvalue; \
+                this->type_ = FT_MEMBER; \
+                this->functionPointer_ = functionPointer; \
+            } \
+    \
+            void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            { \
+                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
+            } \
+    \
+            void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            { \
+                COUT(1) << "An error occurred in Functor.h:" << std::endl; \
+                COUT(1) << "Error: Function is not const." << std::endl; \
+            } \
+    \
+        private: \
+            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)); \
+    }; \
+    \
+    \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    class FunctorConstMember##returnvalue##numparams : public FunctorMember<T> \
+    { \
+        public: \
+            FunctorConstMember##returnvalue##numparams(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
+            { \
+                this->numParams_ = numparams; \
+                this->hasReturnValue_ = returnvalue; \
+                this->type_ = FT_CONSTMEMBER; \
+                this->functionPointer_ = functionPointer; \
+            } \
+    \
+            void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            { \
+                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
+            } \
+    \
+            void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            { \
+                FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
+            } \
+    \
+        private: \
+            FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer_)(FUNCTOR_FUNCTION_PARAMS(numparams)) const; \
+    }; \
+    \
+    \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    inline FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams))) \
+    { \
+        return new FunctorMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+    } \
+    \
+    \
+    FUNCTOR_TEMPLATE(1, returnvalue, numparams) \
+    inline FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams)* createFunctor(FUNCTOR_FUNCTION_RETURNVALUE(returnvalue) (T::*functionPointer)(FUNCTOR_FUNCTION_PARAMS(numparams)) const) \
+    { \
+        return new FunctorConstMember##returnvalue##numparams FUNCTOR_TEMPLATE_CLASSES(1, returnvalue, numparams) (functionPointer); \
+    }
+
+
+
+
+#define CREATE_ALL_STATIC_FUNCTORS() \
+    CREATE_STATIC_FUNCTOR(0, 0); \
+    CREATE_STATIC_FUNCTOR(0, 1); \
+    CREATE_STATIC_FUNCTOR(0, 2); \
+    CREATE_STATIC_FUNCTOR(0, 3); \
+    CREATE_STATIC_FUNCTOR(0, 4); \
+    CREATE_STATIC_FUNCTOR(0, 5); \
+    CREATE_STATIC_FUNCTOR(1, 0); \
+    CREATE_STATIC_FUNCTOR(1, 1); \
+    CREATE_STATIC_FUNCTOR(1, 2); \
+    CREATE_STATIC_FUNCTOR(1, 3); \
+    CREATE_STATIC_FUNCTOR(1, 4); \
+    CREATE_STATIC_FUNCTOR(1, 5)
+
+
+#define CREATE_ALL_MEMBER_FUNCTORS() \
+    CREATE_MEMBER_FUNCTOR(0, 0); \
+    CREATE_MEMBER_FUNCTOR(0, 1); \
+    CREATE_MEMBER_FUNCTOR(0, 2); \
+    CREATE_MEMBER_FUNCTOR(0, 3); \
+    CREATE_MEMBER_FUNCTOR(0, 4); \
+    CREATE_MEMBER_FUNCTOR(0, 5); \
+    CREATE_MEMBER_FUNCTOR(1, 0); \
+    CREATE_MEMBER_FUNCTOR(1, 1); \
+    CREATE_MEMBER_FUNCTOR(1, 2); \
+    CREATE_MEMBER_FUNCTOR(1, 3); \
+    CREATE_MEMBER_FUNCTOR(1, 4); \
+    CREATE_MEMBER_FUNCTOR(1, 5)
+
+
+CREATE_ALL_STATIC_FUNCTORS();
+CREATE_ALL_MEMBER_FUNCTORS();
+
+#endif /* _Functor_H__ */
Index: code/branches/core/src/orxonox/core/Identifier.cc
===================================================================
--- code/branches/core/src/orxonox/core/Identifier.cc	(revision 845)
+++ code/branches/core/src/orxonox/core/Identifier.cc	(revision 847)
@@ -198,4 +198,28 @@
 
     /**
+        @brief Returns the ConfigValueContainer of a variable, given by the string of its name.
+        @param varname The name of the variable
+        @return The ConfigValueContainer
+    */
+    ConfigValueContainer* Identifier::getConfigValueContainer(const std::string& varname)
+    {
+        std::map<std::string, ConfigValueContainer*>::const_iterator it = configValues_.find(varname);
+        if (it != configValues_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds the ConfigValueContainer of a variable, given by the string of its name.
+        @param varname The name of the variablee
+        @param container The container
+    */
+    void Identifier::addConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
+    {
+        this->configValues_[varname] = container;
+    }
+
+    /**
         @brief Searches for a given identifier in a list and returns whether the identifier is in the list or not.
         @param identifier The identifier to look for
Index: code/branches/core/src/orxonox/core/Identifier.h
===================================================================
--- code/branches/core/src/orxonox/core/Identifier.h	(revision 845)
+++ code/branches/core/src/orxonox/core/Identifier.h	(revision 847)
@@ -62,4 +62,5 @@
 #include "Debug.h"
 #include "Iterator.h"
+//#include "XMLPort.h"
 
 namespace orxonox
@@ -151,11 +152,9 @@
             void setNetworkID(unsigned int id);
 
-            /** @brief Returns the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variable @return The ConfigValueContainer */
-            inline ConfigValueContainer* getConfigValueContainer(const std::string& varname)
-                { return this->configValues_[varname]; }
-
-            /** @brief Sets the ConfigValueContainer of a variable, given by the string of its name. @param varname The name of the variablee @param container The container */
-            inline void setConfigValueContainer(const std::string& varname, ConfigValueContainer* container)
-                { this->configValues_[varname] = container; }
+            ConfigValueContainer* getConfigValueContainer(const std::string& varname);
+            void addConfigValueContainer(const std::string& varname, ConfigValueContainer* container);
+
+            virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
+            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
 
             static bool identifierIsInList(const Identifier* identifier, const std::list<const Identifier*>& list);
@@ -236,4 +235,7 @@
             inline const ObjectList<T>* getObjects() const { return this->objects_; }
 
+            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
+            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
+
         private:
             ClassIdentifier();
@@ -243,4 +245,5 @@
             ObjectList<T>* objects_;    //!< The ObjectList, containing all objects of type T
             bool bSetName_;             //!< True if the name is set
+            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;
     };
 
@@ -317,4 +320,20 @@
         for (Iterator<T> it = this->objects_->start(); it;)
             delete *(it++);
+    }
+
+    template <class T>
+    XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
+    {
+        typename std::map<std::string, XMLPortClassParamContainer<T>*>::const_iterator it = xmlportParamContainers_.find(paramname);
+        if (it != xmlportParamContainers_.end())
+            return (XMLPortParamContainer*)((*it).second);
+        else
+            return 0;
+    }
+
+    template <class T>
+    void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
+    {
+        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<T>*)container;
     }
 
Index: code/branches/core/src/orxonox/core/Language.cc
===================================================================
--- code/branches/core/src/orxonox/core/Language.cc	(revision 845)
+++ code/branches/core/src/orxonox/core/Language.cc	(revision 847)
@@ -145,5 +145,5 @@
         {
             LanguageEntry* newEntry = new LanguageEntry(entry);
-            newEntry->setName(label);
+            newEntry->setLabel(label);
             this->languageEntries_[label] = newEntry;
             return newEntry;
@@ -332,5 +332,5 @@
         for (Iterator<LanguageEntry> it = ObjectList<LanguageEntry>::start(); it; ++it)
         {
-            file << it->getName() << "=" << it->getDefault() << std::endl;
+            file << it->getLabel() << "=" << it->getDefault() << std::endl;
         }
 
Index: code/branches/core/src/orxonox/core/Language.h
===================================================================
--- code/branches/core/src/orxonox/core/Language.h	(revision 845)
+++ code/branches/core/src/orxonox/core/Language.h	(revision 847)
@@ -51,4 +51,12 @@
 #include "OrxonoxClass.h"
 
+
+#define AddLanguageEntry(label, fallbackstring) \
+    orxonox::Language::getLanguage().addEntry(label, fallbackstring)
+
+#define GetLocalisation(label) \
+    orxonox::Language::getLanguage().getLocalisation(label)
+
+
 namespace orxonox
 {
@@ -78,8 +86,23 @@
                 { return this->fallbackEntry_; }
 
+            /**
+                @brief Sets the label of this entry.
+                @param label The label
+            */
+            inline void setLabel(const LanguageEntryLabel& label)
+                { this->label_ = label; }
+
+            /**
+                @brief Returns the label of this entry.
+                @return The label
+            */
+            inline const LanguageEntryLabel& getLabel() const
+                { return this->label_; }
+
         private:
-            std::string fallbackEntry_;                             //!< The default entry: Used, if no translation is available or no language configured
-            std::string localisedEntry_;                            //!< The localised entry in the configured language
-            bool bLocalisationSet_;                                 //!< True if the translation was set
+            LanguageEntryLabel label_;              //!< The label of the entry
+            std::string fallbackEntry_;             //!< The default entry: Used, if no translation is available or no language configured
+            std::string localisedEntry_;            //!< The localised entry in the configured language
+            bool bLocalisationSet_;                 //!< True if the translation was set
     };
 
@@ -118,9 +141,3 @@
 }
 
-#define AddLanguageEntry(label, fallbackstring) \
-    orxonox::Language::getLanguage().addEntry(label, fallbackstring)
-
-#define GetLocalisation(label) \
-    orxonox::Language::getLanguage().getLocalisation(label)
-
 #endif /* _Language_H__ */
Index: code/branches/core/src/orxonox/core/Loader.cc
===================================================================
--- code/branches/core/src/orxonox/core/Loader.cc	(revision 845)
+++ code/branches/core/src/orxonox/core/Loader.cc	(revision 847)
@@ -121,4 +121,5 @@
                     COUT(4) << "  fabricating " << child->Value() << "..." << std::endl;
                     BaseObject* newObject = identifier->fabricate();
+                    newObject->XMLPort(*child, true);
                 }
                 else
Index: code/branches/core/src/orxonox/core/OrxonoxClass.cc
===================================================================
--- code/branches/core/src/orxonox/core/OrxonoxClass.cc	(revision 845)
+++ code/branches/core/src/orxonox/core/OrxonoxClass.cc	(revision 847)
@@ -42,7 +42,4 @@
         this->identifier_ = 0;
         this->parents_ = 0;
-
-        this->bActive_ = true;
-        this->bVisible_ = true;
     }
 
Index: code/branches/core/src/orxonox/core/OrxonoxClass.h
===================================================================
--- code/branches/core/src/orxonox/core/OrxonoxClass.h	(revision 845)
+++ code/branches/core/src/orxonox/core/OrxonoxClass.h	(revision 847)
@@ -155,31 +155,8 @@
                 { return this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
 
-
-            /** @brief Sets the name of the object. @param name The name */
-            inline virtual void setName(const std::string& name) { this->name_ = name; }
-
-            /** @brief Returns the name of the object. @return The name */
-            inline const std::string& getName() const { return this->name_; }
-
-            /** @brief Sets the state of the objects activity. @param bActive True = active */
-            inline virtual void setActive(bool bActive) { this->bActive_ = bActive; }
-
-            /** @brief Returns the state of the objects activity. @return The state of the activity */
-            inline const bool isActive() const { return this->bActive_; }
-
-            /** @brief Sets the state of the objects visibility. @param bVisible True = visible */
-            inline virtual void setVisible(bool bVisible) { this->bVisible_ = bVisible; }
-
-            /** @brief Returns the state of the objects visibility. @return The state of the visibility */
-            inline const bool isVisible() const { return this->bVisible_; }
-
         private:
             Identifier* identifier_;                    //!< The Identifier of the object
             std::list<const Identifier*>* parents_;     //!< List of all parents of the object
             MetaObjectList metaList_;                   //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
-
-            std::string name_;                          //!< The name of the object
-            bool bActive_;                              //!< True = the object is active
-            bool bVisible_;                             //!< True = the object is visible
     };
 }
Index: code/branches/core/src/orxonox/core/XMLPort.cc
===================================================================
--- code/branches/core/src/orxonox/core/XMLPort.cc	(revision 847)
+++ code/branches/core/src/orxonox/core/XMLPort.cc	(revision 847)
@@ -0,0 +1,55 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "XMLPort.h"
+#include "Language.h"
+
+namespace orxonox
+{
+    XMLPortParamContainer::XMLPortParamContainer()
+    {
+        this->bAddedDescription_ = false;
+        this->bAddedDefaultValues_ = false;
+    }
+
+    XMLPortParamContainer& XMLPortParamContainer::description(const std::string description)
+    {
+        if (!this->bAddedDescription_)
+        {
+            this->description_ = std::string("XMLPortParamContainer::" + this->classname_ + "::" + this->paramname_);
+            AddLanguageEntry(this->description_, description);
+            this->bAddedDescription_ = true;
+        }
+
+        return (*this);
+    }
+
+    const std::string& XMLPortParamContainer::getDescription()
+    {
+        return GetLocalisation(this->description_);
+    }
+}
Index: code/branches/core/src/orxonox/core/XMLPort.h
===================================================================
--- code/branches/core/src/orxonox/core/XMLPort.h	(revision 847)
+++ code/branches/core/src/orxonox/core/XMLPort.h	(revision 847)
@@ -0,0 +1,113 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _XMLPort_H__
+#define _XMLPort_H__
+
+#include "util/XMLIncludes.h"
+#include "util/MultiTypeMath.h"
+#include "Functor.h"
+
+#include "CorePrereqs.h"
+
+
+#define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, loading) \
+    orxonox::XMLPortClassParamContainer<classname>* xmlcontainer##loadfunction##savefunction = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
+    if (!xmlcontainer##loadfunction##savefunction) \
+    { \
+        xmlcontainer##loadfunction##savefunction = new orxonox::XMLPortClassParamContainer<classname>(this->getIdentifier()->getName(), std::string(paramname), createFunctor(&classname::loadfunction), createFunctor(&classname::savefunction)); \
+        this->getIdentifier()->addXMLPortParamContainer(paramname, xmlcontainer##loadfunction##savefunction); \
+    } \
+    xmlcontainer##loadfunction##savefunction->port(this, xmlelement, loading)
+
+
+namespace orxonox
+{
+    class _CoreExport XMLPortParamContainer
+    {
+        public:
+            XMLPortParamContainer();
+
+            inline const std::string& getName() const
+                { return this->paramname_; }
+
+            XMLPortParamContainer& description(const std::string description);
+            const std::string& getDescription();
+
+            XMLPortParamContainer& defaultValues(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+            {
+                this->defaultValues_[0] = param1;
+                this->defaultValues_[1] = param2;
+                this->defaultValues_[2] = param3;
+                this->defaultValues_[3] = param4;
+                this->defaultValues_[4] = param5;
+
+                return (*this);
+            }
+
+        protected:
+            std::string classname_;
+            std::string paramname_;
+            MultiTypeMath defaultValues_[5];
+
+        private:
+            LanguageEntryLabel description_;
+            bool bAddedDescription_;
+            bool bAddedDefaultValues_;
+    };
+
+    template <class T>
+    class XMLPortClassParamContainer : public XMLPortParamContainer
+    {
+        public:
+            XMLPortClassParamContainer(const std::string classname, const std::string paramname, FunctorMember<T>* loadfunction, FunctorMember<T>* savefunction)
+            {
+                this->classname_ = classname;
+                this->paramname_ = paramname;
+                this->loadfunction_ = loadfunction;
+                this->savefunction_ = savefunction;
+            }
+
+            XMLPortParamContainer& port(T* object, Element& xmlelement, bool loading)
+            {
+                if (loading)
+                {
+                }
+                else
+                {
+                }
+
+                return (*this);
+            }
+
+        private:
+            FunctorMember<T>* loadfunction_;
+            FunctorMember<T>* savefunction_;
+    };
+}
+
+#endif /* _XMLPort_H__ */
