Index: code/branches/core2/src/orxonox/core/Functor.h
===================================================================
--- code/branches/core2/src/orxonox/core/Functor.h	(revision 902)
+++ code/branches/core2/src/orxonox/core/Functor.h	(revision 925)
@@ -161,14 +161,4 @@
         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 ,
 
 
Index: code/branches/core2/src/util/Convert.h
===================================================================
--- code/branches/core2/src/util/Convert.h	(revision 902)
+++ code/branches/core2/src/util/Convert.h	(revision 925)
@@ -41,5 +41,4 @@
 #include "MultiTypeMath.h"
 
-
 // DEFAULT CLASS
 template <typename FromType, typename ToType>
@@ -151,5 +150,7 @@
     bool operator()(ToType* output, const MultiTypePrimitive& input) const
     {
-      if (input.getType() == MT_int)
+      if (input.getType() == MT_void)
+        return ConvertValue(output, input.getVoid());
+      else if (input.getType() == MT_int)
         return ConvertValue(output, input.getInt());
       else if (input.getType() == MT_uint)
@@ -185,5 +186,7 @@
     bool operator()(std::string* output, const MultiTypePrimitive& input) const
     {
-      if (input.getType() == MT_int)
+      if (input.getType() == MT_void)
+        return ConvertValue(output, input.getVoid());
+      else if (input.getType() == MT_int)
         return ConvertValue(output, input.getInt());
       else if (input.getType() == MT_uint)
@@ -225,4 +228,6 @@
       else if (input.getType() == MT_string)
         return ConvertValue(output, input.getString());
+      else if (input.getType() == MT_xmlelement)
+        return ConvertValue(output, input.getXMLElement());
       else
         return ConvertValue(output, (MultiTypePrimitive)input);
@@ -239,4 +244,6 @@
       else if (input.getType() == MT_string)
         return ConvertValue(output, input.getString());
+      else if (input.getType() == MT_xmlelement)
+        return ConvertValue(output, input.getXMLElement());
       else
         return ConvertValue(output, (MultiTypePrimitive)input);
@@ -534,3 +541,42 @@
 };
 
+
+////////////////
+// XMLElement //
+////////////////
+
+// orxonox::Element to std::string
+template <>
+class Converter<orxonox::Element, std::string>
+{
+  public:
+    bool operator()(std::string* output, const orxonox::Element& input) const
+    {
+      std::ostringstream ostream;
+      if (ostream << input)
+      {
+        (*output) = ostream.str();
+        return true;
+      }
+
+      return false;
+    }
+};
+
+// std::string to orxonox::Element
+template <>
+class Converter<std::string, orxonox::Element>
+{
+  public:
+    bool operator()(orxonox::Element* output, const std::string& input) const
+    {
+      std::istringstream istream(input);
+      if (istream >> (*output))
+        return true;
+
+      return false;
+    }
+};
+
+
 #endif /* _Convert_H__ */
Index: code/branches/core2/src/util/MultiType.h
===================================================================
--- code/branches/core2/src/util/MultiType.h	(revision 902)
+++ code/branches/core2/src/util/MultiType.h	(revision 925)
@@ -35,4 +35,5 @@
 {
     MT_null,
+    MT_void,
     MT_int,
     MT_uint,
@@ -49,4 +50,5 @@
     MT_constchar,
     MT_string,
+    MT_xmlelement,
     MT_vector2,
     MT_vector3,
@@ -59,4 +61,5 @@
 union _UtilExport MultiTypeValue
 {
+    void*           void_;
     int             int_;
     unsigned int    uint_;
Index: code/branches/core2/src/util/MultiTypeMath.cc
===================================================================
--- code/branches/core2/src/util/MultiTypeMath.cc	(revision 902)
+++ code/branches/core2/src/util/MultiTypeMath.cc	(revision 925)
@@ -88,4 +88,8 @@
 }
 
+MultiTypeMath::operator orxonox::BaseObject*() const
+{ return (this->type_ == MT_void) ? (orxonox::BaseObject*)this->value_.void_ : (orxonox::BaseObject*)ConvertValueAndReturn<MultiTypeMath, void*>(*this); }
+MultiTypeMath::operator void*() const
+{ return (this->type_ == MT_void) ? this->value_.void_ : ConvertValueAndReturn<MultiTypeMath, void*>(*this); }
 MultiTypeMath::operator int() const
 { return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypeMath, int>(*this); }
@@ -118,4 +122,6 @@
 MultiTypeMath::operator orxonox::Vector2() const
 { return (this->type_ == MT_vector2) ? this->vector2_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Vector2>(*this); }
+MultiTypeMath::operator orxonox::Element() const
+{ return (this->type_ == MT_xmlelement) ? this->xmlelement_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Element>(*this); }
 MultiTypeMath::operator orxonox::Vector3() const
 { return (this->type_ == MT_vector3) ? this->vector3_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Vector3>(*this); }
Index: code/branches/core2/src/util/MultiTypeMath.h
===================================================================
--- code/branches/core2/src/util/MultiTypeMath.h	(revision 902)
+++ code/branches/core2/src/util/MultiTypeMath.h	(revision 925)
@@ -38,5 +38,6 @@
 {
     public:
-        MultiTypeMath(MultiType      type = MT_null);
+        MultiTypeMath(MultiType type = MT_null);
+        inline MultiTypeMath(void*          value) : MultiTypeString(value) {}
         inline MultiTypeMath(int            value) : MultiTypeString(value) {}
         inline MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}
@@ -51,6 +52,7 @@
         inline MultiTypeMath(long double    value) : MultiTypeString(value) {}
         inline MultiTypeMath(bool           value) : MultiTypeString(value) {}
-        inline MultiTypeMath(const char*        value) : MultiTypeString(value) {}
-        inline MultiTypeMath(const std::string& value) : MultiTypeString(value) {}
+        inline MultiTypeMath(const char*             value) : MultiTypeString(value) {}
+        inline MultiTypeMath(const std::string&      value) : MultiTypeString(value) {}
+        inline MultiTypeMath(const orxonox::Element& value) : MultiTypeString(value) {}
         inline MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
         inline MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
@@ -89,4 +91,6 @@
         bool operator!=(const MultiTypeMath& mtm) const;
 
+        virtual operator orxonox::BaseObject*()          const;
+        virtual operator void*()                const;
         virtual operator int()                  const;
         virtual operator unsigned int()         const;
@@ -103,4 +107,5 @@
         virtual operator std::string()          const;
         virtual operator const char*()          const;
+        virtual operator orxonox::Element()     const;
         virtual operator orxonox::Vector2()     const;
         virtual operator orxonox::Vector3()     const;
Index: code/branches/core2/src/util/MultiTypePrimitive.cc
===================================================================
--- code/branches/core2/src/util/MultiTypePrimitive.cc	(revision 902)
+++ code/branches/core2/src/util/MultiTypePrimitive.cc	(revision 925)
@@ -34,5 +34,7 @@
     this->type_ = type;
 
-    if (type == MT_int)
+    if (type == MT_void)
+        this->value_.void_ = 0;
+    else if (type == MT_int)
         this->value_.int_ = 0;
     else if (type == MT_uint)
@@ -59,5 +61,5 @@
         this->value_.bool_ = false;
     else
-        this->value_.int_ = 0;
+        this->value_.void_ = 0;
 }
 
@@ -66,5 +68,7 @@
     if (this->type_ == mtp.type_)
     {
-        if (this->type_ == MT_int)
+        if (this->type_ == MT_void)
+            return (this->value_.void_ == mtp.value_.void_);
+        else if (this->type_ == MT_int)
             return (this->value_.int_ == mtp.value_.int_);
         else if (this->type_ == MT_uint)
@@ -99,5 +103,7 @@
     if (this->type_ == mtp.type_)
     {
-        if (this->type_ == MT_int)
+        if (this->type_ == MT_void)
+            return (this->value_.void_ != mtp.value_.void_);
+        else if (this->type_ == MT_int)
             return (this->value_.int_ != mtp.value_.int_);
         else if (this->type_ == MT_uint)
@@ -128,4 +134,8 @@
 }
 
+MultiTypePrimitive::operator orxonox::BaseObject*() const
+{ return (this->type_ == MT_void) ? (orxonox::BaseObject*)this->value_.void_ : (orxonox::BaseObject*)ConvertValueAndReturn<MultiTypePrimitive, void*>(*this); }
+MultiTypePrimitive::operator void*() const
+{ return (this->type_ == MT_void) ? this->value_.void_ : ConvertValueAndReturn<MultiTypePrimitive, void*>(*this); }
 MultiTypePrimitive::operator int() const
 { return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypePrimitive, int>(*this); }
@@ -163,5 +173,7 @@
     std::string output;
 
-    if (this->type_ == MT_int)
+    if (this->type_ == MT_void)
+        ConvertValue(&output, this->value_.void_);
+    else if (this->type_ == MT_int)
         ConvertValue(&output, this->value_.int_);
     else if (this->type_ == MT_uint)
@@ -193,5 +205,7 @@
 bool MultiTypePrimitive::fromString(const std::string value)
 {
-    if (this->type_ == MT_int)
+    if (this->type_ == MT_void)
+        return ConvertValue(&this->value_.void_, value, (void*)0);
+    else if (this->type_ == MT_int)
         return ConvertValue(&this->value_.int_, value, (int)0);
     else if (this->type_ == MT_uint)
Index: code/branches/core2/src/util/MultiTypePrimitive.h
===================================================================
--- code/branches/core2/src/util/MultiTypePrimitive.h	(revision 902)
+++ code/branches/core2/src/util/MultiTypePrimitive.h	(revision 925)
@@ -36,8 +36,13 @@
 #include "MultiType.h"
 
+namespace orxonox
+{
+    class BaseObject;
+}
 class _UtilExport MultiTypePrimitive
 {
     public:
-        MultiTypePrimitive(MultiType      type = MT_null);
+        MultiTypePrimitive(MultiType type = MT_null);
+        inline MultiTypePrimitive(void*          value) { this->setValue(value); }
         inline MultiTypePrimitive(int            value) { this->setValue(value); }
         inline MultiTypePrimitive(unsigned int   value) { this->setValue(value); }
@@ -56,4 +61,5 @@
 
         inline MultiTypePrimitive& operator=(MultiType      value) { this->type_ = MT_null; return *this; }
+        inline MultiTypePrimitive& operator=(void*          value) { this->setValue(value); return *this; }
         inline MultiTypePrimitive& operator=(int            value) { this->setValue(value); return *this; }
         inline MultiTypePrimitive& operator=(unsigned int   value) { this->setValue(value); return *this; }
@@ -70,4 +76,5 @@
         inline MultiTypePrimitive& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp); return *this; }
 
+        inline bool operator==(void*          value) const { return (this->value_.void_       == value); }
         inline bool operator==(int            value) const { return (this->value_.int_        == value); }
         inline bool operator==(unsigned int   value) const { return (this->value_.uint_       == value); }
@@ -84,5 +91,5 @@
         bool operator==(const MultiTypePrimitive& mtp) const;
 
-        inline bool operator!=(int            value) const { return (this->value_.int_        != value); }
+        inline bool operator!=(void*          value) const { return (this->value_.void_       != value); }
         inline bool operator!=(unsigned int   value) const { return (this->value_.uint_       != value); }
         inline bool operator!=(char           value) const { return (this->value_.char_       != value); }
@@ -98,4 +105,6 @@
         bool operator!=(const MultiTypePrimitive& mtp) const;
 
+        virtual operator orxonox::BaseObject*()    const;
+        virtual operator void*()          const;
         virtual operator int()            const;
         virtual operator unsigned int()   const;
@@ -111,4 +120,5 @@
         virtual operator bool()           const;
 
+        inline void setValue(void*          value) { this->type_ = MT_void;       this->value_.void_       = value; }
         inline void setValue(int            value) { this->type_ = MT_int;        this->value_.int_        = value; }
         inline void setValue(unsigned int   value) { this->type_ = MT_uint;       this->value_.uint_       = value; }
@@ -125,4 +135,5 @@
         void setValue(const MultiTypePrimitive& mtp);
 
+        inline void*          getVoid()          const { return this->value_.void_;        }
         inline int            getInt()           const { return this->value_.int_;        }
         inline unsigned int   getUnsignedInt()   const { return this->value_.uint_;       }
@@ -151,4 +162,5 @@
         inline bool&           getBool()          { return this->value_.bool_;       }
 
+        inline void getValue(void*           variable) const { variable    = this->value_.void_;       }
         inline void getValue(int*            variable) const { (*variable) = this->value_.int_;        }
         inline void getValue(unsigned int*   variable) const { (*variable) = this->value_.uint_;       }
Index: code/branches/core2/src/util/MultiTypeString.cc
===================================================================
--- code/branches/core2/src/util/MultiTypeString.cc	(revision 902)
+++ code/branches/core2/src/util/MultiTypeString.cc	(revision 925)
@@ -46,4 +46,6 @@
         else if (this->type_ == MT_string)
             return (this->string_ == mts.string_);
+        else if (this->type_ == MT_xmlelement)
+            return (&this->xmlelement_ == &mts.xmlelement_);
     }
 
@@ -59,4 +61,6 @@
         else if (this->type_ == MT_string)
             return (this->string_ != mts.string_);
+        else if (this->type_ == MT_xmlelement)
+            return (&this->xmlelement_ != &mts.xmlelement_);
     }
 
