Index: code/branches/core2/src/orxonox/OrxonoxStableHeaders.h
===================================================================
--- code/branches/core2/src/orxonox/OrxonoxStableHeaders.h	(revision 1000)
+++ code/branches/core2/src/orxonox/OrxonoxStableHeaders.h	(revision 1001)
@@ -83,5 +83,4 @@
 
 #include "util/Math.h"
-#include "util/Convert.h"
 #include "util/Sleep.h"
 #include "util/String2Number.h"
Index: code/branches/core2/src/orxonox/core/CommandExecutor.cc
===================================================================
--- code/branches/core2/src/orxonox/core/CommandExecutor.cc	(revision 1000)
+++ code/branches/core2/src/orxonox/core/CommandExecutor.cc	(revision 1001)
@@ -297,9 +297,9 @@
     }
 
-    bool CommandExecutor::addConsoleCommandShortcut(ExecutorStatic* executor)
+    Executor& CommandExecutor::addConsoleCommandShortcut(ExecutorStatic* executor)
     {
         CommandExecutor::getInstance().consoleCommandShortcuts_[executor->getName()] = executor;
         CommandExecutor::getInstance().consoleCommandShortcuts_LC_[getLowercase(executor->getName())] = executor;
-        return true;
+        return (*executor);
     }
 
Index: code/branches/core2/src/orxonox/core/CommandExecutor.h
===================================================================
--- code/branches/core2/src/orxonox/core/CommandExecutor.h	(revision 1000)
+++ code/branches/core2/src/orxonox/core/CommandExecutor.h	(revision 1001)
@@ -139,5 +139,5 @@
             static CommandEvaluation evaluate(const std::string& command);
 
-            static bool addConsoleCommandShortcut(ExecutorStatic* executor);
+            static Executor& addConsoleCommandShortcut(ExecutorStatic* executor);
             static ExecutorStatic* getConsoleCommandShortcut(const std::string& name);
             static ExecutorStatic* getLowercaseConsoleCommandShortcut(const std::string& name);
Index: code/branches/core2/src/orxonox/core/ConsoleCommand.h
===================================================================
--- code/branches/core2/src/orxonox/core/ConsoleCommand.h	(revision 1000)
+++ code/branches/core2/src/orxonox/core/ConsoleCommand.h	(revision 1001)
@@ -50,5 +50,5 @@
 
 #define ConsoleCommandShortcutGeneric(fakevariable, executor) \
-    bool fakevariable = CommandExecutor::addConsoleCommandShortcut((ExecutorStatic*)executor)
+    Executor& fakevariable = CommandExecutor::addConsoleCommandShortcut((ExecutorStatic*)executor)
 
 
Index: code/branches/core2/src/orxonox/core/Functor.h
===================================================================
--- code/branches/core2/src/orxonox/core/Functor.h	(revision 1000)
+++ code/branches/core2/src/orxonox/core/Functor.h	(revision 1001)
@@ -325,5 +325,9 @@
             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) \
             { \
+                std::cout << "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" << std::endl; \
+                std::cout << param1 << std::endl; \
+                std::cout << this->getTypenameParam(0) << std::endl; \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
+                std::cout << "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" << std::endl; \
             } \
     \
Index: code/branches/core2/src/orxonox/objects/Tickable.cc
===================================================================
--- code/branches/core2/src/orxonox/objects/Tickable.cc	(revision 1000)
+++ code/branches/core2/src/orxonox/objects/Tickable.cc	(revision 1001)
@@ -1,7 +1,25 @@
 #include "core/CoreIncludes.h"
+#include "core/ConsoleCommand.h"
 #include "Tickable.h"
 
 namespace orxonox
 {
+    ConsoleCommandShortcutExtern(slomo, AccessLevel::Offline).setDefaultValue(0, 1.0);
+    ConsoleCommandShortcutExtern(setTimeFactor, AccessLevel::Offline).setDefaultValue(0, 1.0);
+
+    static float timefactor = 1.0;
+    void slomo(float factor)
+    {
+        setTimeFactor(factor);
+    }
+    void setTimeFactor(float factor)
+    {
+        timefactor = factor;
+    }
+    float getTimeFactor()
+    {
+        return timefactor;
+    }
+
     /**
         @brief Constructor: Registers the object in the Tickable-list
Index: code/branches/core2/src/orxonox/objects/Tickable.h
===================================================================
--- code/branches/core2/src/orxonox/objects/Tickable.h	(revision 1000)
+++ code/branches/core2/src/orxonox/objects/Tickable.h	(revision 1001)
@@ -50,4 +50,8 @@
     class TickFrameListener; // Forward declaration
 
+    void slomo(float factor);
+    void setTimeFactor(float factor = 1.0);
+    float getTimeFactor();
+
     //! The Tickable interface provides a tick(dt) function, that gets called every frame.
     class _OrxonoxExport Tickable : virtual public OrxonoxClass
@@ -71,7 +75,8 @@
             bool frameStarted(const Ogre::FrameEvent &evt)
             {
+                float dt = evt.timeSinceLastFrame * getTimeFactor();
                 // Iterate through all Tickables and call their tick(dt) function
                 for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; )
-                    (it++)->tick(evt.timeSinceLastFrame);
+                    (it++)->tick(dt);
 
                 return FrameListener::frameStarted(evt);
Index: code/branches/core2/src/orxonox/tools/Timer.h
===================================================================
--- code/branches/core2/src/orxonox/tools/Timer.h	(revision 1000)
+++ code/branches/core2/src/orxonox/tools/Timer.h	(revision 1001)
@@ -63,4 +63,5 @@
 #include "OrxonoxPrereqs.h"
 #include "core/CorePrereqs.h"
+#include "../objects/Tickable.h"
 
 namespace orxonox
@@ -200,4 +201,5 @@
             bool frameStarted(const Ogre::FrameEvent &evt)
             {
+                float dt = evt.timeSinceLastFrame * getTimeFactor();
                 // Iterate through all Timers
                 for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; )
@@ -206,5 +208,5 @@
                     {
                         // If active: Decrease the timer by the duration of the last frame
-                        it->time_ -= evt.timeSinceLastFrame;
+                        it->time_ -= dt;
 
                         if (it->time_ <= 0)
Index: code/branches/core2/src/util/Convert.h
===================================================================
--- code/branches/core2/src/util/Convert.h	(revision 1000)
+++ code/branches/core2/src/util/Convert.h	(revision 1001)
@@ -41,101 +41,352 @@
 #include "MultiTypeMath.h"
 
-// DEFAULT CLASS
-template <typename FromType, typename ToType>
-class Converter
-{
-  public:
-    bool operator()(ToType* output, const FromType& input) const
-    {
-      return false;
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT TO STRINGS
-template<typename FromType>
-class Converter<FromType, std::string>
-{
-  public:
-    bool operator()(std::string* output, const FromType& input) const
-    {
-      std::ostringstream oss;
-      if (oss << input)
-      {
+
+//////////
+// Main //
+//////////
+/*
+enum ConversionPreference
+{
+    CP_ToType,
+    CP_FromType
+};
+
+// Helper classes to determine the preferred partial template specialization
+class _AnyType_  {};
+class _ToType_   {} static __to__;
+class _FromType_ {} static __from__;
+class _Explicit_ {} static __explicit__;
+
+
+// The default convert functions
+template <class FromType, class ToType>
+static bool convert(ToType* output, const FromType& input, _ToType_* type)
+{ std::cout << "default to" << std::endl; return false; }
+template <class FromType, class ToType>
+static bool convert(ToType* output, const FromType& input, _FromType_* type)
+{ std::cout << "default from" << std::endl; return false; }
+template <class FromType, class ToType>
+static bool convert(ToType* output, const FromType& input, _Explicit_* type)
+{ std::cout << "default explicit" << std::endl; return false; }
+
+
+// The default convert function if both types are the same
+template <class BothTypes>
+static bool convert(BothTypes* output, const BothTypes& input, _Explicit_* type)
+{ (*output) = input; return true; }
+
+
+// The default conversion of primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)
+template <class FromType, class ToType, class Type>
+static bool convertDefault(ToType* output, const FromType& input, Type* type)
+{ return false; }
+#define CONVERT_PRIMITIVE_DEFAULT(primitive) \
+template <class FromType> static bool convertDefault(primitive* output, const FromType& input, _ToType_* type) { return convertDefault(output, input, &__from__); } \
+template <class ToType>   static bool convertDefault(ToType* output, const primitive& input, _FromType_* type) { (*output) = (ToType)input; return true; }
+CONVERT_PRIMITIVE_DEFAULT(int)
+CONVERT_PRIMITIVE_DEFAULT(unsigned int)
+CONVERT_PRIMITIVE_DEFAULT(char)
+CONVERT_PRIMITIVE_DEFAULT(unsigned char)
+CONVERT_PRIMITIVE_DEFAULT(short)
+CONVERT_PRIMITIVE_DEFAULT(unsigned short)
+CONVERT_PRIMITIVE_DEFAULT(long)
+CONVERT_PRIMITIVE_DEFAULT(unsigned long)
+CONVERT_PRIMITIVE_DEFAULT(float)
+CONVERT_PRIMITIVE_DEFAULT(double)
+CONVERT_PRIMITIVE_DEFAULT(long double)
+CONVERT_PRIMITIVE_DEFAULT(bool)
+
+// Calls all four possibilities of converting two values: (the order of 2 and 3 can be changed by setting bPreferToType to false)
+// 1) explicit specialization
+// 2) partial specialization for ToType
+// 3) partial specialization of the FromType
+// 4) default conversion if available
+template<class FromType, class ToType>
+static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+{
+std::cout << "1_1\n";
+    if (convert(output, input, &__explicit__))
+        return true;
+
+std::cout << "1_2\n";
+    if (preference == CP_ToType)
+    {
+std::cout << "1_3\n";
+        if (convert(output, input, &__to__))
+            return true;
+std::cout << "1_4\n";
+        if (convert(output, input, &__from__))
+            return true;
+std::cout << "1_5\n";
+    }
+    else
+    {
+std::cout << "1_6\n";
+        if (convert(output, input, &__from__))
+            return true;
+std::cout << "1_7\n";
+        if (convert(output, input, &__to__))
+            return true;
+std::cout << "1_8\n";
+    }
+std::cout << "1_9\n";
+    return convertDefault(output, input, &__to__);
+}
+*/
+
+    // Enum to declare the wanted conversion preference in case of equal type-levels
+    enum ConversionPreference
+    {
+        CP_ToType,
+        CP_FromType
+    };
+
+    // Helper classes to determine the preferred partial template specialization
+    class _AnyType_  {};
+    class _ToType_   {} static __to__;
+    class _FromType_ {} static __from__;
+    class _Explicit_ {} static __explicit__;
+
+
+    // The default convert functions
+    template <class FromType, class ToType>
+    static bool convert(ToType* output, const FromType& input, _ToType_* type)
+    { std::cout << "default to" << std::endl; return false; }
+    template <class FromType, class ToType>
+    static bool convert(ToType* output, const FromType& input, _FromType_* type)
+    { std::cout << "default from" << std::endl; return false; }
+    template <class FromType, class ToType>
+    static bool convert(ToType* output, const FromType& input, _Explicit_* type)
+    { std::cout << "default explicit" << std::endl; return false; }
+
+
+    // The default convert function if both types are the same
+    template <class BothTypes>
+    static bool convert(BothTypes* output, const BothTypes& input, _Explicit_* type)
+    { (*output) = input; return true; }
+
+
+    // The possible levels
+    #define __low__  0
+    #define __mid__  1
+    #define __high__ 2
+
+    // Defines the levels of all types
+    template <class T> struct ConverterLeveL          { enum { level = __high__ }; };
+    template <> struct ConverterLeveL<std::string>    { enum { level = __mid__ }; };
+    template <> struct ConverterLeveL<int>            { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned int>   { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<char>           { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned char>  { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<short>          { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned short> { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<long>           { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned long>  { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<float>          { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<double>         { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<long double>    { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<bool>           { enum { level = __low__ }; };
+
+
+    // Calculates the preference based on the levels of FromType and ToType
+    template <int from, int to>
+    struct ConverterPreference
+    {
+        enum
+        {
+            max = (from > to) ? from : to,
+            diff = ((to - from) > 1) ? 1 : (((to - from) < -1) ? -1 : to - from)
+        };
+    };
+
+
+    // The default conversion: This usually does nothing
+    template <int max, class FromType, class ToType, class Type>
+    struct ConverterDefault
+    {
+        static bool convert(ToType* output, const FromType& input, Type* type)
+        {
+            return false;
+        }
+    };
+    // The default conversion for primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)    template <int max, class FromType, class ToType>
+    template <class FromType, class ToType, class Type>
+    struct ConverterDefault<0, FromType, ToType, Type>
+    {
+        static bool convert(ToType* output, const FromType& input, Type* type)
+        {
+            (*output) = (ToType)input;
+            return true;
+        }
+    };
+
+
+    // Converter: Converts input of FromType into output of ToType
+    template <int diff, int max, class FromType, class ToType>
+    struct Converter
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            return false;
+        }
+    };
+    // Converter: FromType-level > ToType-level
+    template <int max, class FromType, class ToType>
+    struct Converter<-1, max, FromType, ToType>
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            if (convert(output, input, &__explicit__))
+                return true;
+            if (convert(output, input, &__from__))
+                return true;
+            if (ConverterDefault<max, FromType, ToType, _ToType_>::convert(output, input, &__to__))
+                return true;
+
+            return false;
+        }
+    };
+    // Converter: ToType-level > FromType-level
+    template <int max, class FromType, class ToType>
+    struct Converter<1, max, FromType, ToType>
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            if (convert(output, input, &__explicit__))
+                return true;
+            if (convert(output, input, &__to__))
+                return true;
+            if (ConverterDefault<max, FromType, ToType, _ToType_>::convert(output, input, &__to__))
+                return true;
+
+            return false;
+        }
+    };
+    // Converter: ToType-level = ToType-level
+    template <int max, class FromType, class ToType>
+    struct Converter<0, max, FromType, ToType>
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            if (convert(output, input, &__explicit__))
+                return true;
+
+            if (preference == CP_ToType)
+            {
+                if (convert(output, input, &__to__))
+                    return true;
+                if (convert(output, input, &__from__))
+                    return true;
+            }
+            else
+            {
+                if (convert(output, input, &__from__))
+                    return true;
+                if (convert(output, input, &__to__))
+                    return true;
+            }
+
+            if (ConverterDefault<max, FromType, ToType, _ToType_>::convert(output, input, &__to__))
+                return true;
+
+            return false;
+        }
+    };
+
+
+    // Calls the Converter::convertValue function with the correct template type parameters calculated by ConverterPreference
+    template <class FromType, class ToType>
+    static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+    {
+        return Converter<ConverterPreference<ConverterLeveL<FromType>::level, ConverterLeveL<ToType>::level>::diff, ConverterPreference<ConverterLeveL<FromType>::level, ConverterLeveL<ToType>::level>::max, FromType, ToType>::convertValue(output, input, preference);
+    }
+
+
+// Helper function: Calls convertValue with and without default value and returns true if the conversion was successful
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+{
+    return convertValue(output, input, preference);
+}
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback, ConversionPreference preference = CP_ToType)
+{
+    if (convertValue(output, input, preference))
+        return true;
+
+    (*output) = fallback;
+    return false;
+}
+
+// Helper function: Calls convertValue with and without default value and returns the converted value
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, ConversionPreference preference = CP_ToType)
+{
+    ToType output = ToType();
+    ConvertValue(&output, input, preference);
+    return output;
+}
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_ToType)
+{
+    ToType output = fallback;
+    ConvertValue(&output, input, fallback, preference);
+    return output;
+}
+
+/////////////////////
+// SPECIALISATIONS //
+/////////////////////
+
+/*
+template <class FromType>
+static bool convertDefault(primitive* output, const FromType& input, _ToType_* type)
+{
+
+}
+
+template <class ToType>
+static bool convertDefault(ToType* output, const primitive& input, _FromType_* type)
+{
+
+}
+
+
+template <>
+static bool convertDefault(ToType* output, const FromType& input, _Explicit_* type)
+{
+
+}
+*/
+
+////////////
+// String //
+////////////
+
+// convert to string
+template <class FromType>
+static bool convert(std::string* output, const FromType& input, _ToType_* type)
+{
+    std::ostringstream oss;
+    if (oss << input)
+    {
         (*output) = oss.str();
         return true;
-      }
-      else
+    }
+    else
         return false;
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT FROM STRING
-template<typename ToType>
-class Converter<std::string, ToType>
-{
-  public:
-    bool operator()(ToType* output, const std::string& input) const
-    {
-      std::istringstream iss(input);
-      if (iss >> (*output))
-        return true;
-      else
+}
+
+// convert from string
+template <class ToType>
+static bool convert(ToType* output, const std::string& input, _FromType_* type)
+{
+    std::istringstream iss(input);
+    if (iss >> (*output))
+        return true;
+    else
         return false;
-    }
-};
-
-// FUNCTION SO WE DO NOT HAVE TO TELL THE COMPILER ABOUT THE TYPE
-template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input)
-{
-  Converter<FromType, ToType> converter;
-  return converter(output, input);
-}
-
-// THE SAME, BUT WITH DEFAULT VALUE
-template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
-{
-  Converter<FromType, ToType> converter;
-  if (converter(output, input))
-    return true;
-
-  (*output) = fallback;
-  return false;
-}
-
-// THE SAME LIKE BEFORE, BUT NEEDS NO POINTER TO THE OUTPUT
-template<typename FromType, typename ToType>
-static ToType ConvertValueAndReturn(const FromType& input)
-{
-  ToType output = ToType();
-  ConvertValue(&output, input);
-  return output;
-}
-
-// THE SAME, BUT WITH DEFAULT VALUE
-template<typename FromType, typename ToType>
-static ToType ConvertValueAndReturn(const FromType& input, const ToType& fallback)
-{
-  ToType output = fallback;
-  ConvertValue(&output, input, fallback);
-  return output;
-}
-
-//////////////////////////
-// MORE SPECIALISATIONS //
-//////////////////////////
-
-// STRING TO STRING
-template<>
-class Converter<std::string, std::string>
-{
-  public:
-    bool operator()(std::string* output, const std::string& input) const
-    {
-        (*output) = std::string(input);
-        return true;
-    }
-};
+}
+
 
 ////////////////