@@ -64,4 +68,8 @@
 }
 
+MultiTypeString::operator orxonox::BaseObject*() const
+{ return (this->type_ == MT_void) ? (orxonox::BaseObject*)this->value_.void_ : (orxonox::BaseObject*)ConvertValueAndReturn<MultiTypeString, void*>(*this); }
+MultiTypeString::operator void*() const
+{ return (this->type_ == MT_void) ? this->value_.void_ : ConvertValueAndReturn<MultiTypeString, void*>(*this); }
 MultiTypeString::operator int() const
 { return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypeString, int>(*this); }
@@ -92,4 +100,6 @@
 MultiTypeString::operator const char*() const
 { return ((this->type_ == MT_constchar) ? this->string_ : ConvertValueAndReturn<MultiTypeString, std::string>(*this)).c_str(); }
+MultiTypeString::operator orxonox::Element() const
+{ return (this->type_ == MT_xmlelement) ? this->xmlelement_ : ConvertValueAndReturn<MultiTypeString, orxonox::Element>(*this); }
 
 void MultiTypeString::setValue(const MultiTypeString& mts)
@@ -101,10 +111,16 @@
 std::string MultiTypeString::toString() const
 {
+    std::string output;
+
     if (this->type_ == MT_constchar)
         return this->string_;
     else if (this->type_ == MT_string)
         return this->string_;
+    else if (this->type_ == MT_xmlelement)
+        ConvertValue(&output, this->xmlelement_);
     else
         return MultiTypePrimitive::toString();
+
+    return output;
 }
 