@@ -143,157 +394,69 @@
 ////////////////
 
-// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEPRIMITIVE
-template<typename ToType>
-class Converter<MultiTypePrimitive, ToType>
-{
-  public:
-    bool operator()(ToType* output, const MultiTypePrimitive& input) const
-    {
-      if (input.getType() == MT_void)
+// convert from MultiTypePrimitive
+template <class ToType>
+static bool convert(ToType* output, const MultiTypePrimitive& input, _FromType_* type)
+{
+    if (input.getType() == MT_void)
         return ConvertValue(output, input.getVoid());
-      else if (input.getType() == MT_int)
+    else if (input.getType() == MT_int)
         return ConvertValue(output, input.getInt());
-      else if (input.getType() == MT_uint)
+    else if (input.getType() == MT_uint)
         return ConvertValue(output, input.getUnsignedInt());
-      else if (input.getType() == MT_char)
+    else if (input.getType() == MT_char)
         return ConvertValue(output, input.getChar());
-      else if (input.getType() == MT_uchar)
+    else if (input.getType() == MT_uchar)
         return ConvertValue(output, input.getUnsignedChar());
-      else if (input.getType() == MT_short)
+    else if (input.getType() == MT_short)
         return ConvertValue(output, input.getShort());
-      else if (input.getType() == MT_ushort)
+    else if (input.getType() == MT_ushort)
         return ConvertValue(output, input.getUnsignedShort());
-      else if (input.getType() == MT_long)
+    else if (input.getType() == MT_long)
         return ConvertValue(output, input.getLong());
-      else if (input.getType() == MT_ulong)
+    else if (input.getType() == MT_ulong)
         return ConvertValue(output, input.getUnsignedLong());
-      else if (input.getType() == MT_float)
+    else if (input.getType() == MT_float)
         return ConvertValue(output, input.getFloat());
-      else if (input.getType() == MT_double)
+    else if (input.getType() == MT_double)
         return ConvertValue(output, input.getDouble());
-      else if (input.getType() == MT_longdouble)
+    else if (input.getType() == MT_longdouble)
         return ConvertValue(output, input.getLongDouble());
-      else if (input.getType() == MT_bool)
+    else if (input.getType() == MT_bool)
         return ConvertValue(output, input.getBool());
-      else
+    else
         return false;
-    }
-};
-template<>
-class Converter<MultiTypePrimitive, std::string>
-{
-  public:
-    bool operator()(std::string* output, const MultiTypePrimitive& input) const
-    {
-      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)
-        return ConvertValue(output, input.getUnsignedInt());
-      else if (input.getType() == MT_char)
-        return ConvertValue(output, input.getChar());
-      else if (input.getType() == MT_uchar)
-        return ConvertValue(output, input.getUnsignedChar());
-      else if (input.getType() == MT_short)
-        return ConvertValue(output, input.getShort());
-      else if (input.getType() == MT_ushort)
-        return ConvertValue(output, input.getUnsignedShort());
-      else if (input.getType() == MT_long)
-        return ConvertValue(output, input.getLong());
-      else if (input.getType() == MT_ulong)
-        return ConvertValue(output, input.getUnsignedLong());
-      else if (input.getType() == MT_float)
-        return ConvertValue(output, input.getFloat());
-      else if (input.getType() == MT_double)
-        return ConvertValue(output, input.getDouble());
-      else if (input.getType() == MT_longdouble)
-        return ConvertValue(output, input.getLongDouble());
-      else if (input.getType() == MT_bool)
-        return ConvertValue(output, input.getBool());
-      else
-        return false;
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPESTRING
-template<typename ToType>
-class Converter<MultiTypeString, ToType>
-{
-  public:
-    bool operator()(ToType* output, const MultiTypeString& input) const
-    {
-      if (input.getType() == MT_constchar)
+}
+
+// convert from MultiTypeString
+template <class ToType>
+static bool convert(ToType* output, const MultiTypeString& input, _FromType_* type)
+{
+    if (input.getType() == MT_constchar)
         return ConvertValue(output, input.getConstChar());
-      else if (input.getType() == MT_string)
+    else if (input.getType() == MT_string)
         return ConvertValue(output, input.getString());
-      else if (input.getType() == MT_xmlelement)
-        return ConvertValue(output, input.getXMLElement());
-      else
+    else
         return ConvertValue(output, (MultiTypePrimitive)input);
-    }
-};
-template<>
-class Converter<MultiTypeString, std::string>
-{
-  public:
-    bool operator()(std::string* output, const MultiTypeString& input) const
-    {
-      if (input.getType() == MT_constchar)
-        return ConvertValue(output, input.getConstChar());
-      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);
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEMATH
-template<typename ToType>
-class Converter<MultiTypeMath, ToType>
-{
-  public:
-    bool operator()(ToType* output, const MultiTypeMath& input) const
-    {
-      if (input.getType() == MT_vector2)
-        return ConvertValue(output, input.getVector2());
-      else if (input.getType() == MT_vector3)
-        return ConvertValue(output, input.getVector3());
-      else if (input.getType() == MT_quaternion)
-        return ConvertValue(output, input.getQuaternion());
-      else if (input.getType() == MT_colourvalue)
-        return ConvertValue(output, input.getColourValue());
-      else if (input.getType() == MT_radian)
+}
+
+// convert from MultiTypeMath
+template <class ToType>
+static bool convert(ToType* output, const MultiTypeMath& input, _FromType_* type)
+{
+    if (input.getType() == MT_vector2)
+        return ConvertValue(output, input.getVector2(), CP_FromType);
+    else if (input.getType() == MT_vector3)
+        return ConvertValue(output, input.getVector3(), CP_FromType);
+    else if (input.getType() == MT_quaternion)
+        return ConvertValue(output, input.getQuaternion(), CP_FromType);
+    else if (input.getType() == MT_colourvalue)
+        return ConvertValue(output, input.getColourValue(), CP_FromType);
+    else if (input.getType() == MT_radian)
         return ConvertValue(output, input.getRadian());
-      else if (input.getType() == MT_degree)
+    else if (input.getType() == MT_degree)
         return ConvertValue(output, input.getDegree());
-      else
+    else
         return ConvertValue(output, (MultiTypeString)input);
-    }
-};
-template<>
-class Converter<MultiTypeMath, std::string>
-{
-  public:
-    bool operator()(std::string* output, const MultiTypeMath& input) const
-    {
-      if (input.getType() == MT_vector2)
-        return ConvertValue(output, input.getVector2());
-      else if (input.getType() == MT_vector3)
-        return ConvertValue(output, input.getVector3());
-      else if (input.getType() == MT_quaternion)
-        return ConvertValue(output, input.getQuaternion());
-      else if (input.getType() == MT_colourvalue)
-        return ConvertValue(output, input.getColourValue());
-      else if (input.getType() == MT_radian)
-        return ConvertValue(output, input.getRadian());
-      else if (input.getType() == MT_degree)
-        return ConvertValue(output, input.getDegree());
-      else
-        return ConvertValue(output, (MultiTypeString)input);
-    }
-};
+}
 
 
@@ -304,4 +467,18 @@
 // Vector2 to std::string
 template <>
+static bool convert(std::string* output, const orxonox::Vector2& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+/*
+// Vector2 to std::string
+template <>
 class Converter<orxonox::Vector2, std::string>
 {
@@ -319,5 +496,19 @@
     }
 };
-
+*/
+// Vector3 to std::string
+template <>
+static bool convert(std::string* output, const orxonox::Vector3& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y << "," << input.z)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+/*
 // Vector3 to std::string
 template <>
@@ -337,5 +528,18 @@
     }
 };
-
+*/
+// Vector4 to std::string
+template <>
+static bool convert(std::string* output, const orxonox::Vector4& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+/*
 // Vector4 to std::string
 template <>
@@ -355,5 +559,18 @@
     }
 };
-
+*/
+// Quaternion to std::string
+template <>
+static bool convert(std::string* output, const orxonox::Quaternion& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+/*
 // Quaternion to std::string
 template <>
@@ -373,5 +590,18 @@
     }
 };
-
+*/
+// ColourValue to std::string
+template <>
+static bool convert(std::string* output, const orxonox::ColourValue& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+/*
 // ColourValue to std::string
 template <>
@@ -391,4 +621,5 @@
     }
 };
+*/
 
 
@@ -399,4 +630,24 @@
 // std::string to Vector2
 template <>
+static bool convert(orxonox::Vector2* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 2)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
+// std::string to Vector2
+template <>
 class Converter<std::string, orxonox::Vector2>
 {
@@ -422,5 +673,27 @@
     }
 };
-
+*/
+// std::string to Vector3
+template <>
+static bool convert(orxonox::Vector3* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 3)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to Vector3
 template <>
@@ -450,5 +723,29 @@
     }
 };
-
+*/
+// std::string to Vector4
+template <>
+static bool convert(orxonox::Vector4* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->w), tokens[3]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to Vector4
 template <>
@@ -480,5 +777,29 @@
     }
 };
-
+*/
+// std::string to Quaternion
+template <>
+static bool convert(orxonox::Quaternion* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->w), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->x), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[3]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to Quaternion
 template <>
@@ -510,5 +831,29 @@
     }
 };
-
+*/
+// std::string to ColourValue
+template <>
+static bool convert(orxonox::ColourValue* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->r), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->g), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->b), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->a), tokens[3]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to ColourValue
 template <>
@@ -540,4 +885,6 @@
     }
 };
+*/
+
 
 #endif /* _Convert_H__ */
Index: code/branches/core2/src/util/MultiTypeMath.cc
===================================================================
--- code/branches/core2/src/util/MultiTypeMath.cc	(revision 1000)
+++ code/branches/core2/src/util/MultiTypeMath.cc	(revision 1001)
@@ -89,47 +89,45 @@
 
 MultiTypeMath::operator void*() const
-{ return (this->type_ == MT_void) ? this->value_.void_ : ConvertValueAndReturn<MultiTypeMath, void*>(*this, 0); }
+{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypeMath, void*>(*this, 0); }
 MultiTypeMath::operator int() const
-{ return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypeMath, int>(*this, 0); }
+{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypeMath, int>(*this, 0); }
 MultiTypeMath::operator unsigned int() const
-{ return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypeMath, unsigned int>(*this, 0); }
+{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypeMath, unsigned int>(*this, 0); }
 MultiTypeMath::operator char() const
-{ return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypeMath, char>(*this, 0); }
+{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypeMath, char>(*this, 0); }
 MultiTypeMath::operator unsigned char() const