@@ -115,4 +131,6 @@
     else if (this->type_ == MT_string)
         this->string_ = value;
+    else if (this->type_ == MT_xmlelement)
+        return ConvertValue(&this->xmlelement_, value, orxonox::Element());
     else
         return MultiTypePrimitive::fromString(value);
Index: code/branches/core2/src/util/MultiTypeString.h
===================================================================
--- code/branches/core2/src/util/MultiTypeString.h	(revision 902)
+++ code/branches/core2/src/util/MultiTypeString.h	(revision 925)
@@ -33,4 +33,6 @@
 #include <iostream>
 #include "UtilPrereqs.h"
+#include "XMLIncludes.h"
+#include "tinyxml/ticpp.h"
 
 #include "MultiTypePrimitive.h"
@@ -39,5 +41,6 @@
 {
     public:
-        MultiTypeString(MultiType      type = MT_null);
+        MultiTypeString(MultiType type = MT_null);
+        inline MultiTypeString(void*          value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(int            value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(unsigned int   value) : MultiTypePrimitive(value) {}
@@ -52,53 +55,64 @@
         inline MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
         inline MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(const char*        value)   { this->setValue(value); }
-        inline MultiTypeString(const std::string& value)   { this->setValue(value); }
-        inline MultiTypeString(const MultiTypeString& mts) { this->setValue(mts);   }
+        inline MultiTypeString(const char*           value)   { this->setValue(value); }
+        inline MultiTypeString(const std::string&    value)   { this->setValue(value); }
+        inline MultiTypeString(const orxonox::Element& value) { this->setValue(value); }
+        inline MultiTypeString(const MultiTypeString& mts)    { this->setValue(mts);   }
         virtual inline ~MultiTypeString() {}
 
         using MultiTypePrimitive::operator=;
-        inline MultiTypeString& operator=(const char*        value)   { this->setValue(value); return *this; }
-        inline MultiTypeString& operator=(const std::string& value)   { this->setValue(value); return *this; }
-        inline MultiTypeString& operator=(const MultiTypeString& mts) { this->setValue(mts);   return *this; }
+        inline MultiTypeString& operator=(const char*             value)   { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const std::string&      value)   { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const orxonox::Element& value)   { this->setValue(value); return *this; }
+        inline MultiTypeString& operator=(const MultiTypeString& mts)      { this->setValue(mts);   return *this; }
 
         using MultiTypePrimitive::operator==;
-        inline bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
-        inline bool operator==(const std::string& value) const { return (this->string_ == value);              }
+        inline bool operator==(const char*             value) const { return (this->string_      == std::string(value)); }
+        inline bool operator==(const std::string&      value) const { return (this->string_      == value);              }
+        inline bool operator==(const orxonox::Element& value) const { return (&this->xmlelement_ == &value);             }
         bool operator==(const MultiTypeString& mts) const;
 
         using MultiTypePrimitive::operator!=;
-        inline bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
-        inline bool operator!=(const std::string& value) const { return (this->string_ != value);              }
+        inline bool operator!=(const char*             value) const { return (this->string_      != std::string(value)); }
+        inline bool operator!=(const std::string&      value) const { return (this->string_      != value);              }
+        inline bool operator!=(const orxonox::Element& value) const { return (&this->xmlelement_ != &value);             }
         bool operator!=(const MultiTypeString& mts) const;
 
-        virtual operator int()            const;
-        virtual operator unsigned int()   const;
-        virtual operator char()           const;
-        virtual operator unsigned char()  const;
-        virtual operator short()          const;
-        virtual operator unsigned short() const;
-        virtual operator long()           const;
-        virtual operator unsigned long()  const;
-        virtual operator float ()         const;
-        virtual operator double ()        const;
-        virtual operator long double()    const;
-        virtual operator bool()           const;
-        virtual operator std::string()    const;
-        virtual operator const char*()    const;
+        virtual operator orxonox::BaseObject*() const;
+        virtual operator void*()                const;
+        virtual operator int()                  const;
+        virtual operator unsigned int()         const;
+        virtual operator char()                 const;
+        virtual operator unsigned char()        const;
+        virtual operator short()                const;
+        virtual operator unsigned short()       const;
+        virtual operator long()                 const;
+        virtual operator unsigned long()        const;
+        virtual operator float ()               const;
+        virtual operator double ()              const;
+        virtual operator long double()          const;
+        virtual operator bool()                 const;
+        virtual operator std::string()          const;
+        virtual operator const char*()          const;
+        virtual operator orxonox::Element()     const;
 
         using MultiTypePrimitive::setValue;
-        inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }
-        inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value;              }
+        inline void setValue(const char*             value) { this->type_ = MT_string;     this->string_     = std::string(value); }
+        inline void setValue(const std::string&      value) { this->type_ = MT_string;     this->string_     = value;              }
+        inline void setValue(const orxonox::Element& value) { this->type_ = MT_xmlelement; this->xmlelement_ = value;              }
         void setValue(const MultiTypeString& mts);
 
-        inline const std::string getString() const { return this->string_;         }
-        inline const char*  getConstChar()   const { return this->string_.c_str(); }
+        inline std::string getString()          const { return this->string_;         }
+        inline const char*  getConstChar()      const { return this->string_.c_str(); }
+        inline orxonox::Element getXMLElement() const { return this->xmlelement_;     }
 
-        inline const std::string& getString() { return this->string_;         }
-        inline const char*  getConstChar()    { return this->string_.c_str(); }
+        inline std::string& getString()          { return this->string_;         }
+        inline const char*  getConstChar()       { return this->string_.c_str(); }
+        inline orxonox::Element& getXMLElement() { return this->xmlelement_;     }
 
         using MultiTypePrimitive::getValue;
-        inline void getValue(std::string* variable) const { (*variable) = this->string_;         }
-        inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }
+        inline void getValue(std::string*      variable) const { (*variable) = this->string_;         }
+        inline void getValue(const char**      variable) const { (*variable) = this->string_.c_str(); }
+        inline void getValue(orxonox::Element* variable) const { (*variable) = this->xmlelement_;     }
 
         virtual std::string toString() const;
@@ -106,5 +120,6 @@
 
     protected:
-        std::string string_;
+        std::string      string_;
+        orxonox::Element xmlelement_;
 };
 
Index: code/branches/core2/src/util/tinyxml/ticpp.h
===================================================================
--- code/branches/core2/src/util/tinyxml/ticpp.h	(revision 902)
+++ code/branches/core2/src/util/tinyxml/ticpp.h	(revision 925)
@@ -973,5 +973,5 @@
  		Stream output operator.
  		*/
- 		friend std::ostream& operator <<( std::ostream& out, Node& base )
+ 		friend std::ostream& operator <<( std::ostream& out, const Node& base )
  		{
  			out << *base.GetTiXmlPointer();