-{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypeMath, unsigned char>(*this, 0); }
+{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypeMath, unsigned char>(*this, 0); }
 MultiTypeMath::operator short() const
-{ return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypeMath, short>(*this, 0); }
+{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypeMath, short>(*this, 0); }
 MultiTypeMath::operator unsigned short() const
-{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypeMath, unsigned short>(*this, 0); }
+{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypeMath, unsigned short>(*this, 0); }
 MultiTypeMath::operator long() const
-{ return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypeMath, long>(*this, 0); }
+{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypeMath, long>(*this, 0); }
 MultiTypeMath::operator unsigned long() const
-{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypeMath, unsigned long>(*this, 0); }
+{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypeMath, unsigned long>(*this, 0); }
 MultiTypeMath::operator float() const
-{ return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypeMath, float>(*this, 0); }
+{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypeMath, float>(*this, 0); }
 MultiTypeMath::operator double() const
-{ return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypeMath, double>(*this, 0); }
+{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypeMath, double>(*this, 0); }
 MultiTypeMath::operator long double() const
-{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypeMath, long double>(*this, 0); }
+{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypeMath, long double>(*this, 0); }
 MultiTypeMath::operator bool() const
-{ return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypeMath, bool>(*this, 0); }
+{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypeMath, bool>(*this, 0); }
 MultiTypeMath::operator std::string() const
-{ return (this->type_ == MT_string) ? this->string_ : ConvertValueAndReturn<MultiTypeMath, std::string>(*this); }
+{ return (this->type_ == MT_string) ? this->string_ : getConvertedValue<MultiTypeMath, std::string>(*this); }
 MultiTypeMath::operator const char*() const
-{ return ((this->type_ == MT_constchar) ? this->string_ : ConvertValueAndReturn<MultiTypeMath, std::string>(*this)).c_str(); }
+{ return ((this->type_ == MT_constchar) ? this->string_ : getConvertedValue<MultiTypeMath, std::string>(*this)).c_str(); }
 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); }
+{ return (this->type_ == MT_vector2) ? this->vector2_ : getConvertedValue<MultiTypeMath, orxonox::Vector2>(*this); }
 MultiTypeMath::operator orxonox::Vector3() const
-{ return (this->type_ == MT_vector3) ? this->vector3_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Vector3>(*this); }
+{ return (this->type_ == MT_vector3) ? this->vector3_ : getConvertedValue<MultiTypeMath, orxonox::Vector3>(*this); }
 MultiTypeMath::operator orxonox::Quaternion() const
-{ return (this->type_ == MT_quaternion) ? this->quaternion_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Quaternion>(*this); }
+{ return (this->type_ == MT_quaternion) ? this->quaternion_ : getConvertedValue<MultiTypeMath, orxonox::Quaternion>(*this); }
 MultiTypeMath::operator orxonox::ColourValue() const
-{ return (this->type_ == MT_colourvalue) ? this->colourvalue_ : ConvertValueAndReturn<MultiTypeMath, orxonox::ColourValue>(*this); }
+{ return (this->type_ == MT_colourvalue) ? this->colourvalue_ : getConvertedValue<MultiTypeMath, orxonox::ColourValue>(*this); }
 MultiTypeMath::operator orxonox::Radian() const
-{ return (this->type_ == MT_radian) ? this->radian_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Radian>(*this); }
+{ return (this->type_ == MT_radian) ? this->radian_ : getConvertedValue<MultiTypeMath, orxonox::Radian>(*this); }
 MultiTypeMath::operator orxonox::Degree() const
-{ return (this->type_ == MT_degree) ? this->degree_ : ConvertValueAndReturn<MultiTypeMath, orxonox::Degree>(*this); }
+{ return (this->type_ == MT_degree) ? this->degree_ : getConvertedValue<MultiTypeMath, orxonox::Degree>(*this); }
 
 void MultiTypeMath::setValue(const MultiTypeMath& mtm)
@@ -167,11 +165,12 @@
 
     if (this->type_ == MT_vector2)
-        ConvertValue(&output, this->vector2_);
+        ConvertValue(&output, this->vector2_, CP_FromType);
     else if (this->type_ == MT_vector3)
-        ConvertValue(&output, this->vector3_);
+        ConvertValue(&output, this->vector3_, CP_FromType);
     else if (this->type_ == MT_colourvalue)
-        ConvertValue(&output, this->colourvalue_);
+    { std::cout << "3_1\n";
+        ConvertValue(&output, this->colourvalue_, CP_FromType);}
     else if (this->type_ == MT_quaternion)
-        ConvertValue(&output, this->quaternion_);
+        ConvertValue(&output, this->quaternion_, CP_FromType);
     else if (this->type_ == MT_radian)
         ConvertValue(&output, this->radian_);
@@ -187,11 +186,12 @@
 {
     if (this->type_ == MT_vector2)
-        return ConvertValue(&this->vector2_, value, orxonox::Vector2(0, 0));
+        return ConvertValue(&this->vector2_, value, orxonox::Vector2(0, 0), CP_FromType);
     else if (this->type_ == MT_vector3)
-        return ConvertValue(&this->vector3_, value, orxonox::Vector3(0, 0, 0));
+        return ConvertValue(&this->vector3_, value, orxonox::Vector3(0, 0, 0), CP_FromType);
     else if (this->type_ == MT_colourvalue)
-        return ConvertValue(&this->colourvalue_, value, orxonox::ColourValue(0, 0, 0, 0));
+    { std::cout << "4_1\n";
+        return ConvertValue(&this->colourvalue_, value, orxonox::ColourValue(0, 0, 0, 0), CP_FromType); }
     else if (this->type_ == MT_quaternion)
-        return ConvertValue(&this->quaternion_, value, orxonox::Quaternion(1, 0, 0, 0));
+        return ConvertValue(&this->quaternion_, value, orxonox::Quaternion(1, 0, 0, 0), CP_FromType);
     else if (this->type_ == MT_radian)
         return ConvertValue(&this->radian_, value, orxonox::Radian(0));
Index: code/branches/core2/src/util/MultiTypeMath.h
===================================================================
--- code/branches/core2/src/util/MultiTypeMath.h	(revision 1000)
+++ code/branches/core2/src/util/MultiTypeMath.h	(revision 1001)
@@ -54,5 +54,4 @@
         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); }
@@ -106,5 +105,4 @@
         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 1000)
+++ code/branches/core2/src/util/MultiTypePrimitive.cc	(revision 1001)
@@ -135,29 +135,29 @@
 
 MultiTypePrimitive::operator void*() const
-{ return (this->type_ == MT_void) ? this->value_.void_ : ConvertValueAndReturn<MultiTypePrimitive, void*>(*this, 0); }
+{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypePrimitive, void*>(*this, 0); }
 MultiTypePrimitive::operator int() const
-{ return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypePrimitive, int>(*this, 0); }
+{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypePrimitive, int>(*this, 0); }
 MultiTypePrimitive::operator unsigned int() const
-{ return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned int>(*this, 0); }
+{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypePrimitive, unsigned int>(*this, 0); }
 MultiTypePrimitive::operator char() const
-{ return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypePrimitive, char>(*this, 0); }
+{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypePrimitive, char>(*this, 0); }
 MultiTypePrimitive::operator unsigned char() const
-{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned char>(*this, 0); }
+{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypePrimitive, unsigned char>(*this, 0); }
 MultiTypePrimitive::operator short() const
-{ return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypePrimitive, short>(*this, 0); }
+{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypePrimitive, short>(*this, 0); }
 MultiTypePrimitive::operator unsigned short() const
-{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned short>(*this, 0); }
+{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypePrimitive, unsigned short>(*this, 0); }
 MultiTypePrimitive::operator long() const
-{ return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypePrimitive, long>(*this, 0); }
+{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypePrimitive, long>(*this, 0); }
 MultiTypePrimitive::operator unsigned long() const
-{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypePrimitive, unsigned long>(*this, 0); }
+{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypePrimitive, unsigned long>(*this, 0); }
 MultiTypePrimitive::operator float() const
-{ return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypePrimitive, float>(*this, 0); }
+{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypePrimitive, float>(*this, 0); }
 MultiTypePrimitive::operator double() const
-{ return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypePrimitive, double>(*this, 0); }
+{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypePrimitive, double>(*this, 0); }
 MultiTypePrimitive::operator long double() const
-{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypePrimitive, long double>(*this, 0); }
+{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypePrimitive, long double>(*this, 0); }
 MultiTypePrimitive::operator bool() const
-{ return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypePrimitive, bool>(*this, 0); }
+{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypePrimitive, bool>(*this, 0); }
 
 void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
Index: code/branches/core2/src/util/MultiTypeString.cc
===================================================================
--- code/branches/core2/src/util/MultiTypeString.cc	(revision 1000)
+++ code/branches/core2/src/util/MultiTypeString.cc	(revision 1001)
@@ -43,6 +43,4 @@
         else if (this->type_ == MT_string)
             return (this->string_ == mts.string_);
-        else if (this->type_ == MT_xmlelement)
-            return (&this->xmlelement_ == &mts.xmlelement_);
     }
 
@@ -58,6 +56,4 @@
         else if (this->type_ == MT_string)
             return (this->string_ != mts.string_);
-        else if (this->type_ == MT_xmlelement)
-            return (&this->xmlelement_ != &mts.xmlelement_);
     }
 
@@ -66,35 +62,33 @@
 
 MultiTypeString::operator void*() const
-{ return (this->type_ == MT_void) ? this->value_.void_ : ConvertValueAndReturn<MultiTypeString, void*>(*this, 0); }
+{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypeString, void*>(*this, 0); }
 MultiTypeString::operator int() const
-{ return (this->type_ == MT_int) ? this->value_.int_ : ConvertValueAndReturn<MultiTypeString, int>(*this, 0); }
+{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypeString, int>(*this, 0); }
 MultiTypeString::operator unsigned int() const
-{ return (this->type_ == MT_uint) ? this->value_.uint_ : ConvertValueAndReturn<MultiTypeString, unsigned int>(*this, 0); }
+{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypeString, unsigned int>(*this, 0); }
 MultiTypeString::operator char() const
-{ return (this->type_ == MT_char) ? this->value_.char_ : ConvertValueAndReturn<MultiTypeString, char>(*this, 0); }
+{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypeString, char>(*this, 0); }
 MultiTypeString::operator unsigned char() const
-{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : ConvertValueAndReturn<MultiTypeString, unsigned char>(*this, 0); }
+{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypeString, unsigned char>(*this, 0); }
 MultiTypeString::operator short() const
-{ return (this->type_ == MT_short) ? this->value_.short_ : ConvertValueAndReturn<MultiTypeString, short>(*this, 0); }
+{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypeString, short>(*this, 0); }
 MultiTypeString::operator unsigned short() const
-{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : ConvertValueAndReturn<MultiTypeString, unsigned short>(*this, 0); }
+{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypeString, unsigned short>(*this, 0); }
 MultiTypeString::operator long() const
-{ return (this->type_ == MT_long) ? this->value_.long_ : ConvertValueAndReturn<MultiTypeString, long>(*this, 0); }
+{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypeString, long>(*this, 0); }
 MultiTypeString::operator unsigned long() const
-{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : ConvertValueAndReturn<MultiTypeString, unsigned long>(*this, 0); }
+{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypeString, unsigned long>(*this, 0); }
 MultiTypeString::operator float() const
-{ return (this->type_ == MT_float) ? this->value_.float_ : ConvertValueAndReturn<MultiTypeString, float>(*this, 0); }
+{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypeString, float>(*this, 0); }
 MultiTypeString::operator double() const
-{ return (this->type_ == MT_double) ? this->value_.double_ : ConvertValueAndReturn<MultiTypeString, double>(*this, 0); }
+{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypeString, double>(*this, 0); }
 MultiTypeString::operator long double() const
-{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : ConvertValueAndReturn<MultiTypeString, long double>(*this, 0); }
+{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypeString, long double>(*this, 0); }
 MultiTypeString::operator bool() const
-{ return (this->type_ == MT_bool) ? this->value_.bool_ : ConvertValueAndReturn<MultiTypeString, bool>(*this, 0); }
+{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypeString, bool>(*this, 0); }
 MultiTypeString::operator std::string() const
-{ return (this->type_ == MT_string) ? this->string_ : ConvertValueAndReturn<MultiTypeString, std::string>(*this); }
+{ return (this->type_ == MT_string) ? this->string_ : getConvertedValue<MultiTypeString, std::string>(*this); }
 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); }
+{ return ((this->type_ == MT_constchar) ? this->string_ : getConvertedValue<MultiTypeString, std::string>(*this)).c_str(); }
 
 void MultiTypeString::setValue(const MultiTypeString& mts)
@@ -110,6 +104,4 @@
     else if (this->type_ == MT_string)
         return "string";
-    else if (this->type_ == MT_xmlelement)
-        return "XML-element";
     else
         return MultiTypePrimitive::getTypename();
@@ -124,6 +116,4 @@
     else if (this->type_ == MT_string)
         return this->string_;
-    else if (this->type_ == MT_xmlelement)
-        ConvertValue(&output, this->xmlelement_);
     else
         return MultiTypePrimitive::toString();
@@ -138,6 +128,4 @@
     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 1000)
+++ code/branches/core2/src/util/MultiTypeString.h	(revision 1001)
@@ -33,6 +33,4 @@
 #include <iostream>
 #include "UtilPrereqs.h"
-#include "XMLIncludes.h"
-#include "tinyxml/ticpp.h"
 
 #include "MultiTypePrimitive.h"
@@ -57,5 +55,4 @@
         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() {}
@@ -64,5 +61,4 @@
         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; }
 
@@ -70,5 +66,4 @@
         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;
 
@@ -76,5 +71,4 @@
         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;
 
@@ -94,24 +88,19 @@
         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 orxonox::Element& value) { this->type_ = MT_xmlelement; this->xmlelement_ = value;              }
         void setValue(const MultiTypeString& mts);
 
         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 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(orxonox::Element* variable) const { (*variable) = this->xmlelement_;     }
 
         virtual std::string getTypename() const;
@@ -122,5 +111,4 @@
     protected:
         std::string      string_;
-        orxonox::Element xmlelement_;
 };
 
Index: code/branches/core2/src/util/UtilPrereqs.h
===================================================================
--- code/branches/core2/src/util/UtilPrereqs.h	(revision 1000)
+++ code/branches/core2/src/util/UtilPrereqs.h	(revision 1001)
@@ -60,6 +60,6 @@
 //-----------------------------------------------------------------------
 class Convert;
-template <typename FromType, typename ToType>
-class Converter;
+//template <typename FromType, typename ToType>
+//class Converter;
 class MultiTypePrimitive;
 class MultiTypeString;
