Index: code/trunk/src/CMakeLists.txt
===================================================================
--- code/trunk/src/CMakeLists.txt	(revision 7380)
+++ code/trunk/src/CMakeLists.txt	(revision 7401)
@@ -116,5 +116,5 @@
 ADD_SUBDIRECTORY(modules)
 
-################ Executable ################
+################## Executable ###################
 
 INCLUDE_DIRECTORIES(
@@ -137,4 +137,6 @@
   OUTPUT_NAME orxonox
 )
+# Main executable should depend on all modules
+ADD_DEPENDENCIES(orxonox-main ${ORXONOX_MODULES})
 
 # Get name to configure the run scripts
@@ -161,2 +163,14 @@
   CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/orxonox-main.vcproj.user.in" "${CMAKE_CURRENT_BINARY_DIR}/orxonox-main.vcproj.user")
 ENDIF(MSVC)
+
+#################### Doxygen ####################
+
+# Prepare include paths for Doxygen. This is necessary to display
+# the correct path to use when including a file, e.g.
+# core/XMLPort.h instead of src/core/XMLPort.h
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/modules)
+GET_DIRECTORY_PROPERTY(_temp INCLUDE_DIRECTORIES)
+# Replace ';' by spaces
+STRING(REPLACE ";" " " _temp "${_temp}")
+SET(DOXYGEN_INCLUDE_DIRECTORIES "${_temp}" PARENT_SCOPE)
Index: code/trunk/src/OrxonoxConfig.h.in
===================================================================
--- code/trunk/src/OrxonoxConfig.h.in	(revision 7380)
+++ code/trunk/src/OrxonoxConfig.h.in	(revision 7401)
@@ -145,9 +145,5 @@
  * Options
  *-------------------------------*/
-/**
-@def ORXONOX_RELEASE
-    Enables expensive (build time) optimisations and disables certain features
-*/
-#cmakedefine ORXONOX_RELEASE
+#cmakedefine ORXONOX_RELEASE  ///< Enables expensive (build time) optimisations and disables certain features
 
 
Index: code/trunk/src/SpecialConfig.h.in
===================================================================
--- code/trunk/src/SpecialConfig.h.in	(revision 7380)
+++ code/trunk/src/SpecialConfig.h.in	(revision 7401)
@@ -42,29 +42,11 @@
 #include "OrxonoxConfig.h"
 
-/**
-@def CEGUILUA_USE_INTERNAL_LIBRARY
-    Set whether we must suffix "ceguilua/" for the CEGUILua.h include
-*/
-#cmakedefine CEGUILUA_USE_INTERNAL_LIBRARY
+#cmakedefine CEGUILUA_USE_INTERNAL_LIBRARY  ///< Set whether we must suffix "ceguilua/" for the CEGUILua.h include
 
-/**
-@def DEPENDENCY_PACKAGE_ENABLE
-    Defined if a precompiled depdency package was used. We then copy all libraries
-    too when installing.
-*/
-#cmakedefine DEPENDENCY_PACKAGE_ENABLE
+#cmakedefine DEPENDENCY_PACKAGE_ENABLE      ///< Defined if a precompiled depdency package was used. We then copy all libraries too when installing.
 
-/**
-@def INSTALL_COPYABLE
-    Orxonox either gets installed to the system or just into a folder.
-    The latter uses relative paths.
-*/
-#cmakedefine INSTALL_COPYABLE
+#cmakedefine INSTALL_COPYABLE               ///< Orxonox either gets installed to the system or just into a folder. The latter uses relative paths.
 
-/**
-@def CMAKE_CONFIGURATION_TYPES
-    Using MSVC or XCode IDE
-*/
-#cmakedefine CMAKE_CONFIGURATION_TYPES
+#cmakedefine CMAKE_CONFIGURATION_TYPES      ///< Using MSVC or XCode IDE
 
 // Handle default ConfigValues
@@ -125,9 +107,5 @@
 } }
 
-/**
-@def ORXONOX_USE_WINMAIN
-    Use main() or WinMain()?
-*/
-#cmakedefine ORXONOX_USE_WINMAIN
+#cmakedefine ORXONOX_USE_WINMAIN  ///< Using MSVC or XCode IDE
 
 #endif /* _SpecialConfig_H__ */
Index: code/trunk/src/libraries/CMakeLists.txt
===================================================================
--- code/trunk/src/libraries/CMakeLists.txt	(revision 7380)
+++ code/trunk/src/libraries/CMakeLists.txt	(revision 7401)
@@ -18,8 +18,5 @@
  #
 
-INCLUDE_DIRECTORIES(
-  ${CMAKE_SOURCE_DIR}/src/external
-  ${CMAKE_CURRENT_SOURCE_DIR}
-)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
 ################ Sub Directories ################
Index: code/trunk/src/libraries/core/BaseObject.cc
===================================================================
--- code/trunk/src/libraries/core/BaseObject.cc	(revision 7380)
+++ code/trunk/src/libraries/core/BaseObject.cc	(revision 7401)
@@ -116,5 +116,5 @@
         @brief XML loading and saving.
         @param xmlelement The XML-element
-        @param loading Loading (true) or saving (false)
+        @param mode The mode defines the operation that is being executed: loading or saving the object (from or to XML respectively)
     */
     void BaseObject::XMLPort(Element& xmlelement, XMLPort::Mode mode)
@@ -141,5 +141,5 @@
         @brief Defines the possible event states of this object and parses eventsources from an XML file.
         @param xmlelement The XML-element
-        @param loading Loading (true) or saving (false)
+        @param mode The mode defines the operation that is being executed: loading or saving the object (from or to XML respectively)
     */
     void BaseObject::XMLEventPort(Element& xmlelement, XMLPort::Mode mode)
Index: code/trunk/src/libraries/core/BaseObject.h
===================================================================
--- code/trunk/src/libraries/core/BaseObject.h	(revision 7380)
+++ code/trunk/src/libraries/core/BaseObject.h	(revision 7401)
@@ -28,6 +28,12 @@
 
 /**
+    @defgroup BaseObject BaseObject
+    @ingroup Core
+*/
+
+/**
     @file
-    @brief Definition of the BaseObject class.
+    @ingroup BaseObject
+    @brief Declaration of BaseObject, the base class of all objects in Orxonox.
 
     The BaseObject is the parent of all classes representing an instance in the game.
@@ -53,5 +59,5 @@
     class Level;
 
-    //! The BaseObject is the parent of all classes representing an instance in the game.
+    /// The BaseObject is the parent of all classes representing an instance in the game.
     class _CoreExport BaseObject : virtual public OrxonoxClass
     {
Index: code/trunk/src/libraries/core/ClassFactory.h
===================================================================
--- code/trunk/src/libraries/core/ClassFactory.h	(revision 7380)
+++ code/trunk/src/libraries/core/ClassFactory.h	(revision 7401)
@@ -29,7 +29,8 @@
 /**
     @file
+    @ingroup Object Factory
     @brief Definition and implementation of the ClassFactory class
 
-    The ClassFactory is able to create new objects of a specific class.
+    The ClassFactory is able to create new objects of a specific class which creates objects.
 */
 
@@ -49,5 +50,5 @@
     // ###       Factory       ###
     // ###########################
-    //! Base-class of ClassFactory.
+    /// Base-class of ClassFactory.
     class _CoreExport Factory
     {
@@ -60,5 +61,5 @@
     // ###      ClassFactory       ###
     // ###############################
-    //! The ClassFactory is able to create new objects of a specific class.
+    /// The ClassFactory is able to create new objects of a specific class.
     template <class T>
     class ClassFactory : public Factory
Index: code/trunk/src/libraries/core/ClassTreeMask.cc
===================================================================
--- code/trunk/src/libraries/core/ClassTreeMask.cc	(revision 7380)
+++ code/trunk/src/libraries/core/ClassTreeMask.cc	(revision 7401)
@@ -29,5 +29,5 @@
 /**
     @file
-    @brief Implementation of the ClassTreeMask, ClassTreeMaskNode and ClassTreeMaskIterator classes.
+    @brief Implementation of the ClassTreeMask, ClassTreeMaskNode, and ClassTreeMaskIterator classes.
 */
 
@@ -93,5 +93,4 @@
     /**
         @brief Adds a new subnode to the list of subnodes.
-        @param subnode The new subnode
     */
     void ClassTreeMaskNode::addSubnode(ClassTreeMaskNode* subnode)
@@ -178,5 +177,4 @@
     /**
         @brief Returns a pointer to the ClassTreeMaskNode whereon the iterator points.
-        @return The pointer to the node
     */
     ClassTreeMaskNode* ClassTreeMaskIterator::operator*() const
@@ -187,5 +185,4 @@
     /**
         @brief Returns a pointer to the ClassTreeMaskNode whereon the iterator points.
-        @return The pointer to the node
     */
     ClassTreeMaskNode* ClassTreeMaskIterator::operator->() const
@@ -196,5 +193,4 @@
     /**
         @brief Returns true if the stack is empty, meaning we've reached the end of the tree.
-        @return True if we've reached the end of the tree
     */
     ClassTreeMaskIterator::operator bool() const
@@ -205,6 +201,4 @@
     /**
         @brief Compares the current node with the given one and returns true if they match.
-        @param compare The node to compare with
-        @return The result of the comparison (true if they match)
     */
     bool ClassTreeMaskIterator::operator==(ClassTreeMaskNode* compare) const
@@ -218,6 +212,4 @@
     /**
         @brief Compares the current node with the given one and returns true if they don't match.
-        @param compare The node to compare with
-        @return The result of the comparison (true if they don't match)
     */
     bool ClassTreeMaskIterator::operator!=(ClassTreeMaskNode* compare) const
@@ -242,6 +234,5 @@
 
     /**
-        @brief Copyconstructor: Adds the root-node of the tree with the first rule ("include everything") and adds all rules from the other mask.
-        @param other The other mask
+        @brief Copy-constructor: Adds the root-node of the tree with the first rule ("include everything") and adds all rules from the other mask.
     */
     ClassTreeMask::ClassTreeMask(const ClassTreeMask& other)
Index: code/trunk/src/libraries/core/ClassTreeMask.h
===================================================================
--- code/trunk/src/libraries/core/ClassTreeMask.h	(revision 7380)
+++ code/trunk/src/libraries/core/ClassTreeMask.h	(revision 7401)
@@ -29,14 +29,19 @@
 /**
     @file
-    @brief Definition of the ClassTreeMask, ClassTreeMaskNode and ClassTreeMaskIterator classes.
-
-    ClassTreeMask is a class to define a mask of the class-tree beginning with BaseObject.
+    @ingroup Class
+    @brief Declaration of the ClassTreeMask, ClassTreeMaskNode, and ClassTreeMaskIterator classes.
+
+    ClassTreeMask is a class to define a mask of the class-tree beginning with orxonox::BaseObject.
     You can include or exclude classes by calling the corresponding functions with the
-    Identifier of the class.
+    orxonox::Identifier of the class. This mask can then be used to filter out objects that
+    are instances of classes which aren't included in the tree, for example when Loading a
+    level file or if a Trigger should be triggered by only a few classes.
+
+    See the description of orxonox::ClassTreeMask for a short example.
 
     You can work with a ClassTreeMask in the sense of the set-theory, meaning that you can create
     unions, intersections, complements and differences by using overloaded operators.
 
-
+    @par Tree structure
 
     The ClassTreeMask is internally represented by a tree. The nodes in the tree are
@@ -45,25 +50,17 @@
     nodes changing the mask. By adding new rules, the tree gets reordered dynamically.
 
-    Adding a new rule overwrites all rules assigned to inherited classes. Use overwrite = false
+    Adding a new rule overwrites all rules assigned to inherited classes. Use <tt>overwrite = false</tt>
     if you don't like this feature. Useless rules that don't change the information of the mask
-    aren't saved in the internal tree. Use clean = false if you wan't to save them.
-
-    With overwrite = false and clean = false it doesn't matter in which way you create the mask.
-    You can manually drop useless rules from the tree by calling clean().
-
-
-
-    Because of the complicated shape of the internal tree, there is an iterator to iterate
-    through all ClassTreeMaskNodes of a mask. It starts with the BaseObject and moves on to
-    the first subclass until it reaches a leaf of the tree. Then the iterator moves one step
-    back and iterates to the second subclass. If there are no more subclasses, it steps another
-    step back, and so on.
-
-    Example: A and B are children of BaseObject, A1 and A2 are children of A, B1 and B2 are children of B.
-    The ClassTreeMaskIterator would move trough the tree in the following order:
-    BaseObject, A, A1, A2, B, B1, B2.
-
-    Note that the iterator doesn't move trough the whole class-tree, but only through the
-    internal tree of the mask, containing the minimal needed set of nodes to describe the mask.
+    aren't saved in the internal tree. Use <tt>clean = false</tt> if you still want to save them.
+
+    With <tt>overwrite = false</tt> and <tt>clean = false</tt> it doesn't matter in which order
+    you create the mask. You can manually drop useless rules from the tree by calling
+    @ref orxonox::ClassTreeMask::clean() "clean()".
+
+    @par Objects
+
+    To iterate through all objects of the classes that were included by a ClassTreeMask,
+    use orxonox::ClassTreeMaskObjectIterator. The description of this class also contains
+    a short example of how to use it.
 */
 
@@ -83,6 +80,7 @@
     // ###      ClassTreeMaskNode      ###
     // ###################################
-    //! The ClassTreeMaskNode is a node in the internal tree of the ClassTreeMask, containing the rules of the mask.
     /**
+        @brief The ClassTreeMaskNode is a node in the internal tree of the ClassTreeMask, containing the rules of the mask.
+
         The ClassTreeMaskNode is used to store the rule (included or excluded) for a given
         class (described by the corresponding Identifier). The nodes are used in the internal
@@ -105,13 +103,13 @@
             void addSubnode(ClassTreeMaskNode* subnode);
 
-            /** @brief Tells if the rule is "included" or not. @return The rule: true = included, false = excluded */
+            /// Tells if the rule is "included" or not.
             inline bool isIncluded() const { return this->bIncluded_; }
-            /** @brief Tells if the rule is "excluded" or not. @return The inverted rule: true = excluded, false = included */
+            /// Tells if the rule is "excluded" or not.
             inline bool isExcluded() const { return (!this->bIncluded_); }
 
-            /** @brief Returns the Identifier of the class the rule refers to. @return The Identifier representing the class */
+            /// Returns the Identifier of the class the rule refers to.
             inline const Identifier* getClass() const { return this->subclass_; }
 
-            /** @brief Returns true if the Node has some subnodes. */
+            /// Returns true if the node has some subnodes.
             inline bool hasSubnodes() const { return !this->subnodes_.empty(); }
 
@@ -119,7 +117,7 @@
             void deleteAllSubnodes();
 
-            const Identifier* subclass_;                //!< The Identifier of the subclass the rule refers to
-            bool bIncluded_;                            //!< The rule: included or excluded
-            std::list<ClassTreeMaskNode*> subnodes_;    //!< A list containing all subnodes in the tree
+            const Identifier* subclass_;                ///< The Identifier of the subclass the rule refers to
+            bool bIncluded_;                            ///< The rule: included or excluded
+            std::list<ClassTreeMaskNode*> subnodes_;    ///< A list containing all subnodes of this node
     };
 
@@ -128,6 +126,7 @@
     // ###    ClassTreeMaskIterator    ###
     // ###################################
-    //! The ClassTreeMaskIterator moves through all ClassTreeMaskNodes of the internal tree of a ClassTreeMask, containing the rules.
     /**
+        @brief The ClassTreeMaskIterator moves through all ClassTreeMaskNodes of the internal tree of a ClassTreeMask which contains the rules.
+
         Because of the complicated shape of the internal rule-tree of ClassTreeMask, an
         iterator is used to move through all nodes of the tree. It starts with the BaseObject
@@ -135,4 +134,11 @@
         iterator moves one step back and iterates to the second subclass. If there are no more
         subclasses, it steps another step back, and so on.
+
+        Example: A and B are children of BaseObject, A1 and A2 are children of A, B1 and B2 are children of B.
+        The ClassTreeMaskIterator would move trough the tree in the following order:
+        BaseObject, A, A1, A2, B, B1, B2.
+
+        Note that the iterator doesn't move trough the whole class-tree, but only through the
+        internal tree of the mask, containing the minimal needed set of nodes to describe the mask.
     */
     class _CoreExport ClassTreeMaskIterator
@@ -150,6 +156,6 @@
 
         private:
-            std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator> > nodes_;    //!< A stack to store list-iterators
-            std::list<ClassTreeMaskNode*> rootlist_;                                                                            //!< A list for internal use (it only stores the root-node)
+            std::stack<std::pair<std::list<ClassTreeMaskNode*>::iterator, std::list<ClassTreeMaskNode*>::iterator> > nodes_;    ///< A stack to store list-iterators
+            std::list<ClassTreeMaskNode*> rootlist_;                                                                            ///< A list for internal use (it only stores the root-node)
     };
 
@@ -158,11 +164,23 @@
     // ###        ClassTreeMask        ###
     // ###################################
-    //! The ClassTreeMask is a set of rules, containing the information for each class whether it's included or not.
     /**
+        @brief The ClassTreeMask is a set of rules, containing the information for each class whether it's included or not.
+
         With a ClassTreeMask, you can include or exclude subtrees of the class-tree, starting
         with a given subclass, described by the corresponding Identifier. To minimize the size
         of the mask, the mask saves only relevant rules. But you can manually add rules that
-        don't change the information of the mask by using clean = false. If you want to drop
+        don't change the information of the mask by using <tt>clean = false</tt>. If you want to drop
         useless rules, call the clean() function.
+
+        Example:
+        @code
+        ClassTreeMask mymask;
+        mymask.exclude(Class(A));
+        mymask.exclude(Class(B));
+        mymask.include(Class(ChildOfA));
+        @endcode
+
+        In this example, the classes A and B are excluded from the mask, but one of the child
+        classes of A is included again.
     */
     class _CoreExport ClassTreeMask
@@ -189,7 +207,7 @@
             bool isExcluded(const Identifier* subclass) const;
 
-            /** @brief Begin of the ClassTreeMaskObjectIterator. */
+            /// Begin of the ClassTreeMaskObjectIterator.
             inline const ClassTreeMask& begin() const { return (*this); }
-            /** @brief End of the ClassTreeMaskObjectIterator. */
+            /// End of the ClassTreeMaskObjectIterator.
             inline BaseObject*          end()   const { return 0; }
 
@@ -228,5 +246,5 @@
             bool nodeExists(const Identifier* subclass);
 
-            ClassTreeMaskNode* root_;   //!< The root-node of the internal rule-tree, usually BaseObject
+            ClassTreeMaskNode* root_;   ///< The root-node of the internal rule-tree, usually BaseObject
     };
 
@@ -235,17 +253,18 @@
     // ### ClassTreeMaskObjectIterator ###
     // ###################################
-    //! The ClassTreeMaskObjectIterator iterates through all objects of all classes, included by a ClassTreeMask.
     /**
-        The ClassTreeMaskObjectIterator iterates through all objects of all classes,
-        included by a ClassTreeMask. This is done the following way:
-
+        @brief The ClassTreeMaskObjectIterator iterates through all objects of the classes that were included by a ClassTreeMask.
+
+        This is done the following way:
+        @code
         ClassTreeMask mask;
         for (ClassTreeMaskObjectIterator it = mask.begin(); it != mask.end(); ++it)
             it->doSomething();
-
-        Note: The ClassTreeMaskObjectIterator handles all objects as BaseObjects. If
+        @endcode
+
+        @note The ClassTreeMaskObjectIterator handles all objects as BaseObjects. If
               you want to use another class, you should use a dynamic_cast.
 
-        Performance of ClassTreeMaskObjectIterator is good as long as you don't exclude
+        The performance of ClassTreeMaskObjectIterator is good as long as you don't exclude
         subclasses of included classes. Of course you can still exlucde subclasses, but
         if this is done more often, we need a new implementation using a second ObjectList
@@ -255,7 +274,7 @@
     {
         public:
-            /** @brief Defaultconstructor: Does nothing. */
+            /// Default-constructor: Does nothing.
             inline ClassTreeMaskObjectIterator() {}
-            /** @brief Constructor: Initializes the iterator from a given ClassTreeMask. @param mask The mask */
+            /// Copy-Constructor: Initializes the iterator from another ClassTreeMask.
             inline ClassTreeMaskObjectIterator(const ClassTreeMask& mask) { (*this) = mask; }
 
@@ -264,13 +283,13 @@
             const ClassTreeMaskObjectIterator& operator++();
 
-            /** @brief Returns true if the ClassTreeMaskObjectIterator points at the given object. @param pointer The pointer of the object */
+            /// Returns true if the ClassTreeMaskObjectIterator points at the given object.
             inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == 0); }
-            /** @brief Returns true if the ClassTreeMaskObjectIterator doesn't point at the given object. @param pointer The pointer of the object */
+            /// Returns true if the ClassTreeMaskObjectIterator doesn't point at the given object.
             inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != 0); }
-            /** @brief Returns true if the ClassTreeMaskObjectIterator hasn't already reached the end. */
+            /// Returns true if the ClassTreeMaskObjectIterator hasn't already reached the end.
             inline operator bool() const { return (this->objectIterator_); }
-            /** @brief Returns the object the ClassTreeMaskObjectIterator currently points at. */
+            /// Returns the object the ClassTreeMaskObjectIterator currently points at.
             inline BaseObject* operator*() const { return (*this->objectIterator_); }
-            /** @brief Returns the object the ClassTreeMaskObjectIterator currently points at. */
+            /// Returns the object the ClassTreeMaskObjectIterator currently points at.
             inline BaseObject* operator->() const { return (*this->objectIterator_); }
 
@@ -278,7 +297,7 @@
             void create(ClassTreeMaskNode* node);
 
-            std::list<std::pair<const Identifier*, bool> >           subclasses_;       //!< A list of all Identifiers through which objects the iterator should iterate
-            std::list<std::pair<const Identifier*, bool> >::iterator subclassIterator_; //!< The current class of the iterator
-            Iterator<BaseObject>                                     objectIterator_;   //!< The current object of the iterator
+            std::list<std::pair<const Identifier*, bool> >           subclasses_;       ///< A list of all Identifiers through which objects the iterator should iterate
+            std::list<std::pair<const Identifier*, bool> >::iterator subclassIterator_; ///< The current class of the iterator
+            Iterator<BaseObject>                                     objectIterator_;   ///< The current object of the iterator
     };
 }
Index: code/trunk/src/libraries/core/CommandLineParser.cc
===================================================================
--- code/trunk/src/libraries/core/CommandLineParser.cc	(revision 7380)
+++ code/trunk/src/libraries/core/CommandLineParser.cc	(revision 7401)
@@ -126,4 +126,6 @@
     @param arguments
         Vector of space separated strings.
+    @param bParsingFile
+        Parsing a file or the command line itself
     */
     void CommandLineParser::_parse(const std::vector<std::string>& arguments, bool bParsingFile)
@@ -244,4 +246,6 @@
     @param value
         String containing the value
+    @param bParsingFile
+        Parsing a file or the command line itself
     */
     void CommandLineParser::checkFullArgument(const std::string& name, const std::string& value, bool bParsingFile)
@@ -258,7 +262,9 @@
         Parses an argument based on its shortcut.
     @param shortcut
-        Shotcut to the argument
+        Shortcut to the argument
     @param value
         String containing the value
+    @param bParsingFile
+        Parsing a file or the command line itself
     */
     void CommandLineParser::checkShortcut(const std::string& shortcut, const std::string& value, bool bParsingFile)
@@ -308,4 +314,13 @@
     }
 
+    void CommandLineParser::generateDoc(std::ofstream& file)
+    {
+        file << "/** @page cmdargspage Command Line Arguments Reference" << endl;
+        file << "    @verbatim"; /*no endl*/
+        file << getUsageInformation(); /*no endl*/
+        file << "    @endverbatim" << endl;
+        file << "*/" << endl;
+    }
+
     /**
     @brief
@@ -313,5 +328,5 @@
         The method throws an exception if 'name' was not found or the value could not be converted.
     @note
-        You shold of course not call this method before the command line has been parsed.
+        You should of course not call this method before the command line has been parsed.
     */
     const CommandLineArgument* CommandLineParser::getArgument(const std::string& name)
Index: code/trunk/src/libraries/core/CommandLineParser.h
===================================================================
--- code/trunk/src/libraries/core/CommandLineParser.h	(revision 7380)
+++ code/trunk/src/libraries/core/CommandLineParser.h	(revision 7401)
@@ -27,4 +27,16 @@
  */
 
+/**
+    @defgroup CmdArgs Commandline arguments
+    @ingroup Config
+    @brief For a reference of all commandline arguments see @ref cmdargspage
+*/
+
+/**
+    @file
+    @ingroup Config CmdArgs
+    @brief Declaration of CommandLineParser and CommandLineArgument, definition of the SetCommandLineArgument() macros.
+*/
+
 #ifndef _CommandLine_H__
 #define _CommandLine_H__
@@ -32,4 +44,5 @@
 #include "CorePrereqs.h"
 
+#include <fstream>
 #include <map>
 #include "util/OrxAssert.h"
@@ -165,4 +178,6 @@
         static void destroyAllArguments();
 
+        static void generateDoc(std::ofstream& file);
+
     private:
         //! Constructor initialises bFirstTimeParse_ with true.
@@ -207,4 +222,6 @@
     @param defaultValue
         Default value that is used when argument was not given.
+    @param bCommandLineOnly
+        Parsing a file or the command line itself
     */
     template <class T>
Index: code/trunk/src/libraries/core/ConfigFileManager.cc
===================================================================
--- code/trunk/src/libraries/core/ConfigFileManager.cc	(revision 7380)
+++ code/trunk/src/libraries/core/ConfigFileManager.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Implementation of ConfigFileManager and its helper classes.
+*/
+
 #include "ConfigFileManager.h"
 
@@ -43,5 +48,7 @@
     // ConfigFileEntryValue //
     //////////////////////////
-
+    /**
+        @brief Updates the string that will be stored in the file after one of it's components (name, value, comment) has changed.
+    */
     void ConfigFileEntryValue::update()
     {
@@ -63,4 +70,7 @@
     // ConfigFileEntryVectorValue //
     ////////////////////////////////
+    /**
+        @brief Updates the string that will be stored in the file after one of it's components (name, value, index, comment) has changed.
+    */
     void ConfigFileEntryVectorValue::update()
     {
@@ -73,4 +83,7 @@
     // ConfigFileSection //
     ///////////////////////
+    /**
+        @brief Destructor: Deletes all entries.
+    */
     ConfigFileSection::~ConfigFileSection()
     {
@@ -79,4 +92,10 @@
     }
 
+    /**
+        @brief Deletes all elements of a config vector if their index is greater or equal to @a startindex.
+
+        @param name         The name of the vector
+        @param startindex   The index of the first element that will be deleted
+    */
     void ConfigFileSection::deleteVectorEntries(const std::string& name, unsigned int startindex)
     {
@@ -95,4 +114,8 @@
     }
 
+    /**
+        @brief Returns the size of a config vector.
+        @param name     The name of the vector
+    */
     unsigned int ConfigFileSection::getVectorSize(const std::string& name) const
     {
@@ -108,4 +131,7 @@
     }
 
+    /**
+        @brief Returns the title and comment of the section as it will be stored in the file.
+    */
     std::string ConfigFileSection::getFileEntry() const
     {
@@ -116,4 +142,9 @@
     }
 
+    /**
+        @brief Returns the entry with given name (or NULL if it doesn't exist).
+
+        @param name     The name of the entry
+    */
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name) const
     {
@@ -126,4 +157,10 @@
     }
 
+    /**
+        @brief Returns the entry of a vector element with given name and index (or NULL if it doesn't exist).
+
+        @param name     The name of the vector
+        @param index    The index of the element in the vector
+    */
     ConfigFileEntry* ConfigFileSection::getEntry(const std::string& name, unsigned int index) const
     {
@@ -136,4 +173,11 @@
     }
 
+    /**
+        @brief Returns the iterator to the entry with given name. If the entry doesn't exist, it is created using the fallback value.
+
+        @param name     The name of the entry
+        @param fallback The value that will be used if the entry doesn't exist
+        @param bString  If true, the value is treated as string which means some special treatment of special characters.
+    */
     std::list<ConfigFileEntry*>::iterator ConfigFileSection::getOrCreateEntryIterator(const std::string& name, const std::string& fallback, bool bString)
     {
@@ -152,4 +196,12 @@
     }
 
+    /**
+        @brief Returns the iterator to the entry of a vector element with given name and index. If the entry doesn't exist, it is created using the fallback value.
+
+        @param name     The name of the vector
+        @param index    The index of the element in the vector
+        @param fallback The value that will be used if the entry doesn't exist
+        @param bString  If true, the value is treated as string which means some special treatment of special characters.
+    */
     std::list<ConfigFileEntry*>::iterator ConfigFileSection::getOrCreateEntryIterator(const std::string& name, unsigned int index, const std::string& fallback, bool bString)
     {
@@ -178,4 +230,9 @@
     const char* ConfigFile::DEFAULT_CONFIG_FOLDER = "defaultConfig";
 
+    /**
+        @brief Constructor: Initializes the config file.
+        @param filename The file-name of this config file
+        @param bCopyFallbackFile If true, the default config file is copied into the config-directory before loading the file
+    */
     ConfigFile::ConfigFile(const std::string& filename, bool bCopyFallbackFile)
         : filename_(filename)
@@ -185,4 +242,7 @@
     }
 
+    /**
+        @brief Destructor: Deletes all sections and entries.
+    */
     ConfigFile::~ConfigFile()
     {
@@ -190,4 +250,7 @@
     }
 
+    /**
+        @brief Loads the config file from the hard-disk and reads the sections and their values.
+    */
     void ConfigFile::load()
     {
@@ -318,4 +381,7 @@
     }
 
+    /**
+        @brief Writes the sections and values to the hard-disk.
+    */
     void ConfigFile::save() const
     {
@@ -323,4 +389,7 @@
     }
 
+    /**
+        @brief Writes the sections and values to a given file on the hard-disk.
+    */
     void ConfigFile::saveAs(const std::string& filename) const
     {
@@ -354,4 +423,7 @@
     }
 
+    /**
+        @brief Deletes all sections (which again delete all their values) and clears the list of sections.
+    */
     void ConfigFile::clear()
     {
@@ -361,18 +433,11 @@
     }
 
-    const std::string& ConfigFile::getOrCreateValue(const std::string& section, const std::string& name, const std::string& fallback, bool bString)
-    {
-        const std::string& output = this->getOrCreateSection(section)->getOrCreateValue(name, fallback, bString);
-        this->saveIfUpdated();
-        return output;
-    }
-
-    const std::string& ConfigFile::getOrCreateValue(const std::string& section, const std::string& name, unsigned int index, const std::string& fallback, bool bString)
-    {
-        const std::string& output = this->getOrCreateSection(section)->getOrCreateValue(name, index, fallback, bString);
-        this->saveIfUpdated();
-        return output;
-    }
-
+    /**
+        @brief Deletes all elements of a config vector if their index is greater or equal to @a startindex.
+
+        @param section      The name of the section
+        @param name         The name of the vector
+        @param startindex   The index of the first element that will be deleted
+    */
     void ConfigFile::deleteVectorEntries(const std::string& section, const std::string& name, unsigned int startindex)
     {
@@ -384,4 +449,7 @@
     }
 
+    /**
+        @brief Returns a pointer to the section with given name (or NULL if the section doesn't exist).
+    */
     ConfigFileSection* ConfigFile::getSection(const std::string& section) const
     {
@@ -392,4 +460,7 @@
     }
 
+    /**
+        @brief Returns a pointer to the section with given name. If it doesn't exist, the section is created.
+    */
     ConfigFileSection* ConfigFile::getOrCreateSection(const std::string& section)
     {
@@ -403,4 +474,7 @@
     }
 
+    /**
+        @brief Saves the config file if it was updated (or if any of its sections were updated).
+    */
     void ConfigFile::saveIfUpdated()
     {
@@ -442,4 +516,7 @@
     SettingsConfigFile* SettingsConfigFile::singletonPtr_s = 0;
 
+    /**
+        @brief Constructor: Activates the console commands.
+    */
     SettingsConfigFile::SettingsConfigFile(const std::string& filename)
         : ConfigFile(filename)
@@ -452,4 +529,7 @@
     }
 
+    /**
+        @brief Destructor: Deactivates the console commands.
+    */
     SettingsConfigFile::~SettingsConfigFile()
     {
@@ -461,4 +541,7 @@
     }
 
+    /**
+        @brief Loads the config file and updates the @ref ConfigValueContainer "config value containers".
+    */
     void SettingsConfigFile::load()
     {
@@ -467,4 +550,7 @@
     }
 
+    /**
+        @brief Changes the file-name.
+    */
     void SettingsConfigFile::setFilename(const std::string& filename)
     {
@@ -472,4 +558,7 @@
     }
 
+    /**
+        @brief Registers a new @ref ConfigValueContainer "config value container".
+    */
     void SettingsConfigFile::addConfigValueContainer(ConfigValueContainer* container)
     {
@@ -481,4 +570,7 @@
     }
 
+    /**
+        @brief Unregisters a @ref ConfigValueContainer "config value container".
+    */
     void SettingsConfigFile::removeConfigValueContainer(ConfigValueContainer* container)
     {
@@ -500,6 +592,11 @@
     }
 
+    /**
+        @brief Updates all @ref ConfigValueContainer "config value containers".
+    */
     void SettingsConfigFile::updateConfigValues()
     {
+        // todo: can this be done more efficiently? looks like some identifiers will be updated multiple times.
+
         for (ContainerMap::const_iterator it = this->containers_.begin(); it != this->containers_.end(); ++it)
         {
@@ -509,4 +606,8 @@
     }
 
+    /**
+        @brief Removes entries and sections from the file that don't exist anymore (i.e. if there's no corresponding @ref ConfigValueContainer "config value container").
+        @param bCleanComments If true, comments are also removed from the file
+    */
     void SettingsConfigFile::clean(bool bCleanComments)
     {
@@ -558,4 +659,11 @@
     }
 
+    /**
+        @brief Console-command: Changes the value of an entry and stores it the file.
+
+        @param section  The section of the config value
+        @param entry    The name of the config value
+        @param value    The new value
+    */
     void SettingsConfigFile::config(const std::string& section, const std::string& entry, const std::string& value)
     {
@@ -564,4 +672,11 @@
     }
 
+    /**
+        @brief Console-command: Changes the value of an entry, but doesn't store it in the file (it's only a temporary change).
+
+        @param section  The section of the config value
+        @param entry    The name of the config value
+        @param value    The new value
+    */
     void SettingsConfigFile::tconfig(const std::string& section, const std::string& entry, const std::string& value)
     {
@@ -570,4 +685,12 @@
     }
 
+    /**
+        @brief Changes the value of an entry, depending on @a function, either by using "set" or "tset"
+
+        @param section  The section of the config value
+        @param entry    The name of the config value
+        @param value    The new value
+        @param function The function ("set" or "tset") that will be used to change the value.
+    */
     bool SettingsConfigFile::configImpl(const std::string& section, const std::string& entry, const std::string& value, bool (ConfigValueContainer::*function)(const MultiType&))
     {
@@ -586,4 +709,10 @@
     }
 
+    /**
+        @brief Console-command: Returns the value of a given entry.
+
+        @param section  The section of the config value
+        @param entry    The name of the config value
+    */
     std::string SettingsConfigFile::getConfig(const std::string& section, const std::string& entry)
     {
@@ -611,4 +740,5 @@
     ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
 
+    /// Constructor: Initializes the array of config files with NULL.
     ConfigFileManager::ConfigFileManager()
     {
@@ -616,4 +746,5 @@
     }
 
+    /// Destructor: Deletes the config files.
     ConfigFileManager::~ConfigFileManager()
     {
@@ -623,4 +754,5 @@
     }
 
+    /// Defines the file-name for the config file of a given type (settings, calibration, etc.).
     void ConfigFileManager::setFilename(ConfigFileType::Value type, const std::string& filename)
     {
Index: code/trunk/src/libraries/core/ConfigFileManager.h
===================================================================
--- code/trunk/src/libraries/core/ConfigFileManager.h	(revision 7380)
+++ code/trunk/src/libraries/core/ConfigFileManager.h	(revision 7401)
@@ -27,4 +27,10 @@
  */
 
+/**
+    @file
+    @ingroup Config ConfigFile
+    @brief Declaration of ConfigFileManager and its helper classes, used to load and save config files.
+*/
+
 #ifndef _ConfigFileManager_H__
 #define _ConfigFileManager_H__
@@ -46,14 +52,33 @@
     // ConfigFileEntry //
     /////////////////////
+    /**
+        @brief This class represents an entry in the config file.
+
+        This class is pure virtual. Use one of the derived classes to define the type of the entry.
+    */
     class _CoreExport ConfigFileEntry
     {
         public:
+            /// Destructor
             virtual ~ConfigFileEntry() {};
+
+            /// Changes the value of the entry.
             virtual void setValue(const std::string& value) = 0;
+            /// Returns the value of the entry.
             virtual const std::string& getValue() const = 0;
+
+            /// Returns the name of the entry
             virtual const std::string& getName() const = 0;
+
+            /// Changes the comment of the entry (will be placed after the value)
             virtual void setComment(const std::string& comment) = 0;
+
+            /// Returns the index of the entry in a vector (used only if it is a vector)
             virtual unsigned int getIndex() const { return 0; }
+
+            /// Defines if this entry is treated as string which means some special treatment of special characters.
             virtual void setString(bool bString) = 0;
+
+            /// Returns the line as it will be stored in the config file.
             virtual const std::string& getFileEntry() const = 0;
     };
@@ -63,7 +88,18 @@
     // ConfigFileEntryValue //
     //////////////////////////
+    /**
+        @brief This class represents a normal value in the config file.
+    */
     class _CoreExport ConfigFileEntryValue : public ConfigFileEntry
     {
         public:
+            /**
+                @brief Constructor: Initializes the entry.
+
+                @param name                 The name of the entry
+                @param value                The value of the entry
+                @param bString              If true, the value is treated as string which means some special treatment of special characters.
+                @param additionalComment    An optional comment that will be placed behind the value in the config file
+            */
             inline ConfigFileEntryValue(const std::string& name, const std::string& value = "", bool bString = false, const std::string& additionalComment = "")
                 : name_(name)
@@ -73,4 +109,5 @@
                 { this->update(); }
 
+            /// Destructor
             inline virtual ~ConfigFileEntryValue() {}
 
@@ -92,4 +129,5 @@
                 { return this->fileEntry_; }
 
+            /// Returns the "key" of the value (in this case it's just the name of the entry, but for vectors it's different)
             inline virtual const std::string& getKeyString() const
                 { return this->name_; }
@@ -98,9 +136,9 @@
             virtual void update();
 
-            const std::string name_;
-            std::string value_;
-            std::string additionalComment_;
-            std::string fileEntry_;
-            bool bString_;
+            const std::string name_;            ///< The name of the value
+            std::string value_;                 ///< The value
+            std::string additionalComment_;     ///< The additional comment
+            std::string fileEntry_;             ///< The string as it will be stored in the config file
+            bool bString_;                      ///< If true, the value is treated as string which means some special treatment of special characters.
     };
 
@@ -109,7 +147,19 @@
     // ConfigFileEntryVectorValue //
     ////////////////////////////////
+    /**
+        @brief Subclass of ConfigFileEntryValue, represents an element of a vector.
+    */
     class _CoreExport ConfigFileEntryVectorValue : public ConfigFileEntryValue
     {
         public:
+            /**
+                @brief Constructor: Initializes the entry.
+
+                @param name                 The name of the vector
+                @param index                The index of the element in the vector
+                @param value                The value of the element
+                @param bString              If true, the value is treated as string which means some special treatment of special characters.
+                @param additionalComment    An optional comment that will be placed behind the value in the config file
+            */
             inline ConfigFileEntryVectorValue(const std::string& name, unsigned int index, const std::string& value = "", bool bString = false, const std::string& additionalComment = "")
                 : ConfigFileEntryValue(name, value, bString, additionalComment)
@@ -117,4 +167,5 @@
                 { this->update(); /*No virtual calls in base class ctor*/ }
 
+            /// Destructor
             inline ~ConfigFileEntryVectorValue() {}
 
@@ -122,4 +173,5 @@
                 { return this->index_; }
 
+            /// Returns the "key" of the value (the name of the vector plus the index of the element)
             inline const std::string& getKeyString() const
                 { return this->keyString_; }
@@ -128,6 +180,6 @@
             void update();
 
-            unsigned int index_;
-            std::string keyString_;
+            unsigned int index_;        ///< The index of the element in the vector
+            std::string keyString_;     ///< The full name of the entry (the name of the vector plus the index of the element)
     };
 
@@ -136,8 +188,14 @@
     // ConfigFileEntryComment //
     ////////////////////////////
+    /**
+        @brief This class represents a line in the config file which contains only a comment.
+    */
     class _CoreExport ConfigFileEntryComment : public ConfigFileEntry
     {
         public:
+            /// Constructor: Initializes the object.
             inline ConfigFileEntryComment(const std::string& comment) : comment_(comment) {}
+
+            /// Destructor
             inline virtual ~ConfigFileEntryComment() {}
 
@@ -159,9 +217,6 @@
                 { return this->comment_; }
 
-            inline virtual const std::string& getKeyString() const
-                { return BLANKSTRING; }
-
         private:
-            std::string comment_;
+            std::string comment_;   ///< The comment
     };
 
@@ -170,4 +225,9 @@
     // ConfigFileSection //
     ///////////////////////
+    /**
+        @brief Represents a section in a config file.
+
+        A section has a name and a list of config values.
+    */
     class _CoreExport ConfigFileSection
     {
@@ -176,4 +236,10 @@
 
         public:
+            /**
+                @brief Constructor: Initializes the section.
+
+                @param name The name of the section
+                @param additionalComment An additional comment placed after the title of the section in the config file
+            */
             inline ConfigFileSection(const std::string& name, const std::string& additionalComment = "")
                 : name_(name)
@@ -183,12 +249,27 @@
             ~ConfigFileSection();
 
+            /// Returns the name of the section.
             inline const std::string& getName() const
                 { return this->name_; }
 
+            /// Changes the comment which is placed after the title of the section in the config file.
             inline void setComment(const std::string& comment)
                 { this->additionalComment_ = comment; }
 
+            /**
+                @brief Stores a value in the section. If the entry doesn't exist, it's created.
+
+                @param name     The name of the entry
+                @param value    The new value
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline void setValue(const std::string& name, const std::string& value, bool bString)
                 { this->getOrCreateEntry(name, value, bString)->setValue(value); }
+            /**
+                @brief Returns the value of a given entry in the section. Returns a blank string if the value doesn't exist.
+
+                @param name     The name of the entry
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline const std::string& getValue(const std::string& name, bool bString)
             {
@@ -196,14 +277,36 @@
                 if (entry)
                 {
-                    entry->setString(bString);
+                    entry->setString(bString);  // if the entry was loaded from the config file, we have to tell it if it's a string
                     return entry->getValue();
                 }
                 return BLANKSTRING;
             }
+            /**
+                @brief Returns the value of a given entry in the section. If it doesn't exist, the entry is created using the fallback value.
+
+                @param name     The name of the entry
+                @param fallback The value that will be used if the entry doesn't exist
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline const std::string& getOrCreateValue(const std::string& name, const std::string& fallback, bool bString)
                 { return this->getOrCreateEntry(name, fallback, bString)->getValue(); }
 
+            /**
+                @brief Stores the value of an element of a vector in the section. If the entry doesn't exist, it's created.
+
+                @param name     The name of the vector
+                @param index    The index of the element in the vector
+                @param value    The new value
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline void setValue(const std::string& name, unsigned int index, const std::string& value, bool bString)
                 { this->getOrCreateEntry(name, index, value, bString)->setValue(value); }
+            /**
+                @brief Returns the value of a given element of a vector in the section. Returns a blank string if the value doesn't exist.
+
+                @param name     The name of the vector
+                @param index    The index of the element in the vector
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline const std::string& getValue(const std::string& name, unsigned int index, bool bString)
             {
@@ -211,9 +314,17 @@
                 if (entry)
                 {
-                    entry->setString(bString);
+                    entry->setString(bString);  // if the entry was loaded from the config file, we have to tell it if it's a string
                     return entry->getValue();
                 }
                 return BLANKSTRING;
             }
+            /**
+                @brief Returns the value of a given element of a vector in the section. If it doesn't exist, the entry is created using the fallback value.
+
+                @param name     The name of the vector
+                @param index    The index of the element in the vector
+                @param fallback The value that will be used if the entry doesn't exist
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline const std::string& getOrCreateValue(const std::string& name, unsigned int index, const std::string& fallback, bool bString)
                 { return this->getOrCreateEntry(name, index, fallback, bString)->getValue(); }
@@ -225,8 +336,11 @@
 
         private:
+            /// Returns the list of entries in this section.
             std::list<ConfigFileEntry*>& getEntries()
                 { return this->entries_; }
+            /// Returns the begin-iterator of the list of entries in this section.
             std::list<ConfigFileEntry*>::const_iterator getEntriesBegin() const
                 { return this->entries_.begin(); }
+            /// Returns the end-iterator of the list of entries in this section.
             std::list<ConfigFileEntry*>::const_iterator getEntriesEnd() const
                 { return this->entries_.end(); }
@@ -236,14 +350,30 @@
 
             ConfigFileEntry* getEntry(const std::string& name) const;
+            /**
+                @brief Returns the entry with given name. If it doesn't exist, the entry is created using the fallback value.
+
+                @param name     The name of the entry
+                @param fallback The value that will be used if the entry doesn't exist
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline ConfigFileEntry* getOrCreateEntry(const std::string& name, const std::string& fallback, bool bString)
                 { return (*this->getOrCreateEntryIterator(name, fallback, bString)); }
+
             ConfigFileEntry* getEntry(const std::string& name, unsigned int index) const;
+            /**
+                @brief Returns the entry that contains an element of a vector with given name. If it doesn't exist, the entry is created using the fallback value.
+
+                @param name     The name of the entry
+                @param index    The index of the element in the vector
+                @param fallback The value that will be used if the entry doesn't exist
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline ConfigFileEntry* getOrCreateEntry(const std::string& name, unsigned int index, const std::string& fallback, bool bString)
                 { return (*this->getOrCreateEntryIterator(name, index, fallback, bString)); }
 
-            std::string name_;
-            std::string additionalComment_;
-            std::list<ConfigFileEntry*> entries_;
-            bool bUpdated_;
+            std::string name_;                      ///< The name of the section
+            std::string additionalComment_;         ///< The additional comment which is placed after the title of the section in the config file
+            std::list<ConfigFileEntry*> entries_;   ///< The list of entries in this section
+            bool bUpdated_;                         ///< True if an entry is created
     };
 
@@ -252,4 +382,9 @@
     // ConfigFile //
     ////////////////
+    /**
+        @brief This class represents a config file, which is stored on the hard-disk and contains config values in different sections.
+
+        It provides an interface to manipulate the sections and values.
+    */
     class _CoreExport ConfigFile
     {
@@ -263,7 +398,16 @@
             virtual void clear();
 
+            /// Returns the file-name of this config file
             inline const std::string& getFilename()
                 { return this->filename_; }
 
+            /**
+                @brief Stores a value in the config file. If the entry or its section doesn't exist, it's created.
+
+                @param section  The name of the section
+                @param name     The name of the entry
+                @param value    The new value
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline void setValue(const std::string& section, const std::string& name, const std::string& value, bool bString)
             {
@@ -271,4 +415,11 @@
                 this->save();
             }
+            /**
+                @brief Returns the value of a given entry in the config file. Returns a blank string if the value doesn't exist.
+
+                @param section  The name of the section
+                @param name     The name of the entry
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline const std::string& getValue(const std::string& section, const std::string& name, bool bString)
             {
@@ -276,6 +427,28 @@
                 return (sectionPtr ? sectionPtr->getValue(name, bString) : BLANKSTRING);
             }
-            const std::string& getOrCreateValue(const std::string& section, const std::string& name, const std::string& fallback, bool bString);
-
+            /**
+                @brief Returns the value of a given entry in the config file. If it doesn't exist, the entry is created using the fallback value.
+
+                @param section  The name of the section
+                @param name     The name of the entry
+                @param fallback The value that will be used if the entry doesn't exist
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
+            inline const std::string& getOrCreateValue(const std::string& section, const std::string& name, const std::string& fallback, bool bString)
+            {
+                const std::string& output = this->getOrCreateSection(section)->getOrCreateValue(name, fallback, bString);
+                this->saveIfUpdated();
+                return output;
+            }
+
+            /**
+                @brief Stores the value of an element of a vector in the config file. If the entry or its section doesn't exist, it's created.
+
+                @param section  The name of the section
+                @param name     The name of the vector
+                @param index    The index of the element in the vector
+                @param value    The new value
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline void setValue(const std::string& section, const std::string& name, unsigned int index, const std::string& value, bool bString)
             {
@@ -283,4 +456,12 @@
                 this->save();
             }
+            /**
+                @brief Returns the value of a given element of a vector in the config file. Returns a blank string if the value doesn't exist.
+
+                @param section  The name of the section
+                @param name     The name of the vector
+                @param index    The index of the element in the vector
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
             inline const std::string& getValue(const std::string& section, const std::string& name, unsigned int index, bool bString)
             {
@@ -288,7 +469,26 @@
                 return (sectionPtr ? sectionPtr->getValue(name, index, bString) : BLANKSTRING);
             }
-            const std::string& getOrCreateValue(const std::string& section, const std::string& name, unsigned int index, const std::string& fallback, bool bString);
+            /**
+                @brief Returns the value of a given element of a vector in the config file. If it doesn't exist, the entry is created using the fallback value.
+
+                @param section  The name of the section
+                @param name     The name of the vector
+                @param index    The index of the element in the vector
+                @param fallback The value that will be used if the entry doesn't exist
+                @param bString  If true, the value is treated as string which means some special treatment of special characters.
+            */
+            const std::string& getOrCreateValue(const std::string& section, const std::string& name, unsigned int index, const std::string& fallback, bool bString)
+            {
+                const std::string& output = this->getOrCreateSection(section)->getOrCreateValue(name, index, fallback, bString);
+                this->saveIfUpdated();
+                return output;
+            }
 
             void deleteVectorEntries(const std::string& section, const std::string& name, unsigned int startindex = 0);
+            /**
+                @brief Returns the size of a config vector.
+                @param section  The section of the vector
+                @param name     The name of the vector
+            */
             inline unsigned int getVectorSize(const std::string& section, const std::string& name) const
             {
@@ -297,5 +497,5 @@
             }
 
-            static const char* DEFAULT_CONFIG_FOLDER;
+            static const char* DEFAULT_CONFIG_FOLDER;   ///< The folder where the default config files will be stored
 
         protected:
@@ -303,11 +503,12 @@
             ConfigFileSection* getOrCreateSection(const std::string& section);
 
-            std::list<ConfigFileSection*> sections_;
+            std::list<ConfigFileSection*> sections_;    ///< A list of sections in this config file
 
         private:
             void saveIfUpdated();
-            const std::string filename_;
-            const bool bCopyFallbackFile_;
-            bool bUpdated_;
+
+            const std::string filename_;                ///< The filename of this config file
+            const bool bCopyFallbackFile_;              ///< If true, the default config file is copied into the config-directory before loading the file
+            bool bUpdated_;                             ///< Becomes true if a section is added
     };
 
@@ -316,4 +517,13 @@
     // SettingsConfigFile //
     ////////////////////////
+    /**
+        @brief Child class of ConfigFile, used to store the settings of the game.
+
+        In addition to ConfigFile, this class provides an interface to manipulate the settings
+        with console commands and to cache entries in instances of ConfigValueContainer.
+
+        SettingsConfigFile is a Singleton, meaning there's only one instance of this class
+        (and thus only one config file that stores settings).
+    */
     class _CoreExport SettingsConfigFile // tolua_export
         : public ConfigFile, public Singleton<SettingsConfigFile>
@@ -338,8 +548,11 @@
             void removeConfigValueContainer(ConfigValueContainer* container);
 
+            /// Returns a set containing the names of all sections in this config file.
             inline const std::set<std::string>& getSectionNames()
                 { return this->sectionNames_; }
+            /// Returns the lower-bound-iterator of the @ref ConfigValueContainer "config value containers" for the given section.
             inline ContainerMap::const_iterator getContainerLowerBound(const std::string section)
                 { return this->containers_.lower_bound(section); }
+            /// Returns the upper-bound-iterator of the @ref ConfigValueContainer "config value containers" for the given section.
             inline ContainerMap::const_iterator getContainerUpperBound(const std::string section)
                 { return this->containers_.upper_bound(section); }
@@ -351,7 +564,7 @@
             bool configImpl(const std::string& section, const std::string& entry, const std::string& value, bool (ConfigValueContainer::*function)(const MultiType&));
 
-            ContainerMap containers_;
-            std::set<std::string> sectionNames_;
-            static SettingsConfigFile* singletonPtr_s;
+            ContainerMap containers_;                   ///< Stores all @ref ConfigValueContainer "config value containers"
+            std::set<std::string> sectionNames_;        ///< Stores all section names
+            static SettingsConfigFile* singletonPtr_s;  ///< The singleton pointer
     }; // tolua_export
 
@@ -360,4 +573,7 @@
     // ConfigFileManager //
     ///////////////////////
+    /**
+        @brief Manages the different config files (settings, calibration, etc). Implemented as Singleton.
+    */
     class _CoreExport ConfigFileManager : public Singleton<ConfigFileManager>
     {
@@ -369,4 +585,5 @@
             void setFilename(ConfigFileType::Value type, const std::string& filename);
 
+            /// Returns the config file of a given type (settings, calibration, etc.)
             inline ConfigFile* getConfigFile(ConfigFileType::Value type)
             {
@@ -376,8 +593,8 @@
 
         private:
-            ConfigFileManager(const ConfigFileManager&);
-
-            boost::array<ConfigFile*, 3> configFiles_;
-            static ConfigFileManager* singletonPtr_s;
+            ConfigFileManager(const ConfigFileManager&);    ///< Copy-constructor: not implemented
+
+            boost::array<ConfigFile*, 3> configFiles_;      ///< Stores the config files for each type in an array (must have the same size like ConfigFileType::Value)
+            static ConfigFileManager* singletonPtr_s;       ///< Stores the singleton-pointer
     };
 } // tolua_export
Index: code/trunk/src/libraries/core/ConfigValueContainer.h
===================================================================
--- code/trunk/src/libraries/core/ConfigValueContainer.h	(revision 7380)
+++ code/trunk/src/libraries/core/ConfigValueContainer.h	(revision 7401)
@@ -29,5 +29,6 @@
 /**
     @file
-    @brief Definition of the ConfigValueContainer class.
+    @ingroup Config ConfigFile
+    @brief Declaration of the ConfigValueContainer class, caches a config-value.
 
     The ConfigValueContainer class contains all needed information about a configurable variable:
@@ -78,6 +79,7 @@
 
 
-    //! The ConfigValuecontainer contains all needed information about a configurable variable.
     /**
+        @brief The ConfigValuecontainer contains all needed information about a configurable variable.
+
         The ConfigValueContainer class contains all needed information about a configurable variable:
          - the name of the variable
@@ -117,6 +119,8 @@
                 @param type The type of the corresponding config-file
                 @param identifier The identifier of the class the variable belongs to
+                @param sectionname Name of the section the configValue should be put in.
                 @param varname The name of the variable
                 @param defvalue The default-value
+                @param value Only needed do determine the right type.
             */
             template <class D, class V>
@@ -213,17 +217,17 @@
             }
 
-            /** @brief Returns the name of this container. */
+            /// Returns the name of this container.
             inline const std::string& getName() const
                 { return this->varname_; }
-            /** @brief Returns the name of the section this config value is in. */
+            /// Returns the name of the section this config value is in.
             inline const std::string& getSectionName() const
                 { return this->sectionname_; }
-            /** @brief Returns the associated identifier (can be NULL). */
+            /// Returns the associated identifier (can be NULL).
             inline Identifier* getIdentifier() const
                 { return this->identifier_; }
-            /** @brief Returns true if this config-value is a vector */
+            /// Returns true if this config-value is a vector.
             inline bool isVector() const
                 { return this->bIsVector_; }
-            /** @brief Returns the vectors size (or zero if it's not a vector). */
+            /// Returns the vectors size (or zero if it's not a vector).
             inline unsigned int getVectorSize() const
                 { return this->valueVector_.size(); }
@@ -265,8 +269,8 @@
             void update();
 
-            /** @brief Converts the config-value to a string. @return The string */
+            /// Converts the config-value to a string.
             inline std::string toString() const
                 { return this->value_; }
-            /** @brief Returns the typename of the assigned config-value. @return The typename */
+            /// Returns the typename of the assigned config-value.
             inline std::string getTypename() const
                 { return this->value_.getTypename(); }
Index: code/trunk/src/libraries/core/ConfigValueIncludes.h
===================================================================
--- code/trunk/src/libraries/core/ConfigValueIncludes.h	(revision 7380)
+++ code/trunk/src/libraries/core/ConfigValueIncludes.h	(revision 7401)
@@ -28,7 +28,72 @@
 
 /**
-@file
-@brief
-    Definition of macros and functions for config-values.
+    @defgroup ConfigFile Config file
+    @ingroup Config
+*/
+
+/**
+    @file
+    @ingroup Config ConfigFile
+    @brief Definition of macros and functions for config-values.
+
+    An example of how to use SetConfigValue():
+
+    Definition of a class in the header-file:
+    @code
+    class MyClass : public BaseObject
+    {
+        public:
+            MyClass();              // Constructor
+            void setConfigValues(); // Inherited function
+
+            const std::string& getName()
+                { return this->name_; }
+
+            float getVersion()
+                { return this->version_; }
+
+        private:
+            std::string name_;
+            float version_;
+    };
+    @endcode
+
+    Implementation of the class source-file:
+    @code
+    MyClass::MyClass()
+    {
+        // Macro-call to create an Identifier
+        RegisterObject(MyClass);
+
+        // Function-call to assign the config-values to the new object
+        this->setConfigValues();
+    }
+
+    void MyClass::setConfigValues()
+    {
+        SetConfigValue(name_, "Orxonox").description("The name of the game");
+        SetConfigValue(version_, "1.0").description("The version-number");
+    }
+    @endcode
+
+    Extract of orxonox.ini:
+    @code
+    [MyClass]
+    name_ = "Orxonox"
+    version_ = 1.1 // We have changed this value from 1.0 to 1.1
+    @endcode
+
+    Some other code:
+    @code
+    MyObject orxonoxobject;
+    std::cout << "Name:    " << orxonoxobject.getName() << std::endl;
+    std::cout << "Version: " << orxonoxobject.getVersion() << std::endl;
+    @endcode
+
+    Output:
+    @code
+    Name:    Orxonox
+    Version: 1.1
+    @endcode
 */
 
Index: code/trunk/src/libraries/core/Core.cc
===================================================================
--- code/trunk/src/libraries/core/Core.cc	(revision 7380)
+++ code/trunk/src/libraries/core/Core.cc	(revision 7401)
@@ -37,4 +37,5 @@
 
 #include <cassert>
+#include <fstream>
 #include <vector>
 
@@ -171,4 +172,19 @@
         // Create singletons that always exist (in other libraries)
         this->rootScope_.reset(new Scope<ScopeID::Root>());
+
+        // Generate documentation instead of normal run?
+        std::string docFilename;
+        CommandLineParser::getValue("generateDoc", &docFilename);
+        if (!docFilename.empty())
+        {
+            std::ofstream docFile(docFilename.c_str());
+            if (docFile.is_open())
+            {
+                CommandLineParser::generateDoc(docFile);
+                docFile.close();
+            }
+            else
+                COUT(0) << "Error: Could not open file for documentation writing" << endl;
+        }
     }
 
Index: code/trunk/src/libraries/core/Core.h
===================================================================
--- code/trunk/src/libraries/core/Core.h	(revision 7380)
+++ code/trunk/src/libraries/core/Core.h	(revision 7401)
@@ -28,4 +28,15 @@
  */
 
+/**
+    @defgroup CoreGame Core and Game
+    @ingroup Management
+*/
+
+/**
+    @file
+    @ingroup Management CoreGame
+    @brief Declaration of the Core singleton which is used to configure the program basics.
+*/
+
 #ifndef _Core_H__
 #define _Core_H__
@@ -33,5 +44,4 @@
 #include "CorePrereqs.h"
 
-#include <cassert>
 #include <string>
 #include <boost/scoped_ptr.hpp>
Index: code/trunk/src/libraries/core/CoreIncludes.h
===================================================================
--- code/trunk/src/libraries/core/CoreIncludes.h	(revision 7380)
+++ code/trunk/src/libraries/core/CoreIncludes.h	(revision 7401)
@@ -28,12 +28,47 @@
 
 /**
+    @defgroup Factory RegisterObject() and CreateFactory()
+    @ingroup Object
+*/
+
+/**
     @file
-    @brief Definition of macros for Identifiers
+    @ingroup Object Factory
+    @brief Defines several very important macros used to register objects, create factories, and to work with identifiers.
 
-    Every class needs the RegisterObject(class) macro in its constructor. If the class is an interface
-    or the BaseObject itself, it needs the macro RegisterRootObject(class) instead.
+    Every class needs the @c RegisterObject(class) macro in its constructor. If the class is an interface
+    or the @c BaseObject itself, it needs the macro @c RegisterRootObject(class) instead.
 
-    To allow the object being created through the factory, use the CreateFactory(class) macro outside
-    the of the class implementation, so it gets executed before main().
+    To allow the object being created through the factory, use the @c CreateFactory(class) macro outside
+    of the class implementation, so it gets executed statically before @c main(). This will at the same time
+    register @a class in the class-hierarchy. If you don't want @a class to be loadable, but still
+    register it, call @c CreateUnloadableFactory(class).
+
+    Example:
+    @code
+    // Create the factory for MyClass
+    CreateFactory(MyClass);
+
+    // Constructor:
+    MyClass::MyClass()
+    {
+        // Register the object in the Identifier of MyClass
+        RegisterObject(MyClass);
+    }
+    @endcode
+
+    This file also defines a number of other useful macros, like, for example, @c Class(class) which
+    returns the @ref orxonox::Identifier "Identifier" of @a class, or @c ClassByString("class") which
+    returns the Identifier of a class with name @a "class".
+
+    Example:
+    @code
+    // Assigns the Identifier of MyClass
+    Identifier* identifier = Class(MyClass);
+    @endcode
+    @code
+    // Assigns the Identifier of a class named "MyClass"
+    Identifier* identifier = ClassByString("MyClass");
+    @endcode
 */
 
@@ -51,7 +86,7 @@
 
 /**
-    @brief Intern macro, containing the common parts of RegisterObject and RegisterRootObject.
+    @brief Intern macro, containing the common parts of @c RegisterObject and @c RegisterRootObject.
     @param ClassName The name of the class
-    @param bRootClass True if the class is directly derived from OrxonoxClass
+    @param bRootClass True if the class is directly derived from orxonox::OrxonoxClass
 */
 #define InternRegisterObject(ClassName, bRootClass) \
@@ -62,5 +97,5 @@
 
 /**
-    @brief RegisterObject - with and without debug output.
+    @brief Registers a newly created object in the core. Has to be called at the beginning of the constructor of @a ClassName.
     @param ClassName The name of the class
 */
@@ -69,6 +104,9 @@
 
 /**
-    @brief RegisterRootObject - with and without debug output.
+    @brief Registers a newly created object in the core. Has to be called at the beginning of the constructor of @a ClassName.
     @param ClassName The name of the class
+
+    In contrast to RegisterObject, this is used for classes that inherit directly from
+    orxonox::OrxonoxClass, namely all interfaces and orxonox::BaseObject.
 */
 #define RegisterRootObject(ClassName) \
@@ -101,5 +139,5 @@
     /**
         @brief Returns the Identifier with a given name.
-        @param String The name of the class
+        @param name The name of the class
     */
     inline Identifier* ClassByString(const std::string& name)
@@ -110,5 +148,5 @@
     /**
         @brief Returns the Identifier with a given lowercase name.
-        @param String The lowercase name of the class
+        @param name The lowercase name of the class
     */
     inline Identifier* ClassByLowercaseString(const std::string& name)
@@ -119,5 +157,5 @@
     /**
         @brief Returns the Identifier with a given network ID.
-        @param networkID The network ID of the class
+        @param id The network ID of the class
     */
     inline Identifier* ClassByID(uint32_t id)
@@ -130,5 +168,5 @@
         @note This of course only works with OrxonoxClasses.
               The only use is in conjunction with macros that don't know the class type.
-        @param Pointer to an OrxonoxClass
+        @param object Pointer to an OrxonoxClass
     */
     template <class T>
Index: code/trunk/src/libraries/core/DynLib.h
===================================================================
--- code/trunk/src/libraries/core/DynLib.h	(revision 7380)
+++ code/trunk/src/libraries/core/DynLib.h	(revision 7401)
@@ -29,4 +29,10 @@
 
 // 08/11/2009: Small adjustments for Orxonox by Fabian 'x3n' Landau
+
+/**
+    @file
+    @ingroup Management CoreGame
+    @brief Declaration of DynLib which represents a dynamically loaded module.
+*/
 
 #ifndef _Core_DynLib_H__
@@ -61,5 +67,5 @@
 namespace orxonox
 {
-    /** Resource holding data about a dynamic library.
+    /** %Resource holding data about a dynamic library.
         @remarks
             This class holds the data required to get symbols from
@@ -69,6 +75,4 @@
         @since
             27 January 2002
-        @see
-            Resource
     */
     class _CoreExport DynLib
Index: code/trunk/src/libraries/core/DynLibManager.h
===================================================================
--- code/trunk/src/libraries/core/DynLibManager.h	(revision 7380)
+++ code/trunk/src/libraries/core/DynLibManager.h	(revision 7401)
@@ -30,4 +30,10 @@
 // 08/11/2009: Small adjustments for Orxonox by Fabian 'x3n' Landau
 
+/**
+    @file
+    @ingroup Management CoreGame
+    @brief Declaration of DynLibManager, used to load modules at runtime.
+*/
+
 #ifndef _Core_DynLibManager_H__
 #define _Core_DynLibManager_H__
@@ -56,28 +62,36 @@
 
         public:
-            /** Default constructor.
-                @note
-                    <br>Should never be called as the singleton is automatically
-                    created during the creation of the Root object.
-                @see
-                    Root::Root
+            /**
+            @brief
+                Default constructor.
+            @note
+                Should never be called as the singleton is automatically
+                created during the creation of the Root object.
+            @see
+                Root::Root
             */
             DynLibManager();
 
-            /** Default destructor.
-                @see
-                    Root::~Root
+            /**
+            @brief
+                Default destructor.
+            @see
+                Root::~Root
             */
             virtual ~DynLibManager();
 
-            /** Loads the passed library.
-                @param
-                    filename The name of the library. The extension can be omitted
+            /**
+            @brief
+                Loads the passed library.
+            @param filename
+                The name of the library. The extension can be omitted
             */
             DynLib* load(const std::string& filename);
 
-            /** Unloads the passed library.
-            @param
-            filename The name of the library. The extension can be omitted
+            /**
+            @brief
+                Unloads the passed library.
+            @param lib
+                A pointer to the library object
             */
             void unload(DynLib* lib);
Index: code/trunk/src/libraries/core/Event.cc
===================================================================
--- code/trunk/src/libraries/core/Event.cc	(revision 7380)
+++ code/trunk/src/libraries/core/Event.cc	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @brief Implementation of the classes Event and EventState.
+*/
 
 #include "Event.h"
Index: code/trunk/src/libraries/core/Event.h
===================================================================
--- code/trunk/src/libraries/core/Event.h	(revision 7380)
+++ code/trunk/src/libraries/core/Event.h	(revision 7401)
@@ -27,4 +27,15 @@
  */
 
+/**
+    @defgroup Event Events
+    @ingroup Core
+*/
+
+/**
+    @file
+    @ingroup Event
+    @brief Declaration of the classes Event and EventState.
+*/
+
 #ifndef _Event_H__
 #define _Event_H__
@@ -54,10 +65,10 @@
         An event state is a state of an object, which can be changed by events.
         Event states are changed through functions. Possible functions headers for set event states are:
-         - memoryless state: function()
-         - boolean state:    function(bool state)
-         - individual state: function(bool state, SomeClass originator)
+         - memoryless state: <tt>function()</tt>
+         - boolean state:    <tt>function(bool state)</tt>
+         - individual state: <tt>function(bool state, SomeClass originator)</tt>
 
         Note that SomeClass may be any class deriving from BaseObject. You will not receive events from originators of other classes.
-        The actual class for SomeClass must be specified as the second argument of the XMLPortEventState macro.
+        The actual class for SomeClass must be specified as the second argument of the XMLPortEventState() macro.
 
         The this pointer of the affected object is hidden in the functors, because the events are processed in the BaseObject, but some
Index: code/trunk/src/libraries/core/EventIncludes.h
===================================================================
--- code/trunk/src/libraries/core/EventIncludes.h	(revision 7380)
+++ code/trunk/src/libraries/core/EventIncludes.h	(revision 7401)
@@ -26,4 +26,10 @@
  *
  */
+
+/**
+    @file
+    @ingroup Event
+    @brief Definition of the XMLPortEventState() macro, as well as some more useful macros.
+*/
 
 #ifndef _EventIncludes_H__
Index: code/trunk/src/libraries/core/GUIManager.cc
===================================================================
--- code/trunk/src/libraries/core/GUIManager.cc	(revision 7380)
+++ code/trunk/src/libraries/core/GUIManager.cc	(revision 7401)
@@ -110,6 +110,4 @@
         After Lua setup tolua++-elements are linked to Lua-state to give Lua access to C++-code.
         Finally initial Lua code is executed (maybe we can do this with the CEGUI startup script automatically).
-    @param renderWindow
-        Ogre's render window. Without this, the GUI cannot be displayed.
     @return true if success, otherwise false
     */
@@ -237,4 +235,6 @@
     @param name
         The name of the GUI
+    @param bHidePrevious
+        If true all displayed GUIs on the stack, that are below this GUI are hidden.
 
         The function executes the Lua function with the same name in case the GUIManager is ready.
Index: code/trunk/src/libraries/core/GUIManager.h
===================================================================
--- code/trunk/src/libraries/core/GUIManager.h	(revision 7380)
+++ code/trunk/src/libraries/core/GUIManager.h	(revision 7401)
@@ -27,4 +27,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup Graphics
+*/
 
 #ifndef _GUIManager_H__
Index: code/trunk/src/libraries/core/Game.h
===================================================================
--- code/trunk/src/libraries/core/Game.h	(revision 7380)
+++ code/trunk/src/libraries/core/Game.h	(revision 7401)
@@ -29,6 +29,7 @@
 /**
 @file
+@ingroup Management CoreGame
 @brief
-    Declaration of Game Singleton.
+    Declaration of Game Singleton which is responsible for running the game.
  */
 
@@ -53,5 +54,5 @@
 
 /**
-@def
+@brief
     Adds a new GameState to the Game. The second parameter is the name as string
     and every following paramter is a constructor argument (which is usually non existent)
Index: code/trunk/src/libraries/core/GameMode.cc
===================================================================
--- code/trunk/src/libraries/core/GameMode.cc	(revision 7380)
+++ code/trunk/src/libraries/core/GameMode.cc	(revision 7401)
@@ -33,5 +33,5 @@
     bool GameMode::bShowsGraphics_s = false;
     bool GameMode::bPlaysSound_s    = false;
-    bool GameMode::bHasServer_s     = false;
+    bool GameMode::bIsServer_s      = false;
     bool GameMode::bIsClient_s      = false;
     bool GameMode::bIsStandalone_s  = false;
Index: code/trunk/src/libraries/core/GameMode.h
===================================================================
--- code/trunk/src/libraries/core/GameMode.h	(revision 7380)
+++ code/trunk/src/libraries/core/GameMode.h	(revision 7401)
@@ -29,5 +29,6 @@
 /**
     @file
-    @brief Declaration of the GameMode class.
+    @ingroup Management CoreGame
+    @brief Declaration of the GameMode class which stores and returns the current mode of the game.
 */
 
@@ -40,4 +41,5 @@
 namespace orxonox
 {
+    /// Helper class, stores and returns the current mode of the game.
     class _CoreExport GameMode
     {
@@ -47,16 +49,16 @@
         public:
 // tolua_begin
-            static bool showsGraphics() { return bShowsGraphics_s; }
-            static bool playsSound()    { return bPlaysSound_s; }
-            static bool hasServer()     { return bHasServer_s; }
-            static bool isClient()      { return bIsClient_s; }
-            static bool isStandalone()  { return bIsStandalone_s; }
-            static bool isMaster()      { return bIsMaster_s; }
+            static bool showsGraphics() { return bShowsGraphics_s; }    ///< Returns true if the game shows graphics, false if it is in text-console mode
+            static bool playsSound()    { return bPlaysSound_s; }       ///< Returns true if the game is able to play sounds
+            static bool isServer()      { return bIsServer_s; }         ///< Returns true if we're currently a server (online)
+            static bool isClient()      { return bIsClient_s; }         ///< Returns true if we're currently a client (online)
+            static bool isStandalone()  { return bIsStandalone_s; }     ///< Returns true if we're in standalone mode (offline)
+            static bool isMaster()      { return bIsMaster_s; }         ///< Returns true if we're in control of the game (either standalone or server)
 // tolua_end
 
-            static void setPlaysSound   (bool val) { bPlaysSound_s    = val; }
-            static void setHasServer    (bool val) { bHasServer_s     = val; updateIsMaster(); }
-            static void setIsClient     (bool val) { bIsClient_s      = val; updateIsMaster(); }
-            static void setIsStandalone (bool val) { bIsStandalone_s  = val; updateIsMaster(); }
+            static void setPlaysSound   (bool val) { bPlaysSound_s    = val; }                      ///< Defines if the game can play sounds
+            static void setIsServer     (bool val) { bIsServer_s      = val; updateIsMaster(); }    ///< Defines if the program is in server mode (online)
+            static void setIsClient     (bool val) { bIsClient_s      = val; updateIsMaster(); }    ///< Defines if the program is in client mode (online)
+            static void setIsStandalone (bool val) { bIsStandalone_s  = val; updateIsMaster(); }    ///< Defines if the program is in standalone mode (offline)
 
         private:
@@ -65,15 +67,16 @@
             ~GameMode();
 
+            /// Checks if we're in control of the game (either standalone or server).
             static void updateIsMaster()
             {
-                bIsMaster_s = (bHasServer_s || bIsStandalone_s);
+                bIsMaster_s = (bIsServer_s || bIsStandalone_s);
             }
 
             static bool bShowsGraphics_s;                   //!< global variable that tells whether to show graphics
             static bool bPlaysSound_s;                      //!< global variable that tells whether to sound works
-            static bool bHasServer_s;                       //!< global variable that tells whether this is a server
-            static bool bIsClient_s;
-            static bool bIsStandalone_s;
-            static bool bIsMaster_s;
+            static bool bIsServer_s;                        //!< global variable that tells whether this is a server (online)
+            static bool bIsClient_s;                        //!< global variable that tells whether this is a client (online)
+            static bool bIsStandalone_s;                    //!< global variable that tells whether the game is running in standalone mode (offline)
+            static bool bIsMaster_s;                        //!< global variable that tells whether we're in control of the game (standalone or server)
     }; // tolua_export
 } // tolua_export
Index: code/trunk/src/libraries/core/GameState.h
===================================================================
--- code/trunk/src/libraries/core/GameState.h	(revision 7380)
+++ code/trunk/src/libraries/core/GameState.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
 @file
+@ingroup Management CoreGame
 @brief
     Definition of GameState class.
Index: code/trunk/src/libraries/core/GraphicsManager.h
===================================================================
--- code/trunk/src/libraries/core/GraphicsManager.h	(revision 7380)
+++ code/trunk/src/libraries/core/GraphicsManager.h	(revision 7401)
@@ -29,5 +29,11 @@
 
 /**
+    @defgroup Graphics Graphics and GUI
+    @ingroup Core
+*/
+
+/**
 @file
+@ingroup Graphics
 @brief
     Declaration of GraphicsManager Singleton.
Index: code/trunk/src/libraries/core/Identifier.cc
===================================================================
--- code/trunk/src/libraries/core/Identifier.cc	(revision 7380)
+++ code/trunk/src/libraries/core/Identifier.cc	(revision 7401)
@@ -217,5 +217,4 @@
     /**
         @brief Sets the name of the class.
-        @param name The name
     */
     void Identifier::setName(const std::string& name)
@@ -253,5 +252,4 @@
     /**
         @brief Sets the network ID to a new value and changes the entry in the ID-Identifier-map.
-        @param id The new network ID
     */
     void Identifier::setNetworkID(uint32_t id)
Index: code/trunk/src/libraries/core/Identifier.h
===================================================================
--- code/trunk/src/libraries/core/Identifier.h	(revision 7380)
+++ code/trunk/src/libraries/core/Identifier.h	(revision 7401)
@@ -28,21 +28,51 @@
 
 /**
+    @defgroup Identifier Identifier
+    @ingroup Class
+*/
+
+/**
     @file
-    @brief Definition of the Identifier class, definition and implementation of the ClassIdentifier class.
-
-    The Identifier contains all needed information about the class it belongs to:
-     - the name
-     - a list with all objects
-     - parents and children
-     - the factory (if available)
-     - the networkID that can be synchronised with the server
-     - all configurable variables (if available)
-
-    Every object has a pointer to the Identifier of its class. This allows the use isA(...),
-    isExactlyA(...), isChildOf(...) and isParentOf(...).
-
-    To create the class-hierarchy, the Identifier has some intern functions and variables.
-
-    Every Identifier is in fact a ClassIdentifier, but they are derived from Identifier.
+    @ingroup Class Identifier
+    @brief Declaration of Identifier, definition of ClassIdentifier<T>; used to identify the class of an object.
+
+    @anchor IdentifierExample
+
+    An Identifier "identifies" the class of an object. It contains different information about
+    the class: Its name and ID, a list of all instances of this class, a factory to create new
+    instances of this class, and more.
+
+    It also contains information about the inheritance of this class: It stores a list of the
+    Identifiers of all parent-classes as well as a list of all child-classes. These relationships
+    can be tested using functions like @c isA(), @c isChildOf(), @c isParentOf(), and more.
+
+    Every Identifier is in fact a ClassIdentifier<T> (where T is the class that is identified
+    by the Identifier), Identifier is just the common base-class.
+
+    Example:
+    @code
+    MyClass* object = new MyClass();                                            // create an instance of MyClass
+
+    object->getIdentifier()->getName();                                         // returns "MyClass"
+
+    BaseObject* other = object->getIdentifier()->fabricate(0);                  // fabricates a new instance of MyClass
+
+
+    // iterate through all objects of type MyClass:
+    ObjectListBase* objects = object->getIdentifier()->getObjects();            // get a pointer to the object-list
+    int count;
+    for (Iterator<BaseObject> it = objects.begin(); it != objects.end(); ++it)  // iterate through the objects
+        ++count;
+    COUT(0) << count << std::endl;                                              // prints "2" because we created 2 instances of MyClass so far
+
+
+    // test the class hierarchy
+    object->getIdentifier()->isA(Class(MyClass));                               // returns true
+    object->isA(Class(MyClass));                                                // returns true (short version)
+
+    object->isA(Class(BaseClass));                                              // returns true if MyClass is a child of BaseClass
+
+    Class(ChildClass)->isChildOf(object->getIdentifier());                      // returns true if ChildClass is a child of MyClass
+    @endcode
 */
 
@@ -70,46 +100,42 @@
     // ###       Identifier        ###
     // ###############################
-    //! The Identifier is used to identify the class of an object and to store information about the class.
-    /**
-        The Identifier contains all needed information about the class it belongs to:
-         - the name
-         - a list with all objects
-         - parents and children
-         - the factory (if available)
-         - the networkID that can be synchronised with the server
-         - all configurable variables (if available)
-
-        Every object has a pointer to the Identifier of its class. This allows the use isA(...),
-        isExactlyA(...), isChildOf(...) and isParentOf(...).
-
-        You can't directly create an Identifier, it's just the base-class for ClassIdentifier.
+    /**
+        @brief The Identifier is used to identify the class of an object and to store information about the class.
+
+        Each Identifier stores information about one class. The Identifier can then be used to identify
+        this class. On the other hand it's also possible to get the corresponding Identifier of a class,
+        for example by using the macro Class().
+
+        @see See @ref IdentifierExample "Identifier.h" for more information and some examples.
+
+        @note You can't directly create an Identifier, it's just the base-class of ClassIdentifier<T>.
     */
     class _CoreExport Identifier
     {
         public:
-            /** @brief Returns the name of the class the Identifier belongs to. @return The name */
+            /// Returns the name of the class the Identifier belongs to.
             inline const std::string& getName() const { return this->name_; }
             void setName(const std::string& name);
 
-            /** @brief Returns the network ID to identify a class through the network. @return the network ID */
+            /// Returns the network ID to identify a class through the network.
             inline const uint32_t getNetworkID() const { return this->networkID_; }
             void setNetworkID(uint32_t id);
 
-            /** @brief Returns the unique ID of the class */
+            /// Returns the unique ID of the class.
             FORCEINLINE unsigned int getClassID() const { return this->classID_; }
 
-            /** @brief Returns the list of all existing objects of this class. @return The list */
+            /// Returns the list of all existing objects of this class.
             inline ObjectListBase* getObjects() const { return this->objects_; }
 
-            /** @brief Sets the Factory. @param factory The factory to assign */
+            /// Sets the Factory.
             inline void addFactory(Factory* factory) { this->factory_ = factory; }
-            /** @brief Returns true if the Identifier has a Factory. */
+            /// Returns true if the Identifier has a Factory.
             inline bool hasFactory() const { return (this->factory_ != 0); }
 
             BaseObject* fabricate(BaseObject* creator);
 
-            /** @brief Returns true if the class can be loaded through XML. */
+            /// Returns true if the class can be loaded through XML.
             inline bool isLoadable() const { return this->bLoadable_; }
-            /** @brief Set the class to be loadable through XML or not. */
+            /// Set the class to be loadable through XML or not.
             inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
 
@@ -127,33 +153,33 @@
             static void createClassHierarchy();
 
-            /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
+            /// Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents.
             inline static bool isCreatingHierarchy() { return (hierarchyCreatingCounter_s > 0); }
 
-            /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
+            /// Returns the parents of the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getParents() const { return this->parents_; }
-            /** @brief Returns the begin-iterator of the parents-list. @return The begin-iterator */
+            /// Returns the begin-iterator of the parents-list.
             inline std::set<const Identifier*>::const_iterator getParentsBegin() const { return this->parents_.begin(); }
-            /** @brief Returns the end-iterator of the parents-list. @return The end-iterator */
+            /// Returns the end-iterator of the parents-list.
             inline std::set<const Identifier*>::const_iterator getParentsEnd() const { return this->parents_.end(); }
 
-            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
+            /// Returns the children of the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getChildren() const { return this->children_; }
-            /** @brief Returns the begin-iterator of the children-list. @return The begin-iterator */
+            /// Returns the begin-iterator of the children-list.
             inline std::set<const Identifier*>::const_iterator getChildrenBegin() const { return this->children_.begin(); }
-            /** @brief Returns the end-iterator of the children-list. @return The end-iterator */
+            /// Returns the end-iterator of the children-list.
             inline std::set<const Identifier*>::const_iterator getChildrenEnd() const { return this->children_.end(); }
 
-            /** @brief Returns the direct parents of the class the Identifier belongs to. @return The list of all direct parents */
+            /// Returns the direct parents of the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getDirectParents() const { return this->directParents_; }
-            /** @brief Returns the begin-iterator of the direct-parents-list. @return The begin-iterator */
+            /// Returns the begin-iterator of the direct-parents-list.
             inline std::set<const Identifier*>::const_iterator getDirectParentsBegin() const { return this->directParents_.begin(); }
-            /** @brief Returns the end-iterator of the direct-parents-list. @return The end-iterator */
+            /// Returns the end-iterator of the direct-parents-list.
             inline std::set<const Identifier*>::const_iterator getDirectParentsEnd() const { return this->directParents_.end(); }
 
-            /** @brief Returns the direct children the class the Identifier belongs to. @return The list of all direct children */
+            /// Returns the direct children the class the Identifier belongs to.
             inline const std::set<const Identifier*>& getDirectChildren() const { return this->directChildren_; }
-            /** @brief Returns the begin-iterator of the direct-children-list. @return The begin-iterator */
+            /// Returns the begin-iterator of the direct-children-list.
             inline std::set<const Identifier*>::const_iterator getDirectChildrenBegin() const { return this->directChildren_.begin(); }
-            /** @brief Returns the end-iterator of the direct-children-list. @return The end-iterator */
+            /// Returns the end-iterator of the direct-children-list.
             inline std::set<const Identifier*>::const_iterator getDirectChildrenEnd() const { return this->directChildren_.end(); }
 
@@ -170,23 +196,23 @@
             static void clearNetworkIDs();
 
-            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
+            /// Returns the map that stores all Identifiers with their names.
             static inline const std::map<std::string, Identifier*>& getStringIdentifierMap() { return Identifier::getStringIdentifierMapIntern(); }
-            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names. @return The const_iterator */
+            /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names.
             static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapBegin() { return Identifier::getStringIdentifierMap().begin(); }
-            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names. @return The const_iterator */
+            /// Returns a const_iterator to the end of the map that stores all Identifiers with their names.
             static inline std::map<std::string, Identifier*>::const_iterator getStringIdentifierMapEnd() { return Identifier::getStringIdentifierMap().end(); }
 
-            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
+            /// Returns the map that stores all Identifiers with their names in lowercase.
             static inline const std::map<std::string, Identifier*>& getLowercaseStringIdentifierMap() { return Identifier::getLowercaseStringIdentifierMapIntern(); }
-            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
+            /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their names in lowercase.
             static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapBegin() { return Identifier::getLowercaseStringIdentifierMap().begin(); }
-            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase. @return The const_iterator */
+            /// Returns a const_iterator to the end of the map that stores all Identifiers with their names in lowercase.
             static inline std::map<std::string, Identifier*>::const_iterator getLowercaseStringIdentifierMapEnd() { return Identifier::getLowercaseStringIdentifierMap().end(); }
 
-            /** @brief Returns the map that stores all Identifiers with their IDs. @return The map */
+            /// Returns the map that stores all Identifiers with their IDs.
             static inline const std::map<uint32_t, Identifier*>& getIDIdentifierMap() { return Identifier::getIDIdentifierMapIntern(); }
-            /** @brief Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs. @return The const_iterator */
+            /// Returns a const_iterator to the beginning of the map that stores all Identifiers with their IDs.
             static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapBegin() { return Identifier::getIDIdentifierMap().begin(); }
-            /** @brief Returns a const_iterator to the end of the map that stores all Identifiers with their IDs. @return The const_iterator */
+            /// Returns a const_iterator to the end of the map that stores all Identifiers with their IDs.
             static inline std::map<uint32_t, Identifier*>::const_iterator getIDIdentifierMapEnd() { return Identifier::getIDIdentifierMap().end(); }
 
@@ -197,5 +223,5 @@
             virtual void updateConfigValues(bool updateChildren = true) const = 0;
 
-            /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
+            /// Returns true if this class has at least one config value.
             inline bool hasConfigValues() const { return this->bHasConfigValues_; }
 
@@ -207,16 +233,16 @@
             ///// XMLPort /////
             ///////////////////
-            /** @brief Returns the map that stores all XMLPort params. @return The const_iterator */
+            /// Returns the map that stores all XMLPort params.
             inline const std::map<std::string, XMLPortParamContainer*>& getXMLPortParamMap() const { return this->xmlportParamContainers_; }
-            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort params. @return The const_iterator */
+            /// Returns a const_iterator to the beginning of the map that stores all XMLPort params.
             inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapBegin() const { return this->xmlportParamContainers_.begin(); }
-            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort params. @return The const_iterator */
+            /// Returns a const_iterator to the end of the map that stores all XMLPort params.
             inline std::map<std::string, XMLPortParamContainer*>::const_iterator getXMLPortParamMapEnd() const { return this->xmlportParamContainers_.end(); }
 
-            /** @brief Returns the map that stores all XMLPort objects. @return The const_iterator */
+            /// Returns the map that stores all XMLPort objects.
             inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortObjectMap() const { return this->xmlportObjectContainers_; }
-            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort objects. @return The const_iterator */
+            /// Returns a const_iterator to the beginning of the map that stores all XMLPort objects.
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapBegin() const { return this->xmlportObjectContainers_.begin(); }
-            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort objects. @return The const_iterator */
+            /// Returns a const_iterator to the end of the map that stores all XMLPort objects.
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
 
@@ -238,14 +264,14 @@
             void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
 
-            /** @brief Returns the map that stores all Identifiers with their names. @return The map */
+            /// Returns the map that stores all Identifiers with their names.
             static std::map<std::string, Identifier*>& getStringIdentifierMapIntern();
-            /** @brief Returns the map that stores all Identifiers with their names in lowercase. @return The map */
+            /// Returns the map that stores all Identifiers with their names in lowercase.
             static std::map<std::string, Identifier*>& getLowercaseStringIdentifierMapIntern();
-            /** @brief Returns the map that stores all Identifiers with their network IDs. @return The map */
+            /// Returns the map that stores all Identifiers with their network IDs.
             static std::map<uint32_t, Identifier*>& getIDIdentifierMapIntern();
 
-            /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
+            /// Returns the children of the class the Identifier belongs to.
             inline std::set<const Identifier*>& getChildrenIntern() const { return this->children_; }
-            /** @brief Returns the direct children of the class the Identifier belongs to. @return The list of all direct children */
+            /// Returns the direct children of the class the Identifier belongs to.
             inline std::set<const Identifier*>& getDirectChildrenIntern() const { return this->directChildren_; }
 
@@ -253,7 +279,7 @@
 
         private:
-            /** @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents. */
+            /// Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
             inline static void startCreatingHierarchy() { hierarchyCreatingCounter_s++; }
-            /** @brief Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents. */
+            /// Decreases the hierarchyCreatingCounter_s variable, causing the objects to stop storing their parents.
             inline static void stopCreatingHierarchy()  { hierarchyCreatingCounter_s--; }
 
@@ -291,18 +317,21 @@
     // ###     ClassIdentifier     ###
     // ###############################
-    //! The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
-    /**
-        ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
+    /**
+        @brief The ClassIdentifier is derived from Identifier and holds all class-specific functions and variables the Identifier cannot have.
+
+        ClassIdentifier is a Singleton, which means that only one ClassIdentifier for a given type T exists.
         This makes it possible to store information about a class, sharing them with all
         objects of that class without defining static variables in every class.
 
         To be really sure that not more than exactly one object exists (even with libraries),
-        ClassIdentifiers are stored in the Identifier Singleton.
+        ClassIdentifiers are stored in a static map in Identifier.
     */
     template <class T>
     class ClassIdentifier : public Identifier
     {
-        #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
-        #include "Super.h"
+        #ifndef DOXYGEN_SHOULD_SKIP_THIS
+          #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
+          #include "Super.h"
+        #endif
 
         public:
@@ -387,4 +416,6 @@
         @brief Adds an object of the given type to the ObjectList.
         @param object The object to add
+        @param className The name of the class T
+        @param bRootClass True if this is a root class (i.e. it inherits directly from OrxonoxClass)
     */
     template <class T>
Index: code/trunk/src/libraries/core/Iterator.h
===================================================================
--- code/trunk/src/libraries/core/Iterator.h	(revision 7380)
+++ code/trunk/src/libraries/core/Iterator.h	(revision 7401)
@@ -29,10 +29,18 @@
 /**
     @file
-    @brief Definition and implementation of the Iterator class.
-
-    The Iterator of a given class allows to iterate through an ObjectList. Objects in
-    this list are cast to the template argument of the Iterator.
+    @ingroup Object ObjectList
+    @brief Definition of the Iterator class, used to iterate through object-lists.
+
+    @anchor IteratorExample
+
+    @ref orxonox::Iterator "Iterator" allows to iterate through an @ref orxonox::ObjectListBase
+    "ObjectListBase". Objects in this list are cast to the template argument @a T of Iterator<T> using
+    @c dynamic_cast. In contrast to @ref orxonox::ObjectListIterator "ObjectListIterator<T>",
+    @ref orxonox::Iterator "Iterator<T>" can iterate through every object-list. In practice though it
+    is limited to objects of type @a T and its subclasses. Because of the @c dynamic_cast, this iterator
+    is much slower than ObjectListIterator.
 
     Usage:
+    @code
     for (Iterator<myClass> it = anyidentifier->getObjects()->begin(); it != anyidentifier->getObjects()->end(); ++it)
     {
@@ -40,4 +48,5 @@
         myClass* myObject = *it;
     }
+    @endcode
 */
 
@@ -52,5 +61,12 @@
 namespace orxonox
 {
-    //! The Iterator allows to iterate through a given ObjectList
+    /**
+        @brief The Iterator allows to iterate through a given ObjectList.
+
+        Independent of the object-list's type, the objects in the list are always casted
+        to @a T using @c dynamic_cast.
+
+        @see See @ref IteratorExample "Iterator.h" for more information an example.
+    */
     template <class T = OrxonoxClass>
     class Iterator
@@ -200,5 +216,5 @@
                 @return The Iterator itself
             */
-            inline Iterator<T> operator++(int i)
+            inline Iterator<T> operator++(int)
             {
                 Iterator<T> copy = *this;
Index: code/trunk/src/libraries/core/Language.cc
===================================================================
--- code/trunk/src/libraries/core/Language.cc	(revision 7380)
+++ code/trunk/src/libraries/core/Language.cc	(revision 7401)
@@ -168,4 +168,5 @@
         @brief Returns the localisation of a given entry.
         @param label The label of the entry
+        @param bError If true, an error is printed if the label doesn't exist and the default localisation is returned. If false, no error is printed and an empty string is returned.
         @return The localisation
     */
Index: code/trunk/src/libraries/core/Language.h
===================================================================
--- code/trunk/src/libraries/core/Language.h	(revision 7380)
+++ code/trunk/src/libraries/core/Language.h	(revision 7401)
@@ -28,6 +28,14 @@
 
 /**
+    @defgroup Language Language
+    @ingroup Core
+*/
+
+/**
     @file
-    @brief Definition of the Language and the LanguageEntry class.
+    @ingroup Language
+    @brief Declaration of the Language and the LanguageEntry class, as well as some helper functions.
+
+    @anchor LanguageExample
 
     The Language class is used, to get a localisation of a string in the configured language.
@@ -37,8 +45,44 @@
     Usage:
      - Set the entry with the default string:
+       @code
        Language::getInstance()->addEntry("label of the entry", "the string to translate");
+       @endcode
 
      - Get the localisation of the entry in the configured language:
+       @code
        std::cout << Language::getInstance()->getLocalisation("name of the entry") << std::endl;
+       @endcode
+
+    Example:
+    @code
+    int age = 20;
+    AddLanguageEntry("user_age", "Age");
+    std::cout << GetLocalisation("user_age") << ": " << age << std::endl;
+    @endcode
+
+    Resulting output:
+    @code
+    Age: 20
+    @endcode
+
+    The language entry is now defined in @a translation_default.lang:
+    @code
+    user_age=Age
+    @endcode
+
+    We can add a translation for another language, for example @a translation_german.lang:
+    @code
+    user_age=Alter
+    @endcode
+
+    Now change the language in @a orxonox.ini to "german":
+    @code
+    language_ = "german"
+    @endcode
+
+    Now you will see the translated language entry in the resulting output of the above code:
+    @code
+    Alter: 20
+    @endcode
 */
 
@@ -58,5 +102,9 @@
     // ###      LanguageEntry      ###
     // ###############################
-    //! The LanguageEntry class stores the default- and the translated string of a given entry in the language file.
+    /**
+        @brief The LanguageEntry class stores the default- and the translated string of a given entry in the language file.
+
+        This class belongs to the Language class.
+    */
     class _CoreExport LanguageEntry
     {
@@ -105,5 +153,9 @@
     // ###         Language        ###
     // ###############################
-    //! The Language class manges the language files and entries and stores the LanguageEntry objects in a map.
+    /**
+        @brief The Language class manges the language files and entries and stores the LanguageEntry objects in a map.
+
+        @see See @ref LanguageExample "Language.h" for some examples.
+    */
     class _CoreExport Language : public Singleton<Language>
     {
@@ -134,5 +186,5 @@
     };
 
-    //! Shortcut function for Language::addEntry
+    /// Shortcut function for Language::addEntry
     inline void AddLanguageEntry(const LanguageEntryLabel& label, const std::string& fallbackString)
     {
@@ -140,5 +192,5 @@
     }
 
-    //! Shortcut function for Language::getLocalisation
+    /// Shortcut function for Language::getLocalisation
     inline const std::string& GetLocalisation(const LanguageEntryLabel& label)
     {
@@ -146,5 +198,5 @@
     }
 
-    //! Shortcut function for Language::getLocalisation without printing an error in case the label doesn't exist
+    /// Shortcut function for Language::getLocalisation without printing an error in case the label doesn't exist
     inline const std::string& GetLocalisation_noerror(const LanguageEntryLabel& label)
     {
Index: code/trunk/src/libraries/core/Loader.h
===================================================================
--- code/trunk/src/libraries/core/Loader.h	(revision 7380)
+++ code/trunk/src/libraries/core/Loader.h	(revision 7401)
@@ -26,4 +26,14 @@
  *
  */
+
+/**
+    @defgroup Loader Loader
+    @ingroup XML
+*/
+
+/**
+    @file
+    @ingroup XML Loader
+*/
 
 #ifndef _Loader_H__
Index: code/trunk/src/libraries/core/LuaState.h
===================================================================
--- code/trunk/src/libraries/core/LuaState.h	(revision 7380)
+++ code/trunk/src/libraries/core/LuaState.h	(revision 7401)
@@ -27,4 +27,14 @@
  *
  */
+
+/**
+    @defgroup Lua Lua
+    @ingroup Core
+*/
+
+/**
+    @file
+    @ingroup Lua
+*/
 
 #ifndef _LuaState_H__
Index: code/trunk/src/libraries/core/MemoryArchive.cc
===================================================================
--- code/trunk/src/libraries/core/MemoryArchive.cc	(revision 7380)
+++ code/trunk/src/libraries/core/MemoryArchive.cc	(revision 7401)
@@ -54,5 +54,5 @@
     }
 
-    DataStreamPtr MemoryArchive::open(const String& filename) const
+    DataStreamPtr MemoryArchive::open(const Ogre::String& filename) const
     {
         const FileMap& files = archives_s[this->getName()];
@@ -64,6 +64,6 @@
     }
 
-    void MemoryArchive::findFiles(const String& pattern, bool bRecursive,
-        bool bDirs, StringVector* simpleList, FileInfoList* detailList)
+    void MemoryArchive::findFiles(const Ogre::String& pattern, bool bRecursive,
+        bool bDirs, Ogre::StringVector* simpleList, Ogre::FileInfoList* detailList)
     {
         const FileMap& files = archives_s[this->getName()];
@@ -110,5 +110,5 @@
     }
 
-    StringVectorPtr MemoryArchive::find(const String& pattern,
+    StringVectorPtr MemoryArchive::find(const Ogre::String& pattern,
                                             bool recursive, bool dirs)
     {
@@ -118,5 +118,5 @@
     }
 
-    FileInfoListPtr MemoryArchive::findFileInfo(const String& pattern,
+    FileInfoListPtr MemoryArchive::findFileInfo(const Ogre::String& pattern,
         bool recursive, bool dirs)
     {
@@ -126,5 +126,5 @@
     }
 
-    bool MemoryArchive::exists(const String& filename)
+    bool MemoryArchive::exists(const Ogre::String& filename)
     {
         const FileMap& files = archives_s[this->getName()];
Index: code/trunk/src/libraries/core/MemoryArchive.h
===================================================================
--- code/trunk/src/libraries/core/MemoryArchive.h	(revision 7380)
+++ code/trunk/src/libraries/core/MemoryArchive.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup Management Resources
+*/
 
 #ifndef _MemoryArchive_H__
Index: code/trunk/src/libraries/core/MetaObjectList.h
===================================================================
--- code/trunk/src/libraries/core/MetaObjectList.h	(revision 7380)
+++ code/trunk/src/libraries/core/MetaObjectList.h	(revision 7401)
@@ -29,5 +29,6 @@
 /**
     @file
-    @brief Definition of the MetaObjectList class.
+    @ingroup Object ObjectList
+    @brief Declaration of the MetaObjectList class.
 
     The MetaObjectList is a single-linked list, containing all list-elements and their
@@ -46,5 +47,5 @@
     // ###  MetaObjectListElement  ###
     // ###############################
-    //! The list-element of the MetaObjectList
+    /// The list-element of the MetaObjectList
     class _CoreExport MetaObjectListElement
     {
@@ -65,6 +66,7 @@
     // ###     MetaObjectList      ###
     // ###############################
-    //!  The MetaObjectList contains ObjectListBaseElements and their ObjectListBases.
     /**
+        @brief The MetaObjectList contains ObjectListBaseElements and their ObjectListBases.
+
         The MetaObjectList is a single-linked list, containing all list-elements and their
         lists wherein the object that owns the MetaObjectList is registered.
Index: code/trunk/src/libraries/core/Namespace.cc
===================================================================
--- code/trunk/src/libraries/core/Namespace.cc	(revision 7380)
+++ code/trunk/src/libraries/core/Namespace.cc	(revision 7401)
@@ -55,10 +55,4 @@
     }
 
-    /**
-        @brief XML loading and saving.
-        @param xmlelement The XML-element
-        @param loading Loading (true) or saving (false)
-        @return The XML-element
-    */
     void Namespace::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
Index: code/trunk/src/libraries/core/Namespace.h
===================================================================
--- code/trunk/src/libraries/core/Namespace.h	(revision 7380)
+++ code/trunk/src/libraries/core/Namespace.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup XML Loader
+*/
 
 #ifndef _Namespace_H__
Index: code/trunk/src/libraries/core/NamespaceNode.h
===================================================================
--- code/trunk/src/libraries/core/NamespaceNode.h	(revision 7380)
+++ code/trunk/src/libraries/core/NamespaceNode.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup XML Loader
+*/
 
 #ifndef _NamespaceNode_H__
Index: code/trunk/src/libraries/core/ObjectList.h
===================================================================
--- code/trunk/src/libraries/core/ObjectList.h	(revision 7380)
+++ code/trunk/src/libraries/core/ObjectList.h	(revision 7401)
@@ -28,9 +28,16 @@
 
 /**
+    @defgroup ObjectList Object-lists and iterators
+    @ingroup Object
+*/
+
+/**
     @file
-    @brief Definition and implementation of the ObjectList class.
+    @ingroup Object ObjectList
+    @brief Definition of the ObjectList class, a wrapper of ObjectListBase.
 
-    The ObjectList is a wrapper of an ObjectListBase of a given class.
-    Use Iterator<class> to iterate through all objects of the class.
+    @ref orxonox::ObjectList "ObjectList<T>" is a wrapper of an @ref orxonox::ObjectListBase
+    "ObjectListBase" of class @a T. Use @ref orxonox::ObjectListIterator "ObjectListIterator<T>"
+    to iterate through the list.
 */
 
@@ -49,8 +56,10 @@
     // ###       ObjectList        ###
     // ###############################
-    //! The ObjectList contains all objects of the given class.
     /**
-        Wraps the ObjectListBase of the corresponding Identifier.
-        Use ObjectListIterator<class> to iterate through all objects in the list.
+        @brief The ObjectList contains all objects of the given class.
+
+        Wraps the ObjectListBase which contains all objects of type @a T. Use @ref ObjectListIterator
+        "ObjectListIterator<T>" or its typedef ObjectList<T>::iterator to iterate through all objects
+        in the list.
     */
     template <class T>
@@ -60,5 +69,5 @@
             typedef ObjectListIterator<T> iterator;
 
-            /** @brief Returns an Iterator to the first element in the list. @return The Iterator */
+            /// Returns an Iterator to the first element in the list.
             inline static ObjectListElement<T>* begin()
             {
@@ -67,5 +76,5 @@
             }
 
-            /** @brief Returns an Iterator to the element after the last element in the list. @return The Iterator */
+            /// Returns an Iterator to the element after the last element in the list.
             inline static ObjectListElement<T>* end()
             {
@@ -74,5 +83,5 @@
             }
 
-            /** @brief Returns an Iterator to the last element in the list. @return The Iterator */
+            /// Returns an Iterator to the last element in the list.
             inline static ObjectListElement<T>* rbegin()
             {
@@ -81,5 +90,5 @@
             }
 
-            /** @brief Returns an Iterator to the element before the first element in the list. @return The Iterator */
+            /// Returns an Iterator to the element before the first element in the list.
             inline static ObjectListElement<T>* rend()
             {
Index: code/trunk/src/libraries/core/ObjectListBase.cc
===================================================================
--- code/trunk/src/libraries/core/ObjectListBase.cc	(revision 7380)
+++ code/trunk/src/libraries/core/ObjectListBase.cc	(revision 7401)
@@ -30,7 +30,4 @@
     @file
     @brief Implementation of the ObjectListBase class.
-
-    The ObjectListBase is a double-linked list, used by Identifiers to store all objects of a given class.
-    Newly created objects are added through the RegisterObject-macro in its constructor.
 */
 
@@ -70,5 +67,5 @@
     /**
         @brief Increases all Iterators that currently point on the given element (because it gets removed).
-        @param element The element that gets removed
+        @param object The object that gets removed
     */
     void ObjectListBase::notifyIterators(OrxonoxClass* object) const
@@ -82,5 +79,5 @@
     /**
         @brief Adds a new object to the end of the list.
-        @param object The object to add
+        @param element The element to add
         @return The pointer to the new ObjectListBaseElement, needed by the MetaObjectList of the added object
     */
Index: code/trunk/src/libraries/core/ObjectListBase.h
===================================================================
--- code/trunk/src/libraries/core/ObjectListBase.h	(revision 7380)
+++ code/trunk/src/libraries/core/ObjectListBase.h	(revision 7401)
@@ -29,8 +29,10 @@
 /**
     @file
-    @brief Definition of the ObjectListBase class.
+    @ingroup Object ObjectList
+    @brief Declaration of the ObjectListBase class which stores all objects of each class.
 
-    The ObjectListBase is a double-linked list, used by Identifiers to store all objects of a given class.
-    Newly created objects are added through the RegisterObject-macro in its constructor.
+    orxonox::ObjectListBase is a double-linked list, used by @ref orxonox::Identifier "Identifiers"
+    to store all objects of a given class. Newly created objects are added to the list through the
+    @c RegisterObject() macro in the constructor.
 */
 
@@ -48,5 +50,5 @@
     // ###  ObjectListBaseElement  ###
     // ###############################
-    //! The list-element of the ObjectListBase
+    /// The list-element of the ObjectListBase
     class _CoreExport ObjectListBaseElement
     {
@@ -54,5 +56,5 @@
             /**
                 @brief Constructor: Creates the list-element with an object.
-                @param object The object to store
+                @param objectBase The object to store
             */
             ObjectListBaseElement(OrxonoxClass* objectBase) : next_(0), prev_(0), objectBase_(objectBase) {}
@@ -67,5 +69,5 @@
     // ###    ObjectListElement    ###
     // ###############################
-    //! The list-element that actually contains the object
+    /// The list-element that actually contains the object
     template <class T>
     class ObjectListElement : public ObjectListBaseElement
@@ -80,8 +82,14 @@
     // ###     ObjectListBase      ###
     // ###############################
-    //! The ObjectListBase contains all objects of a given class.
     /**
-        The ObjectListBase is used by Identifiers to store all objects of their given class.
-        Use ObjectList<T> to get the list of all T's and Iterator<T> to iterate through them.
+        @brief The ObjectListBase contains all objects of a given class.
+
+        The ObjectListBase is used by Identifiers to store all objects of their class.
+        You can use Identifier::getObjects() to get the object-list from an Identifier.
+        Use @ref Iterator "Iterator<T>" to iterate through them.
+
+        Alternatively you can also use the static helper class @ref orxonox::ObjectList "ObjectList<T>"
+        to get the list of all objects of type @a T. Use @ref ObjectListIterator "ObjectListIterator<T>"
+        or @ref Iterator "Iterator<T>" to iterate through them.
     */
     class _CoreExport ObjectListBase
@@ -95,4 +103,5 @@
             ObjectListBaseElement* add(ObjectListBaseElement* element);
 
+            /// Helper struct, used to export an element and the list to an instance of Iterator.
             struct Export
             {
@@ -102,11 +111,11 @@
             };
 
-            /** @brief Returns a pointer to the first element in the list. @return The element */
+            /// Returns a pointer to the first element in the list. Works only with Iterator.
             inline Export begin() { return ObjectListBase::Export(this, this->first_); }
-            /** @brief Returns a pointer to the element after the last element in the list. @return The element */
+            /// Returns a pointer to the element after the last element in the list. Works only with Iterator.
             inline Export end() { return ObjectListBase::Export(this, 0); }
-            /** @brief Returns a pointer to the last element in the list. @return The element */
+            /// Returns a pointer to the last element in the list. Works only with Iterator.
             inline Export rbegin() { return ObjectListBase::Export(this, this->last_); }
-            /** @brief Returns a pointer to the element in front of the first element in the list. @return The element */
+            /// Returns a pointer to the element in front of the first element in the list. Works only with Iterator.
             inline Export rend() { return ObjectListBase::Export(this, 0); }
 
Index: code/trunk/src/libraries/core/ObjectListIterator.h
===================================================================
--- code/trunk/src/libraries/core/ObjectListIterator.h	(revision 7380)
+++ code/trunk/src/libraries/core/ObjectListIterator.h	(revision 7401)
@@ -29,11 +29,16 @@
 /**
     @file
-    @brief Definition and implementation of the Iterator class.
-
-    The ObjectListIterator of a given class allows to iterate through the
-    ObjectList of this class, containing all objects of that type.
-    This is the only way to access the objects stored in an ObjectList.
+    @ingroup Object ObjectList
+    @brief Definition of the ObjectListIterator class, used to iterate through object-lists.
+
+    @anchor ObjectListIteratorExample
+
+    @ref orxonox::ObjectListIterator "ObjectListIterator<T>" allows to iterate through
+    @ref orxonox::ObjectList "ObjectList<T>", containing all objects of type @a T. In contrast to
+    @ref orxonox::Iterator "Iterator<T>", this iterator is limited to the object-list of type @a T.
+    It is, however, much faster as it doesn't need a @c dynamic_cast.
 
     Usage:
+    @code
     for (ObjectListIterator<myClass> it = ObjectList<myClass>::begin(); it != ObjectList<myClass>::end(); ++it)
     {
@@ -41,4 +46,8 @@
         myClass* myObject = *it;
     }
+    @endcode
+
+    @note @ref orxonox::ObjectList::iterator "ObjectList<T>::iterator" is identical to
+          @ref orxonox::ObjectListIterator "ObjectListIterator<T>" (it's just a typedef).
 */
 
@@ -52,5 +61,9 @@
 namespace orxonox
 {
-    //! The Iterator allows to iterate through the ObjectList of a given class.
+    /**
+        @brief ObjectListIterator<T> allows to iterate through the ObjectList of class @a T.
+
+        @see See @ref ObjectListIteratorExample "ObjectListIterator.h" for more information an example.
+    */
     template <class T>
     class ObjectListIterator
@@ -109,5 +122,5 @@
             /**
                 @brief Assigns the element of another ObjectListIterator.
-                @param element The other ObjectListIterator
+                @param other The other ObjectListIterator
             */
             inline ObjectListIterator<T>& operator=(const ObjectListIterator<T>& other)
@@ -131,5 +144,5 @@
                 @return The ObjectListIterator itself
             */
-            inline ObjectListIterator<T> operator++(int i)
+            inline ObjectListIterator<T> operator++(int)
             {
                 ObjectListIterator<T> copy = *this;
@@ -217,5 +230,5 @@
 
         private:
-            ObjectListElement<T>* element_;        //!< The element the Iterator points at
+            ObjectListElement<T>* element_;        //!< The element the iterator points at
     };
 }
Index: code/trunk/src/libraries/core/OrxonoxClass.cc
===================================================================
--- code/trunk/src/libraries/core/OrxonoxClass.cc	(revision 7380)
+++ code/trunk/src/libraries/core/OrxonoxClass.cc	(revision 7401)
@@ -29,5 +29,5 @@
 /**
     @file
-    @brief Implementation of the OrxonoxClass Class.
+    @brief Implementation of OrxonoxClass.
 */
 
@@ -41,5 +41,7 @@
 namespace orxonox
 {
-    /** @brief Constructor: Sets the default values. */
+    /**
+        @brief Constructor: Sets the default values.
+    */
     OrxonoxClass::OrxonoxClass()
     {
@@ -53,5 +55,7 @@
     }
 
-    /** @brief Destructor: Deletes, if existing, the list of the parents. */
+    /**
+        @brief Destructor: Removes the object from the object-lists, notifies all @ref WeakPtr "weak pointers" that this object is being deleted.
+    */
     OrxonoxClass::~OrxonoxClass()
     {
@@ -72,5 +76,7 @@
     }
 
-    /** @brief Deletes the object if no smart pointers point to this object. Otherwise schedules the object to be deleted as soon as possible. */
+    /**
+        @brief Deletes the object if no @ref orxonox::SmartPtr "smart pointers" point to this object. Otherwise schedules the object to be deleted as soon as possible.
+    */
     void OrxonoxClass::destroy()
     {
@@ -85,4 +91,7 @@
     }
 
+    /**
+        @brief Removes this object from the object-lists.
+    */
     void OrxonoxClass::unregisterObject()
     {
@@ -92,40 +101,40 @@
     }
 
-    /** @brief Returns true if the objects class is of the given type or a derivative. */
+    /// Returns true if the object's class is of the given type or a derivative.
     bool OrxonoxClass::isA(const Identifier* identifier)
         { return this->getIdentifier()->isA(identifier); }
-    /** @brief Returns true if the objects class is exactly of the given type. */
+    /// Returns true if the object's class is exactly of the given type.
     bool OrxonoxClass::isExactlyA(const Identifier* identifier)
         { return this->getIdentifier()->isExactlyA(identifier); }
-    /** @brief Returns true if the objects class is a child of the given type. */
+    /// Returns true if the object's class is a child of the given type.
     bool OrxonoxClass::isChildOf(const Identifier* identifier)
         { return this->getIdentifier()->isChildOf(identifier); }
-    /** @brief Returns true if the objects class is a direct child of the given type. */
+    /// Returns true if the object's class is a direct child of the given type.
     bool OrxonoxClass::isDirectChildOf(const Identifier* identifier)
         { return this->getIdentifier()->isDirectChildOf(identifier); }
-    /** @brief Returns true if the objects class is a parent of the given type. */
+    /// Returns true if the object's class is a parent of the given type.
     bool OrxonoxClass::isParentOf(const Identifier* identifier)
         { return this->getIdentifier()->isParentOf(identifier); }
-    /** @brief Returns true if the objects class is a direct parent of the given type. */
+    /// Returns true if the object's class is a direct parent of the given type.
     bool OrxonoxClass::isDirectParentOf(const Identifier* identifier)
         { return this->getIdentifier()->isDirectParentOf(identifier); }
 
 
-    /** @brief Returns true if the objects class is of the given type or a derivative. */
+    /// Returns true if the object's class is of the given type or a derivative.
     bool OrxonoxClass::isA(const OrxonoxClass* object)
         { return this->getIdentifier()->isA(object->getIdentifier()); }
-    /** @brief Returns true if the objects class is exactly of the given type. */
+    /// Returns true if the object's class is exactly of the given type.
     bool OrxonoxClass::isExactlyA(const OrxonoxClass* object)
         { return this->getIdentifier()->isExactlyA(object->getIdentifier()); }
-    /** @brief Returns true if the objects class is a child of the given type. */
+    /// Returns true if the object's class is a child of the given type.
     bool OrxonoxClass::isChildOf(const OrxonoxClass* object)
         { return this->getIdentifier()->isChildOf(object->getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct child of the given type. */
+    /// Returns true if the object's class is a direct child of the given type.
     bool OrxonoxClass::isDirectChildOf(const OrxonoxClass* object)
         { return this->getIdentifier()->isDirectChildOf(object->getIdentifier()); }
-    /** @brief Returns true if the objects class is a parent of the given type. */
+    /// Returns true if the object's class is a parent of the given type.
     bool OrxonoxClass::isParentOf(const OrxonoxClass* object)
         { return this->getIdentifier()->isParentOf(object->getIdentifier()); }
-    /** @brief Returns true if the objects class is a direct child of the given type. */
+    /// Returns true if the object's class is a direct child of the given type.
     bool OrxonoxClass::isDirectParentOf(const OrxonoxClass* object)
         { return this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
Index: code/trunk/src/libraries/core/OrxonoxClass.h
===================================================================
--- code/trunk/src/libraries/core/OrxonoxClass.h	(revision 7380)
+++ code/trunk/src/libraries/core/OrxonoxClass.h	(revision 7401)
@@ -28,6 +28,12 @@
 
 /**
+    @defgroup OrxonoxClass OrxonoxClass
+    @ingroup Class
+*/
+
+/**
     @file
-    @brief Declaration of the OrxonoxClass Class.
+    @ingroup Class OrxonoxClass
+    @brief Declaration of OrxonoxClass, the base class of all objects and interfaces in Orxonox.
 
     All objects and interfaces of the game-logic (not the engine) are derived from OrxonoxClass.
@@ -53,8 +59,10 @@
 namespace orxonox
 {
-    //! The class all objects and interfaces of the game-logic (not the engine) are derived from.
     /**
-        The BaseObject and Interfaces are derived with 'virtual public OrxonoxClass' from OrxonoxClass.
-        OrxonoxClass is needed to create the class-hierarchy at startup and to store the Identifier and the MetaObjectList.
+        @brief The class all objects and interfaces of the game-logic (not the engine) are derived from.
+
+        The BaseObject and Interfaces are derived with @c virtual @c public @c OrxonoxClass from OrxonoxClass.
+        OrxonoxClass is needed to create the class-hierarchy at startup and to store the Identifier and the
+        MetaObjectList, as well as to provide an interface for SmartPtr and WeakPtr.
     */
     class _CoreExport OrxonoxClass
@@ -76,8 +84,8 @@
             void unregisterObject();
 
-            /** @brief Function to collect the SetConfigValue-macro calls. */
+            /// Function to collect the SetConfigValue-macro calls.
             void setConfigValues() {};
 
-            /** @brief Returns the Identifier of the object. @return The Identifier */
+            /// Returns the Identifier of the object.
             inline Identifier* getIdentifier() const { return this->identifier_; }
 
@@ -89,14 +97,20 @@
             bool isDirectParentOf(const Identifier* identifier);
 
+            /// Returns true if the object's class is of the given type or a derivative.
             template <class B> inline bool isA(const SubclassIdentifier<B>* identifier)
                 { return this->isA(*identifier); }
+            /// Returns true if the object's class is exactly of the given type.
             template <class B> inline bool isExactlyA(const SubclassIdentifier<B>* identifier)
                 { return this->isExactlyA(*identifier); }
+            /// Returns true if the object's class is a child of the given type.
             template <class B> inline bool isChildOf(const SubclassIdentifier<B>* identifier)
                 { return this->isChildOf(*identifier); }
+            /// Returns true if the object's class is a direct child of the given type.
             template <class B> inline bool isDirectChildOf(const SubclassIdentifier<B>* identifier)
                 { return this->isDirectChildOf(*identifier); }
+            /// Returns true if the object's class is a parent of the given type.
             template <class B> inline bool isParentOf(const SubclassIdentifier<B>* identifier)
                 { return this->isParentOf(*identifier); }
+            /// Returns true if the object's class is a direct parent of the given type.
             template <class B> inline bool isDirectParentOf(const SubclassIdentifier<B>* identifier)
                 { return this->isDirectParentOf(*identifier); }
@@ -111,4 +125,5 @@
             virtual void clone(OrxonoxClass*& item) {}
 
+            /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
             inline unsigned int getReferenceCount() const
                 { return this->referenceCount_; }
@@ -131,19 +146,20 @@
             }
 
-            //! Version of getDerivedPointer with template
+            /// Version of getDerivedPointer with template
             template <class T> FORCEINLINE T* getDerivedPointer(unsigned int classID)
             {   return static_cast<T*>(this->getDerivedPointer(classID));   }
-            //! Const version of getDerivedPointer with template
+            /// Const version of getDerivedPointer with template
             template <class T> FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
             {   return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);   }
 
         protected:
+            /// This virtual function is called if destroy() is called and no SmartPtr points to this object. Used in some cases to create a new SmartPtr to prevent destruction.
             virtual void preDestroy() {}
 
         private:
-            /** @brief Increments the reference counter (for smart pointers). */
+            /// Increments the reference counter (for smart pointers).
             inline void incrementReferenceCount()
                 { ++this->referenceCount_; }
-            /** @brief Decrements the reference counter (for smart pointers). */
+            /// Decrements the reference counter (for smart pointers).
             inline void decrementReferenceCount()
             {
@@ -153,21 +169,21 @@
             }
 
-            /** @brief Register a weak pointer which points to this object. */
+            /// Register a weak pointer which points to this object.
             template <class T>
             inline void registerWeakPtr(WeakPtr<T>* pointer)
                 { this->weakPointers_.insert(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
-            /** @brief Unegister a weak pointer which pointed to this object before. */
+            /// Unegister a weak pointer which pointed to this object before.
             template <class T>
             inline void unregisterWeakPtr(WeakPtr<T>* pointer)
                 { this->weakPointers_.erase(reinterpret_cast<WeakPtr<OrxonoxClass>*>(pointer)); }
 
-            Identifier* identifier_;                   //!< The Identifier of the object
-            std::set<const Identifier*>* parents_;     //!< List of all parents of the object
-            MetaObjectList* metaList_;                 //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
-            int referenceCount_;                       //!< Counts the references from smart pointers to this object
-            bool requestedDestruction_;                //!< Becomes true after someone called delete on this object
-            std::set<WeakPtr<OrxonoxClass>*> weakPointers_; //!< All weak pointers which point to this object (and like to get notified if it dies)
+            Identifier* identifier_;                            //!< The Identifier of the object
+            std::set<const Identifier*>* parents_;              //!< List of all parents of the object
+            MetaObjectList* metaList_;                          //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
+            int referenceCount_;                                //!< Counts the references from smart pointers to this object
+            bool requestedDestruction_;                         //!< Becomes true after someone called delete on this object
+            std::set<WeakPtr<OrxonoxClass>*> weakPointers_;     //!< All weak pointers which point to this object (and like to get notified if it dies)
 
-            //! 'Fast map' that holds this-pointers of all derived types
+            /// 'Fast map' that holds this-pointers of all derived types
             std::vector<std::pair<unsigned int, void*> > objectPointers_;
     };
Index: code/trunk/src/libraries/core/PathConfig.h
===================================================================
--- code/trunk/src/libraries/core/PathConfig.h	(revision 7380)
+++ code/trunk/src/libraries/core/PathConfig.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup Management Resources
+*/
 
 #ifndef _PathConfig_H__
Index: code/trunk/src/libraries/core/Resource.h
===================================================================
--- code/trunk/src/libraries/core/Resource.h	(revision 7380)
+++ code/trunk/src/libraries/core/Resource.h	(revision 7401)
@@ -26,4 +26,14 @@
  *
  */
+
+/**
+    @defgroup Resources Resources
+    @ingroup Management
+*/
+
+/**
+    @file
+    @ingroup Management Resources
+*/
 
 #ifndef _Core_Resource_H__
@@ -105,5 +115,5 @@
         /**
             Find out if the named file exists.
-        @param filename
+        @param name
             Fully qualified name of the file to test for
         */
@@ -112,5 +122,5 @@
         /**
             Get struct with information about path and size.
-        @param filename
+        @param name
             Fully qualified name of the file to test for
         */
Index: code/trunk/src/libraries/core/SmartPtr.h
===================================================================
--- code/trunk/src/libraries/core/SmartPtr.h	(revision 7380)
+++ code/trunk/src/libraries/core/SmartPtr.h	(revision 7401)
@@ -29,4 +29,91 @@
 // Inspired by boost::intrusive_ptr by Peter Dimov
 
+/**
+    @defgroup SmartPtr SmartPtr<T> and WeakPtr<T>
+    @ingroup Object
+*/
+
+/**
+    @file
+    @ingroup Object SmartPtr
+    @brief Definition of SmartPtr<T>, wraps a pointer to an object and keeps it alive.
+
+    @anchor SmartPtrExample
+
+    orxonox::SmartPtr is an implementation of a smart pointer - it wraps a pointer to an
+    object  and keeps this object alive until no SmartPtr points to this object anymore.
+    In contrast to orxonox::SharedPtr, SmartPtr works only with classes that are derived
+    from orxonox::OrxonoxClass, because it's an intrusive implementation, meaning the
+    reference counter is stored in the object itself.
+
+    It's possible to use normal pointers and smart pointers to an object simultaneously.
+    You don't have to use SmartPtr all the time, you can create a SmartPtr for an object
+    at any time and also convert it back to a normal pointer if you like. This is possible
+    because the reference counter is stored in the object itself and not in SmartPtr (in
+    contrast to SharedPtr).
+
+    @b Important: If you want to delete an object, you must not use @c delete @c object but
+    rather @c object->destroy(). This function will check if there are smart pointers
+    pointing to the object. If yes, the object will be kept alive until all smart pointes
+    are destroyed. If no, the object is deleted instantly.
+
+    If all smart pointers that point to an object are destroyed, but you never called
+    @c object->destroy() before, the object will not be deleted! All a SmartPtr will do
+    is to really just keep an object alive, but it will not delete it automatically
+    unless you tried to destroy it before.
+
+    Example:
+    @code
+    class MyClass                                           // class declaration
+    {
+        public:
+            void setObject(OtherClass* object)              // passes a normal pointer which will be stored in a SmartPtr
+                { this->object_ = object; }
+
+            OtherClass* getObject() const                   // converts the SmartPtr to a normal pointer and returns it
+                { return this->object_; }
+
+        private:
+            SmartPtr<OtherClass> object_;                   // a pointer to an instance of OtherClass is stored in a SmartPtr
+    };
+    @endcode
+    In this example we assume that OtherClass is a child of OrxonoxClass. We don't care
+    about the inheritance of MyClass though.
+
+    Now we create an instance of MyClass and assign a pointer to an instance of OtherClass:
+    @code
+    MyClass* myclass = new MyClass();                       // create an instance of MyClass
+    OtherClass* object = new OtherClass();                  // create an instance of OtherClass
+    myclass->setObject(object);                             // the object is now stored in a SmartPtr inside myclass
+
+    object->destroy();                                      // we try to destroy object, but there's still a SmartPtr pointing at it.
+
+    # object still exists at this point (because a SmartPtr points at it)
+
+    delete myclass;                                         // now we delete myclass, which also destroys the SmartPtr
+
+    # object doesn't exist anymore (because the SmartPtr is now destroyed)
+    @endcode
+
+    Now we look at the same example, but we first delete myclass, then destroy object:
+    @code
+    MyClass* myclass = new MyClass();                       // create an instance of MyClass
+    OtherClass* object = new OtherClass();                  // create an instance of OtherClass
+    myclass->setObject(object);                             // the object is now stored in a SmartPtr inside myclass
+
+    delete myclass;                                         // we delete myclass, which also destroys the SmartPtr
+
+    # object still exists at this point (because destroy() was not called yet)
+
+    object->destroy();                                      // now we try to destroy object, which works instantly
+
+    # object doesn't exist anymore (because we just destroyed it)
+    @endcode
+
+    Note that in any case @c object->destroy() has to be called to delete the object.
+    However if a SmartPtr points at it, the destruction is delayed until all SmartPtr
+    are destroyed.
+*/
+
 #ifndef _SmartPtr_H__
 #define _SmartPtr_H__
@@ -42,16 +129,24 @@
 namespace orxonox
 {
+    /**
+        @brief A smart pointer which wraps a pointer to an object and keeps this object alive as long as the smart pointer exists.
+
+        @see See @ref SmartPtrExample "this description" for more information and an example.
+    */
     template <class T>
     class SmartPtr
     {
         public:
+            /// Constructor: Initializes the smart pointer with a null pointer.
             inline SmartPtr() : pointer_(0), base_(0)
             {
             }
 
+            /// Constructor: Used to explicitly initialize the smart pointer with a null pointer
             inline SmartPtr(int) : pointer_(0), base_(0)
             {
             }
 
+            /// Constructor: Initializes the smart pointer with a pointer to an object. @param pointer The pointer @param bAddRef If true, the reference counter is increased. Don't set this to false unless you know exactly what you're doing! (for example to avoid circular references if the @c this pointer of the possessing object is stored)
             inline SmartPtr(T* pointer, bool bAddRef = true) : pointer_(pointer), base_(pointer)
             {
@@ -60,4 +155,5 @@
             }
 
+            /// Copy-constructor
             inline SmartPtr(const SmartPtr& other) : pointer_(other.pointer_), base_(other.base_)
             {
@@ -66,4 +162,5 @@
             }
 
+            /// Copy-constructor for smart pointers to objects of another class.
             template <class O>
             inline SmartPtr(const SmartPtr<O>& other) : pointer_(other.get()), base_(other.base_)
@@ -73,4 +170,5 @@
             }
 
+            /// Constructor: Initializes the smart pointer with the pointer that is stored in a WeakPtr.
             template <class O>
             inline SmartPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase())
@@ -80,4 +178,5 @@
             }
 
+            /// Destructor: Decrements the reference counter.
             inline ~SmartPtr()
             {
@@ -86,4 +185,5 @@
             }
 
+            /// Used to assign a null pointer.
             inline SmartPtr& operator=(int)
             {
@@ -92,4 +192,5 @@
             }
 
+            /// Assigns a new pointer.
             inline SmartPtr& operator=(T* pointer)
             {
@@ -98,4 +199,5 @@
             }
 
+            /// Assigns the wrapped pointer of another SmartPtr.
             inline SmartPtr& operator=(const SmartPtr& other)
             {
@@ -104,4 +206,5 @@
             }
 
+            /// Assigns the wrapped pointer of a SmartPtr of another class
             template <class O>
             inline SmartPtr& operator=(const SmartPtr<O>& other)
@@ -111,4 +214,5 @@
             }
 
+            /// Assigns the wrapped pointer of a WeakPtr.
             template <class O>
             inline SmartPtr& operator=(const WeakPtr<O>& other)
@@ -118,4 +222,5 @@
             }
 
+            /// Returns the wrapped pointer as @c T*
             inline T* get() const
             {
@@ -123,4 +228,5 @@
             }
 
+            /// Returns the wrapped pointer as @c OrxonoxClass*
             inline OrxonoxClass* getBase() const
             {
@@ -128,4 +234,5 @@
             }
 
+            /// Implicitly converts the SmartPtr to a pointer of type @c T*
             inline operator T*() const
             {
@@ -133,4 +240,5 @@
             }
 
+            /// Overloaded operator, returns a pointer to the stored object.
             inline T* operator->() const
             {
@@ -139,4 +247,5 @@
             }
 
+            /// Overloaded operator, returns a reference to the stored object.
             inline T& operator*() const
             {
@@ -145,4 +254,5 @@
             }
 
+            /// Returns true if the wrapped pointer is NULL.
             inline bool operator!() const
             {
@@ -150,4 +260,5 @@
             }
 
+            /// Swaps the contents of two smart pointers.
             inline void swap(SmartPtr& other)
             {
@@ -164,4 +275,5 @@
             }
 
+            /// Resets the smart pointer (equivalent to assigning a NULL pointer).
             inline void reset()
             {
@@ -170,8 +282,9 @@
 
         private:
-            T* pointer_;
-            OrxonoxClass* base_;
+            T* pointer_;            ///< The wrapped pointer to an object of type @a T
+            OrxonoxClass* base_;    ///< The wrapped pointer, casted up to OrxonoxClass (this is needed because with just a T* pointer, SmartPtr couln't be used with forward declarations)
     };
 
+    /// Swaps the contents of two smart pointers.
     template <class T>
     void swap(SmartPtr<T>& a, SmartPtr<T>& b)
@@ -180,4 +293,5 @@
     }
 
+    /// Uses a static_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
     template <class T, class U>
     SmartPtr<T> static_pointer_cast(const SmartPtr<U>& p)
@@ -186,4 +300,5 @@
     }
 
+    /// Uses a const_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
     template <class T, class U>
     SmartPtr<T> const_pointer_cast(const SmartPtr<U>& p)
@@ -192,4 +307,5 @@
     }
 
+    /// Uses a dynamic_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new SmartPtr<T>.
     template <class T, class U>
     SmartPtr<T> dynamic_pointer_cast(const SmartPtr<U>& p)
Index: code/trunk/src/libraries/core/SubclassIdentifier.h
===================================================================
--- code/trunk/src/libraries/core/SubclassIdentifier.h	(revision 7380)
+++ code/trunk/src/libraries/core/SubclassIdentifier.h	(revision 7401)
@@ -29,8 +29,36 @@
 /**
     @file
+    @ingroup Class Identifier
     @brief Definition of SubclassIdentifier.
+
+    @anchor SubclassIdentifierExample
 
     SubclassIdentifier is a separated class, acting like an Identifier, but has a given class.
     You can only assign Identifiers of exactly the given class or of a derivative to a SubclassIdentifier.
+
+    Example:
+
+    You can assign an Identifier either through the constructor or by using the assignment @c operator=:
+    @code
+    SubclassIdentifier<BaseClass> identifier = Class(SubClass);
+    @endcode
+
+    The @c operator-> is overloaded an returns the assigned Identifier. That way you can just call
+    functions of the assigned Identifier by using @c ->function():
+    @code
+    SubclassIdentifier<BaseClass> identifier = Class(SubClass);
+    identifier->getName();      // returns "SubClass"
+    @endcode
+
+    There are two possibilities to create an object out of a SubclassIdentifier: Either you just use
+    the @c fabricate() function of the assigned Identifier through the overloaded @c operator->, which
+    returns a @c BaseObject* pointer, or you use the function of SubclassIdentifier, this time by using
+    @c operator., which returns a @c BaseClass* pointer (@a BaseClass is the baseclass specified by the
+    template argument):
+    @code
+    identifier->fabricate();    // calls Identifier::fabricate(), creates a SubClass, returns a BaseObject* pointer
+
+    identifier.fabricate();     // calls SubclassIdentifier::fabricate(), creates a SubClass, returns a BaseClass* pointer
+    @endcode
 */
 
@@ -49,9 +77,13 @@
     // ###   SubclassIdentifier    ###
     // ###############################
-    //! The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
     /**
+        @brief The SubclassIdentifier acts almost like an Identifier, but has some prerequisites.
+
         You can only assign an Identifier that belongs to a class T (or derived) to a SubclassIdentifier<T>.
-        If you assign something else, the program aborts.
-        Because we know the minimum type, a dynamic_cast is done, which makes it easier to create a new object.
+        If you assign something else, the program prints an error.
+
+        Because we know the base-type, a @c dynamic_cast is done, which makes it easier to create a new object.
+
+        @see See @ref SubclassIdentifierExample "SubclassIdentifier.h" for some examples.
     */
     template <class T>
@@ -59,7 +91,5 @@
     {
         public:
-            /**
-                @brief Constructor: Automaticaly assigns the Identifier of the given class.
-            */
+            /// Constructor: Automaticaly assigns the Identifier of the given class.
             SubclassIdentifier()
             {
@@ -67,8 +97,5 @@
             }
 
-            /**
-                @brief Constructor: Assigns the given Identifier.
-                @param identifier The Identifier
-            */
+            /// Constructor: Assigns the given Identifier.
             SubclassIdentifier(Identifier* identifier)
             {
@@ -76,8 +103,5 @@
             }
 
-            /**
-                @brief Copyconstructor: Assigns the identifier of the other SubclassIdentifier.
-                @param identifier The other SublcassIdentifier
-            */
+            /// Copyconstructor: Assigns the identifier of another SubclassIdentifier.
             template <class O>
             SubclassIdentifier(const SubclassIdentifier<O>& identifier)
@@ -113,8 +137,5 @@
             }
 
-            /**
-                @brief Overloading of the = operator: assigns the identifier of the other SubclassIdentifier.
-                @param identifier The other SublcassIdentifier
-            */
+            /// Overloading of the = operator: assigns the identifier of another SubclassIdentifier.
             template <class O>
             SubclassIdentifier<T>& operator=(const SubclassIdentifier<O>& identifier)
@@ -123,7 +144,5 @@
             }
 
-            /**
-                @brief Overloading of the * operator: returns the assigned identifier.
-            */
+            /// Overloading of the * operator: returns the assigned identifier.
             inline Identifier* operator*() const
             {
@@ -131,7 +150,5 @@
             }
 
-            /**
-                @brief Overloading of the -> operator: returns the assigned identifier.
-            */
+            /// Overloading of the -> operator: returns the assigned identifier.
             inline Identifier* operator->() const
             {
@@ -139,7 +156,5 @@
             }
 
-            /**
-                @brief Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
-            */
+            /// Returns the assigned identifier. This allows you to assign a SubclassIdentifier to a normal Identifier*.
             inline operator Identifier*() const
             {
@@ -147,8 +162,5 @@
             }
 
-            /**
-                @brief Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
-                @return The new object
-            */
+            /// Creates a new object of the type of the assigned Identifier and dynamic_casts it to the minimal type given by T.
             T* fabricate(BaseObject* creator) const
             {
@@ -181,5 +193,5 @@
             }
 
-            /** @brief Returns the assigned identifier. @return The identifier */
+            /// Returns the assigned identifier.
             inline Identifier* getIdentifier() const
                 { return this->identifier_; }
Index: code/trunk/src/libraries/core/Super.h
===================================================================
--- code/trunk/src/libraries/core/Super.h	(revision 7380)
+++ code/trunk/src/libraries/core/Super.h	(revision 7401)
@@ -28,37 +28,42 @@
 
 /**
+    @defgroup Super Super
+    @ingroup Class
+*/
+
+/**
     @file
-    @brief Definition of all super-function related macros.
-
-    This file defines all macros needed to add a new "super-function".
-    If you add a super-function, you can call SUPER(myclass, functionname) inside your
-    code and the function of the parentclass gets called. This is comparable with
-    super.functionname() in Java or other languages.
-
-    This works only with virtual functions that return nothing (void) and belong to
-    classes that have an Identifier. Arguments however are supported.
-
-    To add a new super-function, you have process 4 steps:
-
-    1) Add a new SUPER macro
-       This allows you to call the super-function in your code.
-       Location: This file (Super.h), marked with --> HERE <-- comments (1/3)
-
-    2) Call the SUPER_FUNCTION_GLOBAL_DECLARATION_PART1/2 macros.
-       This defines some global classes and templates, needed to create and call the super-functions.
-       Location: This file (Super.h), marked with --> HERE <-- comments (2/3)
-
-    3) Call the SUPER_INTRUSIVE_DECLARATION macro.
-       This will be included into the declaration of ClassIdentifier<T>.
-       Location: This file (Super.h), marked with --> HERE <-- comments (3/3)
-
-    4) Call the SUPER_FUNCTION macro.
+    @ingroup Class Super
+    @brief Definition of all super-function related macros, used to call functions of the base class.
+
+    This file defines all macros needed to add a new "super-function". If you add
+    a super-function, you can call <tt>SUPER(myclass, functionname, arguments)</tt>
+    inside your code and the function of the parent-class gets called. This is comparable
+    to <tt>super.functionname(arguments)</tt> in Java or other languages.
+
+    This works only with virtual functions that return nothing (@c void) and belong to
+    classes that have an @ref orxonox::Identifier "Identifier". Arguments however are
+    supported, there's no limitation for their number and type, except that the type has
+    to be known in Super.h.
+
+    To add a new super-function, you have to process 4 steps:
+
+    -# Add a new @c SUPER macro <br />
+       This allows you to call the super-function in your code. <br />
+       Location: This file (Super.h), marked with "--> HERE <--" comments (1/3)
+    -# Call the @c SUPER_FUNCTION_GLOBAL_DECLARATION_PART1/2 macros. <br />
+       This defines some global classes and templates, needed to create and call the super-functions. <br />
+       Location: This file (Super.h), marked with "--> HERE <--" comments (2/3)
+    -# Call the @c SUPER_INTRUSIVE_DECLARATION macro. <br />
+       This will be included into the declaration of @c ClassIdentifier<T>. <br />
+       Location: This file (Super.h), marked with "--> HERE <--" comments (3/3)
+    -# Call the @c SUPER_FUNCTION macro. <br />
        This defines a partially specialized template that will decide if a class is "super" to another class.
-       If the check returns true, a SuperFunctionCaller gets created, which will be used by the SUPER macro.
+       If the check returns true, a @c SuperFunctionCaller gets created, which will be used by the @c SUPER macro.
        You have to add this into the header-file of the baseclass of the super-function (the class that first
        implements the function), below the class declaration. You can't call it directly in this file, because
-       otherwise you had to include the headerfile right here, which would cause some ugly backdependencies,
-       include loops and slower compilation.
-       Dont forget to include Super.h in the header-file.
+       otherwise you had to include the headerfile right here, which would cause some ugly back-dependencies,
+       include loops and slower compilation. <br />
+       Dont forget to include Super.h in the header-file. <br />
        Location: The header-file of the baseclass (Baseclass.h), below the class declaration
 */
@@ -205,5 +210,5 @@
     */
 
-    // SUPER-macro: Calls Parent::functionname() where Parent is the direct parent of classname
+    /// SUPER-macro: Calls Parent::functionname(...) where Parent is the direct parent of @a classname
     #ifdef ORXONOX_COMPILER_MSVC
         #define SUPER(classname, functionname, ...) \
Index: code/trunk/src/libraries/core/Template.h
===================================================================
--- code/trunk/src/libraries/core/Template.h	(revision 7380)
+++ code/trunk/src/libraries/core/Template.h	(revision 7401)
@@ -26,4 +26,14 @@
  *
  */
+
+/**
+    @defgroup Template Template
+    @ingroup XML
+*/
+
+/**
+    @file
+    @ingroup XML Template
+*/
 
 #ifndef _Template_H__
Index: code/trunk/src/libraries/core/Thread.h
===================================================================
--- code/trunk/src/libraries/core/Thread.h	(revision 7380)
+++ code/trunk/src/libraries/core/Thread.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup ThreadPool
+*/
 
 #ifndef _Thread_H__
Index: code/trunk/src/libraries/core/ThreadPool.h
===================================================================
--- code/trunk/src/libraries/core/ThreadPool.h	(revision 7380)
+++ code/trunk/src/libraries/core/ThreadPool.h	(revision 7401)
@@ -26,4 +26,14 @@
  *
  */
+
+/**
+    @defgroup ThreadPool Thread pool
+    @ingroup Core
+*/
+
+/**
+    @file
+    @ingroup ThreadPool
+*/
 
 #ifndef _ThreadPool_H__
Index: code/trunk/src/libraries/core/ToluaInterface.h
===================================================================
--- code/trunk/src/libraries/core/ToluaInterface.h	(revision 7380)
+++ code/trunk/src/libraries/core/ToluaInterface.h	(revision 7401)
@@ -29,4 +29,6 @@
 /**
 @file
+@ingroup Lua
+@brief
     This is required because tolua would parse this macro in LuaState.h and fail
 */
Index: code/trunk/src/libraries/core/WeakPtr.h
===================================================================
--- code/trunk/src/libraries/core/WeakPtr.h	(revision 7380)
+++ code/trunk/src/libraries/core/WeakPtr.h	(revision 7401)
@@ -29,4 +29,53 @@
 // Inspired by boost::intrusive_ptr by Peter Dimov
 
+/**
+    @file
+    @ingroup Object SmartPtr
+    @brief Definition of WeakPtr<T>, wraps a pointer to an object.
+
+    @anchor WeakPtrExample
+
+    A WeakPtr wraps a pointer to an object. If the object gets deleted, the WeakPtr becomes
+    NULL. This can be used to store pointers to objects without knowing when they will be
+    destroyed.
+
+    WeakPtr works only with objects that are derived from orxonox::OrxonoxClass, because
+    WeakPtr is intrusive and registers itself in the stored object, to get a notification if
+    the object is being deleted.
+
+    Example:
+    @code
+    MyClass* object = new MyClass();                    // create an instance of MyClass
+
+    WeakPtr<MyClass> pointer = object;                  // create a WeakPtr and assign the object
+
+    if (pointer)                                        // checks if pointer is not NULL (which is true)
+        pointer->someFunction();                        // calls MyClass::someFunction()
+
+    object->destroy();                                  // calls destroy() which deletes the object
+
+    if (pointer)                                        // checks if pointer is not NULL (which is now false)
+        pointer->someFunction();                        // this will not be executed
+    @endcode
+    In this example we assumed that MyClass is derived of OrxonoxClass (otherwise it couldn't
+    be used with a WeakPtr).
+
+    A callback can be registerd with the WeakPtr that will be called if the object gets deleted.
+    @code
+    void myCallback()                                   // definition of the callback function
+    {
+        COUT(0) << "Object destroyed" << std::endl;
+    }
+
+    MyClass* object = new MyClass();                    // create an instance of MyClass
+
+    WeakPtr<MyClass> pointer = object;                  // create a WeakPtr and assign the object
+
+    pointer.setCallback(createFunctor(&myCallback));    // defines a callback
+
+    object->destroy();                                  // calls destroy() which deletes the object. prints "Object destroyed" to the console
+    @endcode
+*/
+
 #ifndef _WeakPtr_H__
 #define _WeakPtr_H__
@@ -41,4 +90,9 @@
 namespace orxonox
 {
+    /**
+        @brief WeakPtr wraps a pointer to an object, which becomes NULL if the object is deleted.
+
+        @see See @ref WeakPtrExample "this description" for more information and an example.
+    */
     template <class T>
     class WeakPtr
@@ -47,12 +101,15 @@
 
         public:
+            /// Constructor: Initializes the weak pointer with a null pointer.
             inline WeakPtr() : pointer_(0), base_(0), callback_(0)
             {
             }
 
+            /// Constructor: Used to explicitly initialize the weak pointer with a null pointer
             inline WeakPtr(int) : pointer_(0), base_(0), callback_(0)
             {
             }
 
+            /// Constructor: Initializes the weak pointer with a pointer to an object.
             inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
             {
@@ -61,4 +118,5 @@
             }
 
+            /// Copy-constructor
             inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(0)
             {
@@ -67,4 +125,5 @@
             }
 
+            /// Copy-constructor for weak pointers to objects of another class.
             template <class O>
             inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.base_), callback_(0)
@@ -74,4 +133,5 @@
             }
 
+            /// Destructor
             inline ~WeakPtr()
             {
@@ -81,4 +141,5 @@
             }
 
+            /// Used to assign a null pointer.
             inline WeakPtr& operator=(int)
             {
@@ -87,4 +148,5 @@
             }
 
+            /// Assigns a new pointer.
             inline WeakPtr& operator=(T* pointer)
             {
@@ -93,4 +155,5 @@
             }
 
+            /// Assigns the wrapped pointer of another WeakPtr.
             inline WeakPtr& operator=(const WeakPtr& other)
             {
@@ -99,4 +162,5 @@
             }
 
+            /// Assigns the wrapped pointer of a WeakPtr of another class
             template <class O>
             inline WeakPtr& operator=(const WeakPtr<O>& other)
@@ -106,4 +170,5 @@
             }
 
+            /// Returns the wrapped pointer as @c T*
             inline T* get() const
             {
@@ -111,4 +176,5 @@
             }
 
+            /// Returns the wrapped pointer as @c OrxonoxClass*
             inline OrxonoxClass* getBase() const
             {
@@ -116,4 +182,5 @@
             }
 
+            /// Implicitly converts the WeakPtr to a pointer of type @c T*
             inline operator T*() const
             {
@@ -121,4 +188,5 @@
             }
 
+            /// Overloaded operator, returns a pointer to the stored object.
             inline T* operator->() const
             {
@@ -127,4 +195,5 @@
             }
 
+            /// Overloaded operator, returns a reference to the stored object.
             inline T& operator*() const
             {
@@ -133,4 +202,5 @@
             }
 
+            /// Returns true if the wrapped pointer is NULL.
             inline bool operator!() const
             {
@@ -138,4 +208,5 @@
             }
 
+            /// Swaps the contents of two weak pointers.
             inline void swap(WeakPtr& other)
             {
@@ -162,4 +233,5 @@
             }
 
+            /// Resets the weak pointer (equivalent to assigning a NULL pointer).
             inline void reset()
             {
@@ -167,4 +239,5 @@
             }
 
+            /// Registers a callback that will be executed if the stored object is destroyed.
             inline void setCallback(const FunctorPtr& callback)
             {
@@ -172,4 +245,5 @@
             }
 
+            /// Returns the registered callback.
             inline const FunctorPtr& getCallback() const
             {
@@ -178,4 +252,5 @@
 
         private:
+            /// Will be called by OrxonoxClass::~OrxonoxClass() if the stored object is deleted. Resets the wrapped pointer and executes the callback.
             inline void objectDeleted()
             {
@@ -186,9 +261,10 @@
             }
 
-            T* pointer_;
-            OrxonoxClass* base_;
-            FunctorPtr callback_;
+            T* pointer_;            ///< The wrapped pointer to an object of type @a T
+            OrxonoxClass* base_;    ///< The wrapped pointer, casted up to OrxonoxClass (this is needed because with just a T* pointer, WeakPtr couln't be used with forward declarations)
+            FunctorPtr callback_;   ///< This callback will be executed if the stored object is deleted
     };
 
+    /// Swaps the contents of two weak pointers.
     template <class T>
     void swap(WeakPtr<T>& a, WeakPtr<T>& b)
@@ -197,4 +273,5 @@
     }
 
+    /// Uses a static_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new WeakPtr<T>.
     template <class T, class U>
     WeakPtr<T> static_pointer_cast(const WeakPtr<U>& p)
@@ -203,4 +280,5 @@
     }
 
+    /// Uses a const_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new WeakPtr<T>.
     template <class T, class U>
     WeakPtr<T> const_pointer_cast(const WeakPtr<U>& p)
@@ -209,4 +287,5 @@
     }
 
+    /// Uses a dynamic_cast to cast a pointer of type U* to a pointer of type T* and returns it in a new WeakPtr<T>.
     template <class T, class U>
     WeakPtr<T> dynamic_pointer_cast(const WeakPtr<U>& p)
Index: code/trunk/src/libraries/core/WindowEventListener.h
===================================================================
--- code/trunk/src/libraries/core/WindowEventListener.h	(revision 7380)
+++ code/trunk/src/libraries/core/WindowEventListener.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup Graphics
+*/
 
 #ifndef _WindowEventListener_H__
Index: code/trunk/src/libraries/core/XMLFile.h
===================================================================
--- code/trunk/src/libraries/core/XMLFile.h	(revision 7380)
+++ code/trunk/src/libraries/core/XMLFile.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup XML XMLPort
+*/
 
 #ifndef _XMLFile_H__
Index: code/trunk/src/libraries/core/XMLNameListener.h
===================================================================
--- code/trunk/src/libraries/core/XMLNameListener.h	(revision 7380)
+++ code/trunk/src/libraries/core/XMLNameListener.h	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @ingroup XML XMLPort
+*/
+
 #ifndef _XMLNameListener_H__
 #define _XMLNameListener_H__
Index: code/trunk/src/libraries/core/XMLPort.h
===================================================================
--- code/trunk/src/libraries/core/XMLPort.h	(revision 7380)
+++ code/trunk/src/libraries/core/XMLPort.h	(revision 7401)
@@ -28,5 +28,11 @@
 
 /**
+    @defgroup XMLPort XMLPort
+    @ingroup XML
+*/
+
+/**
     @file
+    @ingroup XML XMLPort
     @brief Declaration of the XMLPort helper classes and macros.
 
@@ -69,5 +75,7 @@
 
     In the XML file, a param or attribute will be set like this:
+    @code
     <classname paramname="value" />
+    @endcode
 
     The macro will then call loadfunction(value) to set the given value (or call savefunction() to
@@ -88,5 +96,7 @@
 
     In the XML file, a param or attribute will be set like this:
+    @code
     <classname paramname="value" />
+    @endcode
 
     The macro will then store "value" in the variable or read it when saving.
@@ -148,10 +158,12 @@
     @param paramname The name of the attribute
     @param loadfunction The function to set the attribute inside of the member object.
-    @param loadfunction The function to get the attribute from the member object
+    @param savefunction The function to get the attribute from the member object
+    @param xmlelement The XML-element that is parsed by this macro
+    @param mode Loading or saving
 
     Sometimes you'll have a member object in your class, which has it's own load- and savefunctions.
     With this macro, you can simply use them instead of writing your own functions.
 
-    @example
+    Example:
     Your class is called SpaceShip and this class has an object (myPilot_) of class Pilot. Pilot has a name
     and two functions, setName(name) and getName(). Now you want an attribute "pilotname" in your
@@ -196,5 +208,5 @@
     @param sectionname The name of the subsection in the XML file that encloses the sub-objects ("" means no subsection)
     @param loadfunction The function to add a new object to the class
-    @param loadfunction The function to get all added objects from the class
+    @param savefunction The function to get all added objects from the class
     @param xmlelement The XMLElement (received through the XMLPort function)
     @param mode The mode (load/save) (received through the XMLPort function)
@@ -210,9 +222,11 @@
     likely the best option, so this is usually true.
 
-    @note
+    @details
     The load- and savefunctions have to follow an exactly defined protocol.
     Loadfunction:
       The loadfunction gets a pointer to the object.
-      > void loadfunction(objectclass* pointer);
+      @code
+      void loadfunction(objectclass* pointer);
+      @endcode
 
     Savefunction:
@@ -220,7 +234,10 @@
       gets called again, but with index + 1. It's the functions responsibility to do something smart
       with the index and to return 0 if all objects were returned.
-      > objectclass* savefunction(unsigned int index) const;
+      @code
+      objectclass* savefunction(unsigned int index) const;
+      @endcode
 
       Possible implementation:
+      @code
         objectclass* savefunction(unsigned int index) const
         {
@@ -230,10 +247,14 @@
             return 0;
         }
-
-    @example
+      @endcode
+
+    Example:
     Possible usage of the macro:
-    > XMLPortObject(SpaceShip, Weapon, "weapons", addWeapon, getWeapon, xmlelement, mode, false, true);
+    @code
+    XMLPortObject(SpaceShip, Weapon, "weapons", addWeapon, getWeapon, xmlelement, mode, false, true);
+    @endcode
 
     Now you can add weapons through the XML file:
+    @code
     <SpaceShip someattribute="..." ...>
       <weapons>
@@ -243,4 +264,5 @@
       </weapons>
     </SpaceShip>
+    @endcode
 
     Note that "weapons" is the subsection. This allows you to add more types of sub-objects. In our example,
Index: code/trunk/src/libraries/core/command/ArgumentCompleter.h
===================================================================
--- code/trunk/src/libraries/core/command/ArgumentCompleter.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/ArgumentCompleter.h	(revision 7401)
@@ -27,4 +27,27 @@
  */
 
+/**
+    @defgroup ArgumentCompletion Argument completion
+    @ingroup Command
+*/
+
+/**
+    @file
+    @ingroup Command ArgumentCompletion
+    @brief Definition of the orxonox::ArgumentCompleter class that is used to execute @ref ArgumentCompletionFunctions.h "argument completion functions".
+
+    An ArgumentCompleter can be assigned to an orxonox::ConsoleCommand using
+    @ref orxonox::ConsoleCommand::argumentCompleter "argumentCompleter()".
+    The ArgumentCompleter calls an argument completion function that is defined
+    in ArgumentCompletionFunctions.h. This can be used to list possible arguments
+    for console commands and to allow auto-completion.
+
+    Instances of ArgumentCompleter are usually not created manually but rather
+    by the macros defined in ArgumentCompletionFunctions.h. There you'll also
+    find some examples.
+
+    @see See the @ref ArgumentCompletionExample "examples".
+*/
+
 #ifndef _ArgumentCompleter_H__
 #define _ArgumentCompleter_H__
@@ -35,14 +58,28 @@
 namespace orxonox
 {
+    /**
+        @brief This class executes an argument completion function and returns a list of the possible arguments.
+
+        ArgumentCompleter is used to wrap argument completion functions as defined
+        in ArgumentCompletionFunctions.h and can be assigned to a ConsoleCommand to
+        create a list of possible arguments.
+
+        @see See ArgumentCompleter.h for more information.
+        @see See @ref ArgumentCompletionExample "ArgumentCompletionFunctions.h" for an example.
+    */
     class _CoreExport ArgumentCompleter
     {
         public:
-            ArgumentCompleter(ArgumentCompletionList (*function) (void), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(0), function_0_(function) {}
-            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(1), function_1_(function) {}
-            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(2), function_2_(function) {}
-            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(3), function_3_(function) {}
-            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(4), function_4_(function) {}
-            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(5), function_5_(function) {}
+            ArgumentCompleter(ArgumentCompletionList (*function) (void), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(0), function_0_(function) {} ///< Constructor, assigns a function-pointer with no arguments.
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(1), function_1_(function) {} ///< Constructor, assigns a function-pointer with one argument.
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(2), function_2_(function) {} ///< Constructor, assigns a function-pointer with two arguments.
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(3), function_3_(function) {} ///< Constructor, assigns a function-pointer with three arguments.
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(4), function_4_(function) {} ///< Constructor, assigns a function-pointer with four arguments.
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5), bool bUseMultipleWords) : bUseMultipleWords_(bUseMultipleWords), paramCount_(5), function_5_(function) {} ///< Constructor, assigns a function-pointer with five arguments.
 
+            /**
+                @brief Calls the argument completion function with a maximum of five parameters.
+                @return Returns the list of possible arguments, created by the argument completion function
+            */
             ArgumentCompletionList operator()(const std::string& param1 = "", const std::string& param2 = "", const std::string& param3 = "", const std::string& param4 = "", const std::string& param5 = "")
             {
@@ -66,16 +103,17 @@
             }
 
+            /// Returns true if the argument completion list supports multiple words.
             inline bool useMultipleWords() const
                 { return this->bUseMultipleWords_; }
 
         private:
-            bool bUseMultipleWords_;
-            unsigned char paramCount_;
-            ArgumentCompletionList (*function_0_) (void);
-            ArgumentCompletionList (*function_1_) (const std::string& param1);
-            ArgumentCompletionList (*function_2_) (const std::string& param1, const std::string& param2);
-            ArgumentCompletionList (*function_3_) (const std::string& param1, const std::string& param2, const std::string& param3);
-            ArgumentCompletionList (*function_4_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4);
-            ArgumentCompletionList (*function_5_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5);
+            bool bUseMultipleWords_;    ///< If true, the argument completion list supports multiple words
+            unsigned char paramCount_;  ///< The number of parameters of the argument completion function
+            ArgumentCompletionList (*function_0_) (void);   ///< Function-pointer for an argument completion function with no arguments
+            ArgumentCompletionList (*function_1_) (const std::string& param1);   ///< Function-pointer for an argument completion function with one argument
+            ArgumentCompletionList (*function_2_) (const std::string& param1, const std::string& param2);   ///< Function-pointer for an argument completion function with two arguments
+            ArgumentCompletionList (*function_3_) (const std::string& param1, const std::string& param2, const std::string& param3);   ///< Function-pointer for an argument completion function with three arguments
+            ArgumentCompletionList (*function_4_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4);   ///< Function-pointer for an argument completion function with four arguments
+            ArgumentCompletionList (*function_5_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5);   ///< Function-pointer for an argument completion function with five arguments
     };
 }
Index: code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.cc
===================================================================
--- code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.cc	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @brief Implementation of all argument completion functions
+*/
 
 #include "ArgumentCompletionFunctions.h"
@@ -53,4 +58,7 @@
     namespace autocompletion
     {
+        /**
+            @brief Fallback implementation, returns an empty list.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(fallback)()
         {
@@ -60,4 +68,7 @@
         namespace detail
         {
+            /**
+                @brief Returns true if a group of console commands is visible (i.e. if at least one command in this group is visible).
+            */
             bool groupIsVisible(const std::map<std::string, ConsoleCommand*>& group, bool bOnlyShowHidden)
             {
@@ -69,9 +80,19 @@
             }
 
+            /**
+                @brief Returns a list of all console command groups AND all console command shortcuts.
+                @param fragment The last argument
+                @param bOnlyShowHidden If true, only hidden groups and commands are returned
+            */
             ArgumentCompletionList _groupsandcommands(const std::string& fragment, bool bOnlyShowHidden)
             {
+                // note: this function returns only arguments that begin with "fragment", which would't be necessary for the
+                //       auto-completion, but it's necessary to place the line-break "\n" between groups and commands
+                //       only if both groups AND commands are in the list.
+
                 ArgumentCompletionList groupList;
                 std::string fragmentLC = getLowercase(fragment);
 
+                // get all the groups that are visible (except the shortcut group "")
                 const std::map<std::string, std::map<std::string, ConsoleCommand*> >& commands = ConsoleCommand::getCommands();
                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.begin(); it_group != commands.end(); ++it_group)
@@ -79,10 +100,13 @@
                         groupList.push_back(ArgumentCompletionListElement(it_group->first, getLowercase(it_group->first)));
 
+                // now add all shortcuts (in group "")
                 std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = commands.find("");
                 if (it_group != commands.end())
                 {
+                    // add a line-break if the list isn't empty
                     if (!groupList.empty())
                         groupList.push_back(ArgumentCompletionListElement("", "", "\n"));
 
+                    // add the shortcuts
                     for (std::map<std::string, ConsoleCommand*>::const_iterator it_command = it_group->second.begin(); it_command != it_group->second.end(); ++it_command)
                         if (it_command->second->isActive() && it_command->second->hasAccess() && (!it_command->second->isHidden())^bOnlyShowHidden && (fragmentLC == "" || getLowercase(it_command->first).find_first_of(fragmentLC) == 0))
@@ -90,4 +114,5 @@
                 }
 
+                // if no shortcut was added, remove the line-break again
                 if (!groupList.empty() && groupList.back().getDisplay() == "\n")
                     groupList.pop_back();
@@ -96,4 +121,10 @@
             }
 
+            /**
+                @brief Returns a list of all console commands in a given group.
+                @param fragment The last argument
+                @param group The group's name
+                @param bOnlyShowHidden If true, only hidden console commands are returned
+            */
             ArgumentCompletionList _subcommands(const std::string& fragment, const std::string& group, bool bOnlyShowHidden)
             {
@@ -102,4 +133,5 @@
                 std::string groupLC = getLowercase(group);
 
+                // find the iterator of the given group
                 std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommands().begin();
                 for ( ; it_group != ConsoleCommand::getCommands().end(); ++it_group)
@@ -107,4 +139,5 @@
                         break;
 
+                // add all commands in the group to the list
                 if (it_group != ConsoleCommand::getCommands().end())
                 {
@@ -118,4 +151,7 @@
         }
 
+        /**
+            @brief Returns a list of all console command groups AND all console command shortcuts.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(groupsandcommands)(const std::string& fragment)
         {
@@ -123,4 +159,7 @@
         }
 
+        /**
+            @brief Returns a list of all console commands in a given group.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(subcommands)(const std::string& fragment, const std::string& group)
         {
@@ -128,4 +167,9 @@
         }
 
+        /**
+            @brief Returns a list of commands and groups and also supports auto-completion of the arguments of these commands.
+
+            This is a multi-word function, because commands are composed of 1-2 words and additional arguments.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_MULTI(command)(const std::string& fragment)
         {
@@ -145,4 +189,11 @@
         }
 
+        /**
+            @brief Returns a list of hidden commands and groups and also supports auto-completion of the arguments of these commands.
+
+            This is a multi-word function, because commands are composed of 1-2 words and additional arguments.
+
+            This function makes commands visible that would usually be hidden.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_MULTI(hiddencommand)(const std::string& fragment)
         {
@@ -170,4 +221,11 @@
         }
 
+        /**
+            @brief Returns possible files and directories and also supports files in arbitrary deeply nested subdirectories.
+
+            This function returns files and directories in the given path. This allows to
+            navigate iteratively through the file system. The first argument @a fragment
+            is used to get the current path.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(files)(const std::string& fragment)
         {
@@ -211,4 +269,7 @@
         }
 
+        /**
+            @brief Returns the sections of the config file.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(settingssections)()
         {
@@ -222,4 +283,7 @@
         }
 
+        /**
+            @brief Returns the entries in a given section of the config file.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(settingsentries)(const std::string& fragment, const std::string& section)
         {
@@ -235,4 +299,7 @@
         }
 
+        /**
+            @brief Returns the current value of a given value in a given section of the config file.
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(settingsvalue)(const std::string& fragment, const std::string& entry, const std::string& section)
         {
@@ -255,4 +322,7 @@
         }
 
+        /**
+            @brief Returns a list of indexes of the available Tcl threads (see TclThreadManager).
+        */
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(tclthreads)()
         {
Index: code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.h
===================================================================
--- code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/ArgumentCompletionFunctions.h	(revision 7401)
@@ -27,4 +27,124 @@
  */
 
+/**
+    @file
+    @ingroup Command ArgumentCompletion
+    @brief Declaration of all argument completion functions and macros used to define them.
+
+    @anchor ArgumentCompletionExample
+
+    Argument completion functions are used to create a list of possible arguments
+    for an orxonox::ConsoleCommand. These functions are usually wrapped by an instance
+    of orxonox::ArgumentCompleter.
+
+    Argument completion functions can be declared and implemented by using the macros
+    ARGUMENT_COMPLETION_FUNCTION_DECLARATION() and ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION()
+    respectively. They are necessary because they don't simply define the function, but they also
+    create a static helper function that returns an instance of orxonox::ArgumentCompleter which
+    wraps the defined function. This allows easier referencing of argument completion functions
+    by simply calling autocompletion::functionname().
+
+    Argument completion functions can take up to 5 arguments, all of type std::string.
+    The first argument is always the current argument which is being entered by the user
+    in the shell. The second argument is the argument before, so in fact arguments from
+    the shell are sent in reversed order to the argument completion function. This is
+    necessary because the number of arguments can be variable
+
+    Example: The user types the following into the shell:
+    @code
+    $ commandname argument1 argument2 argum
+    @endcode
+    Then he presses the @a tab key to print the possible arguments. Now the argument
+    completion function for the @a third argument of @a commandname will be called in
+    the following way:
+    @code
+    list = argcompfunction3("argum", "argument2", "argument1");
+    @endcode
+
+    Usually each argument is one word (without whitespaces in it), but some argument completion
+    functions need more than one word. This can be achieved by using ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_MULTI().
+    In this case all supernumerous words are passed to the first (!) argument.
+
+    An example to show how to declare, implement, and use an argument completion function:
+    @code
+    // ArgumentCompletionFunctions.h:
+    // ------------------------------
+
+    // Declaration of the function:
+    ARGUMENT_COMPLETION_FUNCTION_DECLARATION(month)(const std::string& fragment);
+
+    // ArgumentCompletionFunctions.cc:
+    // -------------------------------
+
+    // Implementation of the function
+    ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(month)(const std::string& fragment)
+    {
+        ArgumentCompletionList list;
+
+        // check if the first part of the argument is a number - if yes, the user likely wants to enter the month as a number
+        if (isNumber(fragment))
+        {
+            for (int month = 1; month <= 12; ++month)
+                list.push_back(ArgumentCompletionListElement(multi_cast<std::string>(month)));
+        }
+        else
+        {
+            list.push_back(ArgumentCompletionListElement("January",   "january"));
+            list.push_back(ArgumentCompletionListElement("February",  "february"));
+            list.push_back(ArgumentCompletionListElement("March",     "march"));
+            list.push_back(ArgumentCompletionListElement("April",     "april"));
+            list.push_back(ArgumentCompletionListElement("May",       "may"));
+            list.push_back(ArgumentCompletionListElement("June",      "june"));
+            list.push_back(ArgumentCompletionListElement("July",      "july"));
+            list.push_back(ArgumentCompletionListElement("August",    "august"));
+            list.push_back(ArgumentCompletionListElement("September", "september"));
+            list.push_back(ArgumentCompletionListElement("October",   "october"));
+            list.push_back(ArgumentCompletionListElement("November",  "november"));
+            list.push_back(ArgumentCompletionListElement("December",  "december"));
+        }
+
+        return list;
+    }
+
+    // SomeFile:
+    // ---------
+
+    // A class to manage the date:
+    class Date
+    {
+        public:
+            static void setDate(int day, const std::string& month, int year);
+    };
+
+    // Define a console command that needs a date. Add argument completion for the month:
+    SetConsoleCommand("setDate", &Date::setDate).argumentCompleter(1, autocompletion::month());
+    @endcode
+
+    This example defines an argument completion function that returns a list of possible
+    months. If the first part of the argument is a number, it returns the numbers 1-12,
+    otherwise the name of the months are returned. Note how the list is composed by
+    instances of orxonox::ArgumentCompletionListElement. For the name of the months,
+    two strings are provided, one in normal case and one in lower case. See the documentation
+    of orxonox::ArgumentCompletionListElement for more information about this.
+
+    Also note that the argument completion list is assigned to the console command by using
+    @ref orxonox::ConsoleCommand::argumentCompleter "argumentCompleter()". The first argument
+    is the index of the argument:
+     - 0 is the first argument (@a day)
+     - 1 is the second argument (@a month)
+     - 2 is the third argument (@a year)
+
+    @a day and @a year don't need an argument completion function as they are just integers.
+
+    The function @c autocompletion::month() is automatically created by the macros
+    ARGUMENT_COMPLETION_FUNCTION_DECLARATION() and ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION()
+    and returns an orxonox::ArgumentCompleter that wraps the defined argument completion function.
+
+    The implemented argument completion function uses only one argument, the fragment of the
+    currently entered argument. More complex functions can also use the previous arguments
+    to return different arguments depending on the other arguments (for example to list the
+    members of a class, where the class-name is the first argument and the member the second).
+*/
+
 #ifndef _ArgumentCompletionFunctions_H__
 #define _ArgumentCompletionFunctions_H__
@@ -33,14 +153,30 @@
 #include "ArgumentCompleter.h"
 
-
+/**
+    @brief Used to declare an argument completion function with name @a functionname.
+    @param functionname The name of the function, will also be used for the implementation of the function.
+
+    The macro also defines a static function that returns an orxonox::ArgumentCompleter
+    which wraps the defined function. This can be accessed by calling autocompletion::functionname();
+*/
 #define ARGUMENT_COMPLETION_FUNCTION_DECLARATION(functionname) \
     _CoreExport ArgumentCompleter* functionname(); \
     _CoreExport ArgumentCompletionList acf_##functionname
 
+/**
+    @brief Used to implement an argument completion function.
+    @param functionname The name of the function
+*/
 #define ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(functionname) \
     _ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_INTERNAL(functionname, false)
+
+/**
+    @brief Used to implement an argument completion function which allows multiple words.
+    @param functionname The name of the function
+*/
 #define ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_MULTI(functionname) \
     _ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_INTERNAL(functionname, true)
 
+/// Internal macro
 #define _ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION_INTERNAL(functionname, bUseMultipleWords) \
     ArgumentCompleter* functionname() \
@@ -52,4 +188,5 @@
     ArgumentCompletionList acf_##functionname
 
+/// Calls an argument completion function. Used for functions that return the results of another argument completion function.
 #define ARGUMENT_COMPLETION_FUNCTION_CALL(functionname) acf_##functionname
 
Index: code/trunk/src/libraries/core/command/ArgumentCompletionListElement.h
===================================================================
--- code/trunk/src/libraries/core/command/ArgumentCompletionListElement.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/ArgumentCompletionListElement.h	(revision 7401)
@@ -27,4 +27,10 @@
  */
 
+/**
+    @file
+    @ingroup Command ArgumentCompletion
+    @brief Definition of ArgumentCompletionList, which is  used in @ref ArgumentCompletionFunctions.h "argument completion functions", and its element.
+*/
+
 #ifndef _ArgumentCompletionListElement_H__
 #define _ArgumentCompletionListElement_H__
@@ -37,37 +43,61 @@
 namespace orxonox
 {
-    const int ACL_MODE_NORMAL    = 1;
-    const int ACL_MODE_COMPARABLE = 2;
-    const int ACL_MODE_DISPLAY   = 4;
+    const int ACL_MODE_NORMAL     = 1;  ///< A flag, used if there's a normal string
+    const int ACL_MODE_COMPARABLE = 2;  ///< A flag, used if there's a different string used to compare
+    const int ACL_MODE_DISPLAY    = 4;  ///< A flag, used if there's a different string used to be displayed
 
     typedef std::list<ArgumentCompletionListElement> ArgumentCompletionList;
 
+    /**
+        @brief This class is used in argument completion lists and contains up to three different strings, used in different situations.
+
+        A list containing elements of type ArgumentCompletionListElement is returned by
+        an @ref ArgumentCompletionFunctions.h "argument completion function". These elements
+        are composed of up to three strings with different usage:
+         - normal: What is used as the actual argument
+         - comparable: What is used to compere the argument to the input of the user (usually lowercase, except for case-sensitive arguments)
+         - display: This is displayed in the list of possible arguments - can differ from what is actually used for better readability
+
+        @remarks An element with an empty ("") 'comparable' string will be ignored by the argument
+        completion algorithms, but it's 'display' string will still be printed in the list. This
+        can be used to add additional information, whitespaces, linebreaks or whatever is needed
+        to format the output.
+    */
     class _CoreExport ArgumentCompletionListElement
     {
         public:
+            /// Constructor: Normal, comparable, and display string are all the same.
             ArgumentCompletionListElement(const std::string& normalcase) : mode_(ACL_MODE_NORMAL), normal_(normalcase) {}
+            /// Constructor: Normal and display string are the same, a different (usually lowercase) string is used for comparison.
             ArgumentCompletionListElement(const std::string& normalcase, const std::string& lowercase) : mode_(ACL_MODE_NORMAL | ACL_MODE_COMPARABLE), normal_(normalcase), comparable_(lowercase) {}
+            /// Constructor: Normal, comparable, and display are all different strings.
             ArgumentCompletionListElement(const std::string& normalcase, const std::string& lowercase, const std::string& display) : mode_(ACL_MODE_NORMAL | ACL_MODE_COMPARABLE | ACL_MODE_DISPLAY), normal_(normalcase), comparable_(lowercase), display_(display) {}
 
+            /// Returns the normal string which is used as the actual argument.
             const std::string& getString() const
                 { return this->normal_; }
+            /// Returns the comparable string which is used to compare arguments and user input
             const std::string& getComparable() const
                 { return (this->mode_ & ACL_MODE_COMPARABLE) ? this->comparable_ : this->normal_; }
+            /// Returns the display string which is used in the displayed list of possible arguments
             const std::string& getDisplay() const
                 { return (this->mode_ & ACL_MODE_DISPLAY) ? this->display_ : this->normal_; }
 
+            /// Returns true if there's a different string for comparison.
             bool hasComparable() const
                 { return (this->mode_ & ACL_MODE_COMPARABLE); }
+            /// Returns true if there's a different string to display.
             bool hasDisplay() const
                 { return (this->mode_ & ACL_MODE_DISPLAY); }
 
+            /// Overloaded operator for usage in maps and sets.
             bool operator<(const ArgumentCompletionListElement& other) const
                 { return (this->getComparable() < other.getComparable()); }
 
         private:
-            unsigned char mode_;
-            std::string normal_;
-            std::string comparable_;
-            std::string display_;
+            unsigned char mode_;        ///< The flags
+            std::string normal_;        ///< The normal string
+            std::string comparable_;    ///< The comparable (usually lowercase) string
+            std::string display_;       ///< The string to display
     };
 }
Index: code/trunk/src/libraries/core/command/CommandEvaluation.cc
===================================================================
--- code/trunk/src/libraries/core/command/CommandEvaluation.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/CommandEvaluation.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Implementation of CommandEvaluation
+*/
+
 #include "CommandEvaluation.h"
 
@@ -35,4 +40,7 @@
 namespace orxonox
 {
+    /**
+        @brief Constructor: Initializes the command evaluation with an empty command.
+    */
     CommandEvaluation::CommandEvaluation()
     {
@@ -40,4 +48,7 @@
     }
 
+    /**
+        @brief Initializes all values.
+    */
     void CommandEvaluation::initialize(const std::string& command)
     {
@@ -49,28 +60,41 @@
         this->bPossibleArgumentsRetrieved_ = false;
         this->possibleArguments_.clear();
-        this->bEvaluatedParams_ = false;
-        this->bTriedToEvaluatedParams_ = false;
-        this->numberOfEvaluatedParams_ = 0;
-
+        this->bEvaluatedArguments_ = false;
+        this->bTriedToEvaluatedArguments_ = false;
+        this->numberOfEvaluatedArguments_ = 0;
+
+        // split the command into tokens
         this->tokens_.split(command, " ", SubString::WhiteSpaces, false, '\\', true, '"', true, '{', '}', true, '\0');
     }
 
+    /**
+        @brief Returns the number of tokens according to the definition of CommandExecutor (which counts also an empty argument at the end of the string).
+    */
     unsigned int CommandEvaluation::getNumberOfArguments() const
     {
         unsigned int count = this->tokens_.size();
-        if (count > 0 && this->string_[this->string_.size() - 1] != ' ')
+
+        // If the last char in the string is a space character (or the string is empty), add +1 to the number of tokens, because this counts as an additional (but empty) argument
+        if (count == 0 || this->string_[this->string_.size() - 1] == ' ')
+            return count + 1;
+        else
             return count;
+    }
+
+    /**
+        @brief Returns the last argument (which is the one the user currently enters into the shell).
+    */
+    const std::string& CommandEvaluation::getLastArgument() const
+    {
+        // the string is empty or ends with a space character, the user is just about to enter a new argument (but its still empty). return a blank string in this case.
+        if (this->tokens_.size() == 0 || this->string_[this->string_.size() - 1] == ' ')
+            return BLANKSTRING;
         else
-            return count + 1;
-    }
-
-    const std::string& CommandEvaluation::getLastArgument() const
-    {
-        if (this->tokens_.size() > 0 && this->string_[this->string_.size() - 1] != ' ')
             return this->tokens_.back();
-        else
-            return BLANKSTRING;
-    }
-
+    }
+
+    /**
+        @brief Returns the token with the given index (or a blank string if it doesn't exist).
+    */
     const std::string& CommandEvaluation::getToken(unsigned int i) const
     {
@@ -81,4 +105,8 @@
     }
 
+    /**
+        @brief Executes the command which was evaluated by this object.
+        @return Returns the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+    */
     int CommandEvaluation::execute()
     {
@@ -88,8 +116,16 @@
     }
 
+    /**
+        @brief Executes the command which was evaluated by this object and returns its return-value.
+        @param error A pointer to an integer (or NULL) which will be used to write error codes to (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @return Returns the result of the command (or MT_Type::Null if there is no return value)
+    */
     MultiType CommandEvaluation::query(int* error)
     {
+        // check if an error value was passed by reference
         if (error)
         {
+            // Determine the error-code and return if it is not Success
+
             *error = CommandExecutor::Success;
 
@@ -105,21 +141,26 @@
         }
 
+        // check if it's possible to execute the command
         if (this->execCommand_ && this->execCommand_->isActive() && this->execCommand_->hasAccess())
         {
-            if (!this->bTriedToEvaluatedParams_)
-                this->evaluateParams(false);
-
-            if (this->bEvaluatedParams_)
-            {
-                COUT(6) << "CE_execute (evaluation): " << this->execCommand_->getName() << " with " << this->numberOfEvaluatedParams_ << " params: " << this->param_[0] << ' ' << this->param_[1] << ' ' << this->param_[2] << ' ' << this->param_[3] << ' ' << this->param_[4] << std::endl;
-                switch (this->numberOfEvaluatedParams_)
+            // if the arguments weren't evaluated yet, do it now.
+            if (!this->bTriedToEvaluatedArguments_)
+                this->evaluateArguments(false);
+
+            // check if the argument evaluation succeded
+            if (this->bEvaluatedArguments_)
+            {
+                COUT(6) << "CE_execute (evaluation): " << this->execCommand_->getName() << " with " << this->numberOfEvaluatedArguments_ << " arguments: " << this->arguments_[0] << ' ' << this->arguments_[1] << ' ' << this->arguments_[2] << ' ' << this->arguments_[3] << ' ' << this->arguments_[4] << std::endl;
+
+                // pass as many arguments to the executor as were evaluated (thus the executor can still use additional default values)
+                switch (this->numberOfEvaluatedArguments_)
                 {
                     case 0:  return (*this->execCommand_->getExecutor())();
-                    case 1:  return (*this->execCommand_->getExecutor())(this->param_[0]);
-                    case 2:  return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1]);
-                    case 3:  return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1], this->param_[2]);
-                    case 4:  return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1], this->param_[2], this->param_[3]);
+                    case 1:  return (*this->execCommand_->getExecutor())(this->arguments_[0]);
+                    case 2:  return (*this->execCommand_->getExecutor())(this->arguments_[0], this->arguments_[1]);
+                    case 3:  return (*this->execCommand_->getExecutor())(this->arguments_[0], this->arguments_[1], this->arguments_[2]);
+                    case 4:  return (*this->execCommand_->getExecutor())(this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3]);
                     case 5:
-                    default: return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1], this->param_[2], this->param_[3], this->param_[4]);
+                    default: return (*this->execCommand_->getExecutor())(this->arguments_[0], this->arguments_[1], this->arguments_[2], this->arguments_[3], this->arguments_[4]);
                 }
             }
@@ -128,50 +169,82 @@
         }
 
+        // return a null value in case of an error
         return MT_Type::Null;
     }
 
-    int CommandEvaluation::evaluateParams(bool bPrintError)
-    {
-        this->bTriedToEvaluatedParams_ = true;
-
+    /**
+        @brief Evaluates the arguments of the command.
+        @param bPrintError If true, the function prints an error message if it doesn't succeed
+        @return Returns the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+    */
+    int CommandEvaluation::evaluateArguments(bool bPrintError)
+    {
+        this->bTriedToEvaluatedArguments_ = true;
+
+        // check if there's a command to execute
         if (!this->execCommand_)
         {
             if (bPrintError)
-                COUT(1) << "Error: Can't evaluate params, no console command assigned." << std::endl;
+                COUT(1) << "Error: Can't evaluate arguments, no console command assigned." << std::endl;
             return CommandExecutor::Error;
         }
 
         int error;
-        this->numberOfEvaluatedParams_ = this->execCommand_->getExecutor()->evaluateParams(this->tokens_.subSet(this->execArgumentsOffset_), this->param_, &error, " ");
+
+        // try to evaluate the arguments using the executor of the evaluated command.
+        // the arguments are currently stored as strings in token_, but afterwards they will be converted to the right type and stored in arguments_
+        this->numberOfEvaluatedArguments_ = this->execCommand_->getExecutor()->evaluateArguments(this->tokens_.subSet(this->execArgumentsOffset_), this->arguments_, &error, " ");
+
+        // check if an error occurred
         if (!error)
-            this->bEvaluatedParams_ = true;
+            this->bEvaluatedArguments_ = true;
         else if (bPrintError)
-            COUT(1) << "Error: Can't evaluate params, not enough arguments given." << std::endl;
+            COUT(1) << "Error: Can't evaluate arguments, not enough arguments given." << std::endl;
 
         return error;
     }
 
-    void CommandEvaluation::setEvaluatedParameter(unsigned int index, const MultiType& param)
+    /**
+        @brief Replaces an evaluated argument with a new value.
+        @param index The index of the parameter (the first argument has index 0)
+        @param arg The new value of the parameter
+    */
+    void CommandEvaluation::setEvaluatedArgument(unsigned int index, const MultiType& arg)
     {
         if (index < MAX_FUNCTOR_ARGUMENTS)
-            this->param_[index] = param;
-    }
-
-    MultiType CommandEvaluation::getEvaluatedParameter(unsigned int index) const
+            this->arguments_[index] = arg;
+    }
+
+    /**
+        @brief Returns the evaluated argument with given index.
+        @param index The index of the argument (the first argument has index 0)
+    */
+    MultiType CommandEvaluation::getEvaluatedArgument(unsigned int index) const
     {
         if (index < MAX_FUNCTOR_ARGUMENTS)
-            return this->param_[index];
+            return this->arguments_[index];
 
         return MT_Type::Null;
     }
 
+    /**
+        @brief Completes the given command string using the list of possible arguments.
+        @return Returns the completed command string
+
+        This is called by the shell if the user presses the @a tab key. The currently entered
+        argument will be completed as good as possible by using the argument completion list
+        of the evaluated command.
+    */
     std::string CommandEvaluation::complete()
     {
+        // check if it's possible to complete the command
         if (!this->hintCommand_ || !this->hintCommand_->isActive())
             return this->string_;
 
+        // get the list of possible arguments
         if (!this->bPossibleArgumentsRetrieved_)
             this->retrievePossibleArguments();
 
+        // if the list is empty, return the current command string
         if (CommandEvaluation::getSize(this->possibleArguments_) == 0)
         {
@@ -180,33 +253,55 @@
         else
         {
+            // get the first part of the command string from the beginning up to the last space character
             std::string output = this->string_.substr(0, this->string_.find_last_of(' ') + 1);
+
+            // add the common begin of all possible arguments
             output += CommandEvaluation::getCommonBegin(this->possibleArguments_);
+
+            // return the resulting string
             return output;
         }
     }
 
+    /**
+        @brief Returns a string containing hints or possible arguments for the evaluated command.
+
+        This is called by the shell if the user presses the @a tab key. It prints a list of
+        possible arguments or other hints, returned by the argument completion list of the
+        evaluated command. If there's no such list, the syntax of the command is returned.
+    */
     std::string CommandEvaluation::hint()
     {
+        // check if it's possible to get hints for this command
         if (!this->hintCommand_ || !this->hintCommand_->isActive())
             return "";
 
+        // get the list of possible arguments
         if (!this->bPossibleArgumentsRetrieved_)
             this->retrievePossibleArguments();
 
+        // return the list of possible arguments if:
+        //   a) it contains at least one non-empty argument
+        //   b) it contains an entry that may be empty (not an actual argument, just a helping text) AND the command is valid
         if (CommandEvaluation::getSize(this->possibleArguments_) > 0 || (!this->possibleArguments_.empty() && this->isValid()))
             return CommandEvaluation::dump(this->possibleArguments_);
 
+        // at this point there's no valid argument in the list, so check if the command is actually valid
         if (this->isValid())
         {
+            // yes it is - return the syntax of the command
             return CommandEvaluation::dump(this->hintCommand_);
         }
         else
         {
+            // no the command is not valid
             if (this->getNumberOfArguments() > 2)
             {
+                // the user typed 2+ arguments, but they don't name a command - print an error
                 return std::string("Error: There is no command with name \"") + this->getToken(0) + " " + this->getToken(1) + "\".";
             }
             else
             {
+                // the user typed 1-2 arguments, check what he tried to type and print a suitable error
                 std::string groupLC = getLowercase(this->getToken(0));
                 for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().begin(); it_group != ConsoleCommand::getCommandsLC().end(); ++it_group)
@@ -219,4 +314,8 @@
     }
 
+    /**
+        @brief If the command couln't be evaluated because it doesn't exist, print a suggestion for
+        a command that looks close to the entered command (useful if the user mistyped the command).
+    */
     std::string CommandEvaluation::getCommandSuggestion() const
     {
@@ -227,4 +326,5 @@
         unsigned int nearestDistance = (unsigned int)-1;
 
+        // iterate through all groups and their commands and calculate the distance to the current command. keep the best.
         for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().begin(); it_group != ConsoleCommand::getCommandsLC().end(); ++it_group)
         {
@@ -244,4 +344,5 @@
         }
 
+        // now also iterate through all shortcuts and keep the best if it's better than the one found above.
         std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandsLC().find("");
         if (it_group !=  ConsoleCommand::getCommandsLC().end())
@@ -259,42 +360,69 @@
         }
 
+        // return the command that's closest to the current one.
         return nearestCommand;
     }
 
+    /**
+        @brief Gets the possible arguments for the command in its current state.
+    */
     void CommandEvaluation::retrievePossibleArguments()
     {
         this->bPossibleArgumentsRetrieved_ = true;
+
+        // we use the hintCommand_ to get possible arguments. get the index of the last argument. limit the index if its greater than the number of arguments supported by the command.
         unsigned int argumentID = std::min(this->getNumberOfArguments() - this->hintArgumentsOffset_, this->hintCommand_->getExecutor()->getParamCount());
+
+        // get the argument completer for the given argument index
         ArgumentCompleter* ac = this->hintCommand_->getArgumentCompleter(argumentID - 1);
 
+        // check if an argument completer exists
         if (ac)
         {
-            MultiType param[MAX_FUNCTOR_ARGUMENTS];
-
+            MultiType arg[MAX_FUNCTOR_ARGUMENTS];
+
+            // the index of the last argument in the command string that is supported by this argument completer
             size_t max = this->hintArgumentsOffset_ + this->hintCommand_->getExecutor()->getParamCount();
 
+            // write the argument strings to the argument array (in reversed order, as required by the argument completion function)
             for (size_t i = 0; i < argumentID; ++i)
-                param[i] = this->getToken(std::min(this->getNumberOfArguments(), (unsigned int)max) - i - 1);
-
+                arg[i] = this->getToken(std::min(this->getNumberOfArguments(), (unsigned int)max) - i - 1);
+
+            // check if there are more arguments given by the user than supported
             if (this->getNumberOfArguments() > max)
             {
+                // yes - now check if multiple words are supported by the argument completer
                 if (ac->useMultipleWords())
                 {
+                    // yes - join the surplus arguments
                     std::string surplusArguments = this->tokens_.subSet(max - 1).join();
                     if (this->string_[this->string_.size() - 1] == ' ')
                         surplusArguments += ' ';
 
-                    this->possibleArguments_ = (*ac)(surplusArguments, param[1], param[2], param[3], param[4]);
+                    // pass all surplus arguments as the first argument to the argument completer
+                    this->possibleArguments_ = (*ac)(surplusArguments, arg[1], arg[2], arg[3], arg[4]);
+
+                    // strip the list using the last argument
                     CommandEvaluation::strip(this->possibleArguments_, this->getToken(this->getNumberOfArguments() - 1));
                 }
+                else
+                {
+                    // no - the user typed more arguments than supported, no action
+                }
             }
             else
             {
-                this->possibleArguments_ = (*ac)(param[0], param[1], param[2], param[3], param[4]);
-                CommandEvaluation::strip(this->possibleArguments_, param[0]);
-            }
-        }
-    }
-
+                // no - so simply call the argument completer and get the list of arguments
+                this->possibleArguments_ = (*ac)(arg[0], arg[1], arg[2], arg[3], arg[4]);
+
+                // strip the list using the last argument (stored arg[0])
+                CommandEvaluation::strip(this->possibleArguments_, arg[0]);
+            }
+        }
+    }
+
+    /**
+        @brief Returns the size of an argument completion list - empty ("") arguments are not counted.
+    */
     /* static */ size_t CommandEvaluation::getSize(const ArgumentCompletionList& list)
     {
@@ -306,12 +434,19 @@
     }
 
+    /**
+        @brief Removes all elements from the list that don't start with @a fragment.
+        @param list The argument completion list
+        @param fragment The argument that is currently entered by the user and that needs to be completed
+    */
     /* static */ void CommandEvaluation::strip(ArgumentCompletionList& list, const std::string& fragment)
     {
         std::string fragmentLC = getLowercase(fragment);
 
+        // iterate through the list
         for (ArgumentCompletionList::iterator it = list.begin(); it != list.end(); )
         {
             const std::string& entry = it->getComparable();
 
+            // check if the argument is empty - if yes, keep it always in the list
             if (entry == "")
             {
@@ -320,4 +455,5 @@
             }
 
+            // check the length of the argument - arguments smaller than 'fragment' are always erased
             if (entry.size() < fragmentLC.size())
             {
@@ -326,4 +462,5 @@
             else
             {
+                // compare the argument char by char with 'fragment'
                 bool bErase = false;
                 for (size_t i = 0; i < fragmentLC.size(); ++i)
@@ -344,16 +481,22 @@
     }
 
+    /**
+        @brief Returns the commond begin of all arguments in the list.
+    */
     /* static */ std::string CommandEvaluation::getCommonBegin(const ArgumentCompletionList& list)
     {
         if (CommandEvaluation::getSize(list) == 0)
         {
+            // no (non-empty) values in the list, return an empty string
             return "";
         }
         else if (CommandEvaluation::getSize(list) == 1)
         {
+            // only one (non-empty) value in the list - search it and return it
             for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
             {
                 if (it->getComparable() != "")
                 {
+                    // arguments that have a separate string to be displayed need a little more care - just return them without modification. add a space character to the others.
                     if (it->hasDisplay())
                         return (it->getString());
@@ -367,9 +510,10 @@
         else
         {
+            // multiple arguments in the list - iterate through it and find the common begin of all arguments
             std::string output;
             for (unsigned int i = 0; true; i++)
             {
-                char tempComparable = 0;
-                char temp = 0;
+                char tempComparable = '\0';
+                char temp = '\0';
                 for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
                 {
@@ -377,4 +521,5 @@
                     const std::string& argument = it->getString();
 
+                    // ignore empty arguments
                     if (argumentComparable == "")
                         continue;
@@ -382,6 +527,7 @@
                     if (argument.size() > i)
                     {
-                        if (tempComparable == 0)
+                        if (tempComparable == '\0')
                         {
+                            // the first entry is always taken
                             tempComparable = argumentComparable[i];
                             temp = argument[i];
@@ -389,7 +535,8 @@
                         else
                         {
+                            // all other entries need comparison to the first entry
                             if (tempComparable != argumentComparable[i])
                                 return output;
-                            else if (temp != argument[i])
+                            else if (temp != argument[i]) // the comparables match, but the normal chars don't - switch to comparable only
                                 temp = tempComparable;
                         }
@@ -406,4 +553,7 @@
     }
 
+    /**
+        @brief Joins the elements of the given list to a string.
+    */
     /* static */ std::string CommandEvaluation::dump(const ArgumentCompletionList& list)
     {
@@ -413,4 +563,5 @@
             output += it->getDisplay();
 
+            // add a space character between two elements for all non-empty arguments
             if (it->getComparable() != "")
                 output += ' ';
@@ -419,15 +570,24 @@
     }
 
+    /**
+        @brief Returns a string that explains the syntax of the given command.
+    */
     /* static */ std::string CommandEvaluation::dump(const ConsoleCommand* command)
     {
+        // get the name of the command
         std::string output = command->getName();
+
+        // check if there are parameters
         if (command->getExecutor()->getParamCount() > 0)
             output += ": ";
 
+        // iterate through the parameters
         for (unsigned int i = 0; i < command->getExecutor()->getParamCount(); i++)
         {
+            // separate the parameters with a space character
             if (i != 0)
                 output += ' ';
 
+            // print default values in [], others in {} braces
             if (command->getExecutor()->defaultValueSet(i))
                 output += '[';
@@ -435,6 +595,8 @@
                 output += '{';
 
+            // add the type-name of the parameter
             output += command->getExecutor()->getTypenameParam(i);
 
+            // print the default value if available
             if (command->getExecutor()->defaultValueSet(i))
                 output += '=' + command->getExecutor()->getDefaultValue(i).getString() + ']';
Index: code/trunk/src/libraries/core/command/CommandEvaluation.h
===================================================================
--- code/trunk/src/libraries/core/command/CommandEvaluation.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/CommandEvaluation.h	(revision 7401)
@@ -27,4 +27,21 @@
  */
 
+/**
+    @defgroup CommandExecEval Command execution and evaluation
+    @ingroup Command
+*/
+
+/**
+    @file
+    @ingroup Command CommandExecEval
+    @brief Declaration of the orxonox::CommandEvaluation class which is returned by orxonox::CommandExecutor::evaluate().
+
+    The orxonox::CommandEvaluation class gathers all information about a command-string. It is used
+    internally by orxonox::CommandExecutor and can also be returned by it to provide more information
+    about a command. It's also possible to evaluate the arguments of a command to execute it faster.
+
+    @see See @ref CommandExecutorExample "this description" for an example.
+*/
+
 #ifndef _CommandEvaluation_H__
 #define _CommandEvaluation_H__
@@ -41,4 +58,24 @@
 namespace orxonox
 {
+    /**
+        @brief CommandEvaluation is used to gather information about a command and to evaluate its arguments
+
+        This class provides several information about a command-string, for example the
+        evaluated ConsoleCommand, but also other information like hints if the command
+        is not yet finished.
+
+        @note You don't have to call evaluateArguments() manually, it's also done automatically
+        if you call the command the first time. However you can of course do it at any earlier
+        time, for example to return an error message if it doesn't work.
+
+        @remarks execCommand_ and hintCommand_ can be different in this case: There are multiple
+        commands avaliable, let's say "tcl", "tclexecute", and "tclquery". The user enters
+        "tcl", which is already a valid command. Now execCommand_ points to the "tcl"-command,
+        but hintCommand_ still points to the autocompletion command of CommandExecutor, because
+        the auto-completion list must still return the three possible commands, "tcl tclexecute tclquery"
+        because the user may want to execute "tclquery" and needs auto-completion.
+
+        @see See @ref CommandExecutorExample "this description" for an example.
+    */
     class _CoreExport CommandEvaluation
     {
@@ -56,18 +93,28 @@
             std::string getCommandSuggestion() const;
 
-            int evaluateParams(bool bPrintError = false);
+            int evaluateArguments(bool bPrintError = false);
 
+            /// Returns true if the command evaluation contains a valid command that can be executed.
             inline bool isValid() const
                 { return (this->execCommand_ != 0); }
 
+            /// Returns the console command that was evaluated by this object.
             inline const ConsoleCommand* getConsoleCommand() const
                 { return this->execCommand_; }
 
-            void setEvaluatedParameter(unsigned int index, const MultiType& param);
-            MultiType getEvaluatedParameter(unsigned int index) const;
+            void setEvaluatedArgument(unsigned int index, const MultiType& arg);
+            MultiType getEvaluatedArgument(unsigned int index) const;
 
+            /**
+                @brief Returns a list of possible arguments for the given command.
+
+                Note that the command's arguments may not be complete yet, so in this case
+                this list returns the possibilities. They can then be used to display a list
+                of the possible arguments or to apply auto-completion.
+            */
             const ArgumentCompletionList& getPossibleArguments() const
                 { return this->possibleArguments_; }
 
+            /// Returns the number of possible arguments. Empty ("") arguments are not counted.
             size_t getPossibleArgumentsSize() const
                 { return CommandEvaluation::getSize(this->possibleArguments_); }
@@ -90,17 +137,17 @@
             static std::string getCommonBegin(const ArgumentCompletionList& list);
 
-            const ConsoleCommand* execCommand_;
-            const ConsoleCommand* hintCommand_;
-            SubString tokens_;
-            std::string string_;
-            unsigned int execArgumentsOffset_;
-            unsigned int hintArgumentsOffset_;
-            bool bPossibleArgumentsRetrieved_;
-            ArgumentCompletionList possibleArguments_;
+            const ConsoleCommand* execCommand_;             ///< The command that will be executed (can be NULL if the command is not valid)
+            const ConsoleCommand* hintCommand_;             ///< The command that is used to display hints and argument lists (can be different to execCommand_ in some cases)
+            SubString tokens_;                              ///< The single words of the command string, split into tokens
+            std::string string_;                            ///< The original command string, entered by the user in the shell
+            unsigned int execArgumentsOffset_;              ///< The index of the first argument in tokens_ used to execute the command
+            unsigned int hintArgumentsOffset_;              ///< The index of the first argument in tokens_ used to display hints and argument lists
+            bool bPossibleArgumentsRetrieved_;              ///< True if the list of possible arguments was already retrieved
+            ArgumentCompletionList possibleArguments_;      ///< List of possible arguments for the command in the current state
 
-            bool bEvaluatedParams_;
-            bool bTriedToEvaluatedParams_;
-            unsigned int numberOfEvaluatedParams_;
-            MultiType param_[MAX_FUNCTOR_ARGUMENTS];
+            bool bEvaluatedArguments_;                      ///< True if the arguments of the command have been evaluated (and stored in arguments_)
+            bool bTriedToEvaluatedArguments_;               ///< True if an attempt was started to evaluate the arguments (but not necessarily successful)
+            unsigned int numberOfEvaluatedArguments_;       ///< The number of evaluated arguments (ranges from 0 to MAX_FUNCTOR_ARGUMENTS)
+            MultiType arguments_[MAX_FUNCTOR_ARGUMENTS];    ///< The evaluated arguments (the arguments from string_ or tokens_ converted to the right type)
     };
 }
Index: code/trunk/src/libraries/core/command/CommandExecutor.cc
===================================================================
--- code/trunk/src/libraries/core/command/CommandExecutor.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/CommandExecutor.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Implementation of CommandExecutor
+*/
+
 #include "CommandExecutor.h"
 
@@ -49,4 +54,7 @@
         .argumentCompleter(1, autocompletion::command());
 
+    /**
+        @brief Returns a reference to the only instance of CommandExecutor.
+    */
     /* static */ CommandExecutor& CommandExecutor::getInstance()
     {
@@ -55,4 +63,10 @@
     }
 
+    /**
+        @brief Executes a command.
+        @param command A string containing the command
+        @param useTcl If true, the command is passed to tcl (see TclBind)
+        @return Returns the error-code (see @ref CommandExecutorErrorCodes "error codes")
+    */
     /* static */ int CommandExecutor::execute(const std::string& command, bool useTcl)
     {
@@ -62,22 +76,47 @@
     }
 
+    /**
+        @brief Executes a command and returns its return-value.
+        @param command A string containing the command
+        @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
+        @param useTcl If true, the command is passed to tcl (see TclBind)
+        @return Returns the return-value of the command (if any - MT_Type::Null otherwise)
+    */
     /* static */ MultiType CommandExecutor::queryMT(const std::string& command, int* error, bool useTcl)
     {
         if (useTcl)
+        {
+            // pass the command to tcl
             return TclBind::eval(command, error);
+        }
         else
         {
             CommandEvaluation evaluation;
+
+            // try to get the command evaluation from the cache
             if (!CommandExecutor::getInstance().getCached(command, evaluation))
             {
+                // it wasn't in the cache - evaluate the command
                 evaluation = CommandExecutor::evaluate(command);
-                evaluation.evaluateParams();
+
+                // evaluate its arguments
+                evaluation.evaluateArguments();
+
+                // write the evaluation to the cache
                 CommandExecutor::getInstance().cache(command, evaluation);
             }
 
+            // query the command and return its return-value
             return evaluation.query(error);
         }
     }
 
+    /**
+        @brief Executes a command and returns its return-value as string.
+        @param command A string containing the command
+        @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
+        @param useTcl If true, the command is passed to tcl (see TclBind)
+        @return Returns the return-value of the command converted to a string (or "" if there's no return value)
+    */
     /* static */ std::string CommandExecutor::query(const std::string& command, int* error, bool useTcl)
     {
@@ -85,13 +124,29 @@
     }
 
+    /**
+        @brief Evaluates the given command.
+        @param command A string containing the command
+        @return Returns an instance of CommandEvaluation, which contains the evaluated ConsoleCommand, if the command is valid.
+
+        Evaluates the given command string and returns an instance of CommandEvaluation.
+        If the command is valid, this contains the evaluated ConsoleCommand. Otherwise it
+        can still be used to print hints or complete the command.
+
+        @note Tcl commands can not be evaluated. You have to pass them to execute() or to
+        TclBind directly.
+    */
     /* static */ CommandEvaluation CommandExecutor::evaluate(const std::string& command)
     {
+        // initialize the command evaluation
         CommandEvaluation evaluation;
         evaluation.initialize(command);
 
+        // assign the fallback-command to get hints about the possible commands and groups
         evaluation.hintCommand_ = ConsoleCommand::getCommand(__CC_CommandExecutor_name, __CC_autocomplete_name);
 
+        // check if there's at least one argument
         if (evaluation.getNumberOfArguments() >= 1)
         {
+            // try to get a command from the first token
             evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0));
             if (evaluation.execCommand_)
@@ -99,4 +154,5 @@
             else if (evaluation.getNumberOfArguments() >= 2)
             {
+                // try to get a command from the first two tokens
                 evaluation.execCommand_ = ConsoleCommand::getCommandLC(evaluation.getToken(0), evaluation.getToken(1));
                 if (evaluation.execCommand_)
@@ -105,4 +161,5 @@
         }
 
+        // if a valid command was found and the user is already entering arguments, overwrite hintCommand_ with execCommand_
         if (evaluation.execCommand_ && evaluation.getNumberOfArguments() > evaluation.execArgumentsOffset_)
         {
@@ -114,4 +171,10 @@
     }
 
+    /**
+        @brief Gets an evaluated command from the cache.
+        @param command The command that should be looked up in the cache
+        @param evaluation Reference to a CommandEvaluation that will be used to return the cached evaluation.
+        @return Returns true if the command was found in the cache
+    */
     bool CommandExecutor::getCached(const std::string& command, CommandEvaluation& evaluation)
     {
@@ -119,4 +182,5 @@
             return false;
 
+        // check if the command is in the cache
         std::map<std::string, CacheEntry>::iterator it = this->cache_.find(command);
         if (it != this->cache_.end())
@@ -134,4 +198,7 @@
     }
 
+    /**
+        @brief Writes a command evaluation for a given command to the cache.
+    */
     void CommandExecutor::cache(const std::string& command, const CommandEvaluation& evaluation)
     {
@@ -156,4 +223,10 @@
     }
 
+    /**
+        @brief This function is used as console command which executes commands that are usually hidden.
+
+        The argument completion function of this console commands is used to find
+        and enter hidden commands and their arguments.
+    */
     /* static */ MultiType CommandExecutor::unhide(const std::string& command)
     {
@@ -161,19 +234,29 @@
     }
 
+    /**
+        @brief This function is used as console command which saves a command and optionally also it's arguments as a new console command with a new name.
+        @param alias The name of the new command alias
+        @param command The existing command and (optionally) its arguments
+    */
     /* static */ void CommandExecutor::alias(const std::string& alias, const std::string& command)
     {
+        // first check if the given command is valid, else print an error
         CommandEvaluation evaluation = CommandExecutor::evaluate(command);
         if (evaluation.isValid())
         {
+            // it is valid - copy the executor of this command
             ExecutorPtr executor = new Executor(*evaluation.getConsoleCommand()->getExecutor().get());
 
-            if (!evaluation.evaluateParams())
+            // evaluate the arguments and if this returns no error, store them as default values
+            if (!evaluation.evaluateArguments())
             {
                 for (size_t i = 0; i < MAX_FUNCTOR_ARGUMENTS; ++i)
-                    executor->setDefaultValue(i, evaluation.getEvaluatedParameter(i));
-            }
-
+                    executor->setDefaultValue(i, evaluation.getEvaluatedArgument(i));
+            }
+
+            // split the alias in tokens
             SubString tokens(alias, " ");
 
+            // check if the alias already exists - print an error and return if it does
             if ((tokens.size() == 1 && ConsoleCommand::getCommand(tokens[0])) || (tokens.size() == 2 && ConsoleCommand::getCommand(tokens[0], tokens[1])))
             {
@@ -182,4 +265,5 @@
             }
 
+            // create a new console command with the given alias as its name
             if (tokens.size() == 1)
                 createConsoleCommand(tokens[0], executor);
Index: code/trunk/src/libraries/core/command/CommandExecutor.h
===================================================================
--- code/trunk/src/libraries/core/command/CommandExecutor.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/CommandExecutor.h	(revision 7401)
@@ -27,4 +27,60 @@
  */
 
+/**
+    @file
+    @ingroup Command CommandExecEval
+    @brief Declaration of the orxonox::CommandExecutor class which is used to execute and evaluate @ref orxonox::ConsoleCommand "console commands".
+
+    @anchor CommandExecutorExample
+
+    orxonox::CommandExecutor can be used to execute console commands (see orxonox::ConsoleCommand).
+    Commands are strings that can be entered by the user in the shell or they can be part of a
+    script.
+
+    A command can be passed to orxonox::CommandExecutor::execute() which will execute them - eiter
+    directly, or - if requested - passes it to Tcl. See orxonox::TclBind for more information.
+    Appart from execute() the command can also be passed to orxonox::CommandExecutor::query() which
+    behaves the same except for that it returns the return value of the command.
+
+    If you don't want to execute the command, but rather gather more information about it, pass it
+    to orxonox::CommandExecutor::evaluate(). This function returns an instance of
+    orxonox::CommandEvaluation. This class provides more information about the command, for example
+    the evaluated instance of orxonox::ConsoleCommand. Its also possible to gather hints about the
+    command or to complete the command-string by using argument completion functions. More than that
+    the command evaluation can also evaluate the arguments, which allows faster execution of the
+    command.
+
+    Example:
+    @code
+    CommandExecutor::execute("log test");               // writes "test" to the console
+    CommandExecutor::execute("log [expr 1+1]");         // writes "2" to the console - expr is a Tcl command
+
+    CommandExecutor::query("expr 1+1");                 // returns "2"
+    CommandExecutor::queryMT("expr 1+1");               // returns 2
+    @endcode
+
+    And another example about how to use evaluate():
+    @code
+    CommandEvaluation evaluation;
+    evaluation = CommandExecutor::evaluate("log test"); // returns an evaluation of "log test"
+
+    evaluation.execute();                               // writes "test" to the console
+    evaluation.hint();                                  // returns "log: {string}"
+    @endcode
+
+    @anchor CommandExecutorErrorCodes
+
+    @b Error @b codes:
+
+    orxonox::CommandExecutor defines a number of error codes that are returned
+    by different functions that operate with commands:
+
+     - CommandExecutor::Success: No error
+     - CommandExecutor::Error: The command doesn't exist
+     - CommandExecutor::Incomplete: The command needs more arguments
+     - CommandExecutor::Deactivated: The command is not active
+     - CommandExecutor::Denied: The command needs a different @ref orxonox::AccessLevel "access level"
+*/
+
 #ifndef _CommandExecutor_H__
 #define _CommandExecutor_H__
@@ -42,4 +98,13 @@
 namespace orxonox
 {
+    /**
+        @brief This class is used to execute and evaluate command-strings.
+
+        CommandExecutor executes command-strings and returns evaluated commands. It's
+        also possible to execute Tcl commands if the corresponding argument of execute()
+        is true.
+
+        @see See @ref CommandExecutorExample "this description" for more information and some examples.
+    */
     class _CoreExport CommandExecutor
     {
@@ -53,18 +118,18 @@
             static CommandEvaluation evaluate(const std::string& command);
 
-            static const int Success = 0;
-            static const int Error = 1;
-            static const int Incomplete = 2;
-            static const int Deactivated = 3;
-            static const int Denied = 4;
+            static const int Success = 0;       ///< Error code for "success" (or no error)
+            static const int Error = 1;         ///< Error code if the command doesn't exist
+            static const int Incomplete = 2;    ///< Error code if the command needs more arguments
+            static const int Deactivated = 3;   ///< Error code if the command is not active
+            static const int Denied = 4;        ///< Error code if the command needs a different access level
 
             static MultiType unhide(const std::string& command);
             static void alias(const std::string& alias, const std::string& command);
-            static void _autocomplete(const std::string& group, const std::string& name) {}
+            static void _autocomplete(const std::string& group, const std::string& name) {} ///< Pseudo console command used whenever no real command is available. In these cases this command provides auto-completion for console commands and groups.
 
         private:
-            CommandExecutor() {}
-            CommandExecutor(const CommandExecutor& other);
-            ~CommandExecutor() {}
+            CommandExecutor() {}                            ///< Empty constructor
+            CommandExecutor(const CommandExecutor& other);  ///< Not implemented copy-constructor
+            ~CommandExecutor() {}                           ///< Empty destructor
 
             static CommandExecutor& getInstance();
@@ -73,12 +138,13 @@
             void cache(const std::string& command, const CommandEvaluation& evaluation);
 
+            /// Helper struct, used to store cached entries
             struct CacheEntry
             {
-                CommandEvaluation evaluation_;
-                std::list<std::string>::iterator iterator_;
+                CommandEvaluation evaluation_;                  ///< The command evaluation which is stored in the cache
+                std::list<std::string>::iterator iterator_;     ///< The iterator of the corresponding element in cachelist_, used for faster access
             };
 
-            std::map<std::string, CacheEntry> cache_;
-            std::list<std::string> cachelist_;
+            std::map<std::string, CacheEntry> cache_;   ///< A map that connects command strings and evaluated commands in the cache
+            std::list<std::string> cachelist_;          ///< A list used to sort the elements in the cache by their age
     }; // tolua_export
 } // tolua_export
Index: code/trunk/src/libraries/core/command/ConsoleCommand.cc
===================================================================
--- code/trunk/src/libraries/core/command/ConsoleCommand.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/ConsoleCommand.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Implementation of the ConsoleCommand class.
+*/
+
 #include "ConsoleCommand.h"
 
@@ -36,4 +41,11 @@
 namespace orxonox
 {
+    /**
+        @brief Constructor: Initializes all values and registers the command.
+        @param group The group of the command
+        @param name The name of the command
+        @param executor The executor of the command
+        @param bInitialized If true, the executor is used for both, the definition of the function-header AND to executute the command. If false, the command is inactive and needs to be assigned a function before it can be used.
+    */
     ConsoleCommand::ConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized)
     {
@@ -45,9 +57,6 @@
         this->baseFunctor_ = executor->getFunctor();
 
-        this->argumentCompleter_[0] = 0;
-        this->argumentCompleter_[1] = 0;
-        this->argumentCompleter_[2] = 0;
-        this->argumentCompleter_[3] = 0;
-        this->argumentCompleter_[4] = 0;
+        for (size_t i = 0; i < MAX_FUNCTOR_ARGUMENTS; ++i)
+            this->argumentCompleter_[i] = 0;
 
         this->keybindMode_ = KeybindMode::OnPress;
@@ -60,4 +69,7 @@
     }
 
+    /**
+        @brief Destructor: Unregisters the command.
+    */
     ConsoleCommand::~ConsoleCommand()
     {
@@ -65,4 +77,7 @@
     }
 
+    /**
+        @brief Registers the command with the same name, but without group, as shortcut.
+    */
     ConsoleCommand& ConsoleCommand::addShortcut()
     {
@@ -71,4 +86,7 @@
     }
 
+    /**
+        @brief Registers the command with an alias as shortcut.
+    */
     ConsoleCommand& ConsoleCommand::addShortcut(const std::string&  name)
     {
@@ -77,4 +95,7 @@
     }
 
+    /**
+        @brief Registers the command in a different group but with the same name.
+    */
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group)
     {
@@ -83,4 +104,7 @@
     }
 
+    /**
+        @brief Registers an alias of the command in a different group with a different name.
+    */
     ConsoleCommand& ConsoleCommand::addGroup(const std::string& group, const std::string&  name)
     {
@@ -89,4 +113,13 @@
     }
 
+    /**
+        @brief Returns true if the command can be executed right now.
+
+        This returns only true, if the following conditions are met:
+         - The command is active
+         - The command has an executor
+         - The executor has a functor
+         - The functor is static or has an object
+    */
     bool ConsoleCommand::isActive() const
     {
@@ -94,4 +127,7 @@
     }
 
+    /**
+        @brief Returns true if the current state of the game matches the required access level.
+    */
     bool ConsoleCommand::hasAccess() const
     {
@@ -101,7 +137,7 @@
             case AccessLevel::Standalone: return GameMode::isStandalone();
             case AccessLevel::Master:     return GameMode::isMaster();
-            case AccessLevel::Server:     return GameMode::hasServer();
+            case AccessLevel::Server:     return GameMode::isServer();
             case AccessLevel::Client:     return GameMode::isClient();
-            case AccessLevel::Online:     return (GameMode::hasServer() || GameMode::isClient());
+            case AccessLevel::Online:     return (GameMode::isServer() || GameMode::isClient());
             case AccessLevel::Offline:    return GameMode::isStandalone();
             case AccessLevel::None:       return false;
@@ -110,14 +146,22 @@
     }
 
+    /**
+        @brief Returns true if the headers of the given functor match the declaration of this command.
+    */
     bool ConsoleCommand::headersMatch(const FunctorPtr& functor)
     {
+        // get the minimum of the number of parameters of both commands
         unsigned int minparams = std::min(this->baseFunctor_->getParamCount(), functor->getParamCount());
 
+        // if the reduced headers don't match -> return false
         if (this->baseFunctor_->getHeaderIdentifier(minparams) != functor->getHeaderIdentifier(minparams))
             return false;
+        // if the reduced headers match and the new functor has less or equal parameters -> return true
         else if (functor->getParamCount() <= this->baseFunctor_->getParamCount())
             return true;
+        // the headers match but the new functor has more arguments and there is no executor with default-values -> return false
         else if (!this->executor_)
             return false;
+        // the headers match but the new functor has more arguments, check if the executor has enough default-values
         else
         {
@@ -135,12 +179,19 @@
     }
 
+    /**
+        @brief Returns true if the headers of the given executor match the declaration of this command.
+    */
     bool ConsoleCommand::headersMatch(const ExecutorPtr& executor)
     {
+        // get the minimum of the number of parameters of both commands
         unsigned int minparams = std::min(this->baseFunctor_->getParamCount(), executor->getParamCount());
 
+        // if the reduced headers don't match -> return false
         if (this->baseFunctor_->getHeaderIdentifier(minparams) != executor->getFunctor()->getHeaderIdentifier(minparams))
             return false;
+        // if the reduced headers match and the new functor has less or equal parameters -> return true
         else if (executor->getParamCount() <= this->baseFunctor_->getParamCount())
             return true;
+        // the headers match but the new functor has more arguments, check if the new executor has enough default-values
         else
         {
@@ -158,8 +209,16 @@
     }
 
+    /**
+        @brief Changes the executor.
+        @param executor The new executor
+        @param bForce If true, the executor is always assigned, even if the headers don't match
+        @return Returns true if the assignment was successful
+    */
     bool ConsoleCommand::setFunction(const ExecutorPtr& executor, bool bForce)
     {
+        // assign the executor if a) it's a null-pointer, b) its functor is a null-pointer, c) it's forced, d) the headers match
         if (!executor || !executor->getFunctor() || bForce || this->headersMatch(executor))
         {
+            // assign the executor and clear the object stack (because it's also a new function)
             this->executor_ = executor;
             this->objectStack_.clear();
@@ -173,8 +232,16 @@
     }
 
+    /**
+        @brief Changes the functor of the current executor.
+        @param functor The new functor
+        @param bForce If true, the functor is always assigned, even if the headers don't match
+        @return Returns true if the assignment was successful
+    */
     bool ConsoleCommand::setFunction(const FunctorPtr& functor, bool bForce)
     {
+        // assign the functor if a) it's a null-pointer, b) it's forced, c) the headers match
         if (!functor || bForce || this->headersMatch(functor))
         {
+            // assign the functor (create a new executor if necessary) and clear the object stack
             if (this->executor_)
                 this->executor_->setFunctor(functor);
@@ -192,6 +259,12 @@
     }
 
+    /**
+        @brief Pushes a new executor to the command-stack.
+        @param executor The new executor
+        @param bForce If true, the executor is always assigned, even if the headers don't match
+    */
     void ConsoleCommand::pushFunction(const ExecutorPtr& executor, bool bForce)
     {
+        // prepare the old function to be put on the stack
         Command command;
         command.executor_ = this->executor_;
@@ -200,10 +273,17 @@
         command.objectStack_ = this->objectStack_;
 
+        // check if the new executor can be assigned and push the old function to the stack
         if (this->setFunction(executor, bForce))
             this->commandStack_.push(command);
     }
 
+    /**
+        @brief Pushes a new functor to the command-stack.
+        @param functor The new functor
+        @param bForce If true, the functor is always assigned, even if the headers don't match
+    */
     void ConsoleCommand::pushFunction(const FunctorPtr& functor, bool bForce)
     {
+        // prepare the old function to be put on the stack
         Command command;
         command.executor_ = this->executor_;
@@ -212,8 +292,12 @@
         command.objectStack_ = this->objectStack_;
 
+        // check if the new functor can be assigned and push the old function to the stack
         if (this->setFunction(functor, bForce))
             this->commandStack_.push(command);
     }
 
+    /**
+        @brief Pushes a copy of the current executor and functor on the stack.
+    */
     void ConsoleCommand::pushFunction()
     {
@@ -224,13 +308,20 @@
     }
 
+    /**
+        @brief Removes the current function from the stack and restores the old state.
+    */
     void ConsoleCommand::popFunction()
     {
         Command command;
+
+        // check if there's a function on the stack
         if (!this->commandStack_.empty())
         {
+            // yes it is - assign it to command and remove it from the stack
             command = this->commandStack_.top();
             this->commandStack_.pop();
         }
 
+        // restore the old executor (and also restore its functor in case this was changed in the meantime)
         this->executor_ = command.executor_;
         if (command.executor_)
@@ -239,4 +330,7 @@
     }
 
+    /**
+        @brief Sets the functor to NULL (which also deactivates the command).
+    */
     void ConsoleCommand::resetFunction()
     {
@@ -246,4 +340,7 @@
     }
 
+    /**
+        @brief Returns the current executor which can be used to execute the command.
+    */
     const ExecutorPtr& ConsoleCommand::getExecutor() const
     {
@@ -251,10 +348,17 @@
     }
 
+    /**
+        @brief Changes the current object that is used to execute member-functions.
+        @return Returns true if the object was successfully changed
+    */
     bool ConsoleCommand::setObject(void* object)
     {
-        if (this->executor_)
-        {
+        // check if there's an executor
+        if (this->executor_)
+        {
+            // check if there's a functor
             if (this->executor_->getFunctor())
             {
+                // change the object
                 this->executor_->getFunctor()->setRawObjectPointer(object);
                 return true;
@@ -269,4 +373,7 @@
     }
 
+    /**
+        @brief Push a new object to the object-stack.
+    */
     void ConsoleCommand::pushObject(void* object)
     {
@@ -276,4 +383,7 @@
     }
 
+    /**
+        @brief Removes the current object from the stack an restores the old object.
+    */
     void ConsoleCommand::popObject()
     {
@@ -287,4 +397,7 @@
     }
 
+    /**
+        @brief Returns the current object pointer that is used to execute member-functions.
+    */
     void* ConsoleCommand::getObject() const
     {
@@ -295,8 +408,11 @@
     }
 
-    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1)
-    {
-        if (this->executor_)
-            this->executor_->setDefaultValues(param1);
+    /**
+        @brief Changes the default values of the current executor.
+    */
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& arg1)
+    {
+        if (this->executor_)
+            this->executor_->setDefaultValues(arg1);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
@@ -305,8 +421,11 @@
     }
 
-    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2)
-    {
-        if (this->executor_)
-            this->executor_->setDefaultValues(param1, param2);
+    /**
+        @brief Changes the default values of the current executor.
+    */
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& arg1, const MultiType& arg2)
+    {
+        if (this->executor_)
+            this->executor_->setDefaultValues(arg1, arg2);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
@@ -315,8 +434,11 @@
     }
 
-    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
-    {
-        if (this->executor_)
-            this->executor_->setDefaultValues(param1, param2, param3);
+    /**
+        @brief Changes the default values of the current executor.
+    */
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3)
+    {
+        if (this->executor_)
+            this->executor_->setDefaultValues(arg1, arg2, arg3);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
@@ -325,8 +447,11 @@
     }
 
-    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
-    {
-        if (this->executor_)
-            this->executor_->setDefaultValues(param1, param2, param3, param4);
+    /**
+        @brief Changes the default values of the current executor.
+    */
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4)
+    {
+        if (this->executor_)
+            this->executor_->setDefaultValues(arg1, arg2, arg3, arg4);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
@@ -335,8 +460,11 @@
     }
 
-    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
-    {
-        if (this->executor_)
-            this->executor_->setDefaultValues(param1, param2, param3, param4, param5);
+    /**
+        @brief Changes the default values of the current executor.
+    */
+    ConsoleCommand& ConsoleCommand::defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5)
+    {
+        if (this->executor_)
+            this->executor_->setDefaultValues(arg1, arg2, arg3, arg4, arg5);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
@@ -345,8 +473,13 @@
     }
 
-    ConsoleCommand& ConsoleCommand::defaultValue(unsigned int index, const MultiType& param)
-    {
-        if (this->executor_)
-            this->executor_->setDefaultValue(index, param);
+    /**
+        @brief Changes the default value of the argument with given index of the current executor.
+        @param index The index of the argument (the first argument has index 0)
+        @param arg The new default value
+    */
+    ConsoleCommand& ConsoleCommand::defaultValue(unsigned int index, const MultiType& arg)
+    {
+        if (this->executor_)
+            this->executor_->setDefaultValue(index, arg);
         else
             COUT(1) << "Error: Can't set default values in console command \"" << this->baseName_ << "\", no executor set." << std::endl;
@@ -355,22 +488,33 @@
     }
 
-    ConsoleCommand& ConsoleCommand::argumentCompleter(unsigned int param, ArgumentCompleter* completer)
-    {
-        if (param < 5)
-            this->argumentCompleter_[param] = completer;
-        else
-            COUT(2) << "Warning: Couldn't add autocompletion-function for param " << param << " in console command \"" << this->baseName_ << "\": index out of bound." << std::endl;
-
-        return *this;
-    }
-
-    ArgumentCompleter* ConsoleCommand::getArgumentCompleter(unsigned int param) const
-    {
-        if (param < 5)
-            return this->argumentCompleter_[param];
+    /**
+        @brief Changes the argument completer for the given argument.
+        @param index The index of the argument (the first argument has index 0)
+        @param completer The new argument completer
+    */
+    ConsoleCommand& ConsoleCommand::argumentCompleter(unsigned int index, ArgumentCompleter* completer)
+    {
+        if (index < 5)
+            this->argumentCompleter_[index] = completer;
+        else
+            COUT(2) << "Warning: Couldn't add autocompletion-function for index " << index << " in console command \"" << this->baseName_ << "\": index out of bound." << std::endl;
+
+        return *this;
+    }
+
+    /**
+        @brief Returns the argument completer for the argument with given index.
+    */
+    ArgumentCompleter* ConsoleCommand::getArgumentCompleter(unsigned int index) const
+    {
+        if (index < 5)
+            return this->argumentCompleter_[index];
         else
             return 0;
     }
 
+    /**
+        @brief Sets the description of this command.
+    */
     ConsoleCommand& ConsoleCommand::description(const std::string& description)
     {
@@ -380,4 +524,7 @@
     }
 
+    /**
+        @brief Returns the description of this command.
+    */
     const std::string& ConsoleCommand::getDescription() const
     {
@@ -385,22 +532,31 @@
     }
 
-    ConsoleCommand& ConsoleCommand::descriptionParam(unsigned int param, const std::string& description)
-    {
-        if (param < MAX_FUNCTOR_ARGUMENTS)
-        {
-            this->descriptionParam_[param] = std::string("ConsoleCommandDescription::" + this->baseName_ + "::param" + multi_cast<std::string>(param));
-            AddLanguageEntry(this->descriptionParam_[param], description);
-        }
-        return *this;
-    }
-
-    const std::string& ConsoleCommand::getDescriptionParam(unsigned int param) const
-    {
-        if (param < MAX_FUNCTOR_ARGUMENTS)
-            return GetLocalisation_noerror(this->descriptionParam_[param]);
+    /**
+        @brief Sets the description for an argument with given index.
+    */
+    ConsoleCommand& ConsoleCommand::descriptionParam(unsigned int index, const std::string& description)
+    {
+        if (index < MAX_FUNCTOR_ARGUMENTS)
+        {
+            this->descriptionParam_[index] = std::string("ConsoleCommandDescription::" + this->baseName_ + "::param" + multi_cast<std::string>(index));
+            AddLanguageEntry(this->descriptionParam_[index], description);
+        }
+        return *this;
+    }
+
+    /**
+        @brief Returns the description for the argument with given index.
+    */
+    const std::string& ConsoleCommand::getDescriptionParam(unsigned int index) const
+    {
+        if (index < MAX_FUNCTOR_ARGUMENTS)
+            return GetLocalisation_noerror(this->descriptionParam_[index]);
 
         return this->descriptionParam_[0];
     }
 
+    /**
+        @brief Sets the description for the return-value.
+    */
     ConsoleCommand& ConsoleCommand::descriptionReturnvalue(const std::string& description)
     {
@@ -410,17 +566,29 @@
     }
 
-    const std::string& ConsoleCommand::getDescriptionReturnvalue(int param) const
+    /**
+        @brief Returns the description for the return-value.
+    */
+    const std::string& ConsoleCommand::getDescriptionReturnvalue(int index) const
     {
         return GetLocalisation_noerror(this->descriptionReturnvalue_);
     }
 
+    /**
+        @brief Returns the command with given group an name.
+        @param group The group of the requested command
+        @param name The group of the requested command
+        @param bPrintError If true, an error is printed if the command doesn't exist
+    */
     /* static */ const ConsoleCommand* ConsoleCommand::getCommand(const std::string& group, const std::string& name, bool bPrintError)
     {
+        // find the group
         std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMap().find(group);
         if (it_group != ConsoleCommand::getCommandMap().end())
         {
+            // find the name
             std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(name);
             if (it_name != it_group->second.end())
             {
+                // return the pointer
                 return it_name->second;
             }
@@ -436,4 +604,10 @@
     }
 
+    /**
+        @brief Returns the command with given group an name in lowercase.
+        @param group The group of the requested command in lowercase
+        @param name The group of the requested command in lowercase
+        @param bPrintError If true, an error is printed if the command doesn't exist
+    */
     /* static */ const ConsoleCommand* ConsoleCommand::getCommandLC(const std::string& group, const std::string& name, bool bPrintError)
     {
@@ -441,10 +615,13 @@
         std::string nameLC = getLowercase(name);
 
+        // find the group
         std::map<std::string, std::map<std::string, ConsoleCommand*> >::const_iterator it_group = ConsoleCommand::getCommandMapLC().find(groupLC);
         if (it_group != ConsoleCommand::getCommandMapLC().end())
         {
+            // find the name
             std::map<std::string, ConsoleCommand*>::const_iterator it_name = it_group->second.find(nameLC);
             if (it_name != it_group->second.end())
             {
+                // return the pointer
                 return it_name->second;
             }
@@ -460,4 +637,7 @@
     }
 
+    /**
+        @brief Returns the static map that stores all console commands.
+    */
     /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMap()
     {
@@ -466,4 +646,7 @@
     }
 
+    /**
+        @brief Returns the static map that stores all console commands in lowercase.
+    */
     /* static */ std::map<std::string, std::map<std::string, ConsoleCommand*> >& ConsoleCommand::getCommandMapLC()
     {
@@ -472,4 +655,7 @@
     }
 
+    /**
+        @brief Registers a new command with given group an name by adding it to the command map.
+    */
     /* static */ void ConsoleCommand::registerCommand(const std::string& group, const std::string& name, ConsoleCommand* command)
     {
@@ -477,4 +663,5 @@
             return;
 
+        // check if a command with this name already exists
         if (ConsoleCommand::getCommand(group, name) != 0)
         {
@@ -486,4 +673,5 @@
         else
         {
+            // add the command to the map
             ConsoleCommand::getCommandMap()[group][name] = command;
             ConsoleCommand::getCommandMapLC()[getLowercase(group)][getLowercase(name)] = command;
@@ -491,10 +679,16 @@
     }
 
+    /**
+        @brief Removes the command from the command map.
+    */
     /* static */ void ConsoleCommand::unregisterCommand(ConsoleCommand* command)
     {
+        // iterate through all groups
         for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMap().begin(); it_group != ConsoleCommand::getCommandMap().end(); )
         {
+            // iterate through all commands of each group
             for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
             {
+                // erase the command
                 if (it_name->second == command)
                     it_group->second.erase(it_name++);
@@ -503,4 +697,5 @@
             }
 
+            // erase the group if it is empty now
             if (it_group->second.empty())
                 ConsoleCommand::getCommandMap().erase(it_group++);
@@ -509,8 +704,13 @@
         }
 
+        // now the same for the lowercase-map:
+
+        // iterate through all groups
         for (std::map<std::string, std::map<std::string, ConsoleCommand*> >::iterator it_group = ConsoleCommand::getCommandMapLC().begin(); it_group != ConsoleCommand::getCommandMapLC().end(); )
         {
+            // iterate through all commands of each group
             for (std::map<std::string, ConsoleCommand*>::iterator it_name = it_group->second.begin(); it_name != it_group->second.end(); )
             {
+                // erase the command
                 if (it_name->second == command)
                     it_group->second.erase(it_name++);
@@ -519,4 +719,5 @@
             }
 
+            // erase the group if it is empty now
             if (it_group->second.empty())
                 ConsoleCommand::getCommandMapLC().erase(it_group++);
@@ -526,6 +727,10 @@
     }
 
+    /**
+        @brief Deletes all commands
+    */
     /* static */ void ConsoleCommand::destroyAll()
     {
+        // delete entries until the map is empty
         while (!ConsoleCommand::getCommandMap().empty() && !ConsoleCommand::getCommandMap().begin()->second.empty())
             delete ConsoleCommand::getCommandMap().begin()->second.begin()->second;
Index: code/trunk/src/libraries/core/command/ConsoleCommand.h
===================================================================
--- code/trunk/src/libraries/core/command/ConsoleCommand.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/ConsoleCommand.h	(revision 7401)
@@ -27,4 +27,192 @@
  */
 
+/**
+    @defgroup ConsoleCommand Console commands
+    @ingroup Command
+*/
+
+/**
+    @file
+    @ingroup Command ConsoleCommand
+    @brief Declaration of the orxonox::ConsoleCommand class and the SetConsoleCommand() macro.
+
+    @anchor ConsoleCommandExample
+
+    Console commands can be used to write scripts, use key-bindings or simply to be
+    entered into the shell by the user. Instances of orxonox::ConsoleCommand define
+    the function of a command, and also more information like, for example, if it is
+    active, default values, and possible arguments.
+
+    Commands need to be registered to the system statically on startup by using the
+    SetConsoleCommand() or DeclareConsoleCommand() macros outside of a function.
+    This ensures that commands are known to the system at any time, so they can be
+    evaluated (see orxonox::CommandExecutor::evaluate()), for example for key-bindings.
+
+    Example:
+    @code
+    void myCoutFunction(const std::string& text)        // Define a static function
+    {
+        COUT(0) << "Text: " << text << std::endl;       // Print the text to the console
+    }
+
+    SetConsoleCommand("cout", &myCoutFunction);         // Register the function as command with name "cout"
+    @endcode
+
+    Now you can open the shell and execute the command:
+    @code
+    $ cout Hello World
+    @endcode
+
+    Internally this command is now passed to orxonox::CommandExecutor::execute():
+    @code
+    CommandExecutor::execute("cout HelloWorld");
+    @endcode
+
+    CommandExecutor searches for a command with name "cout" and passes the arguments
+    "Hello World" to it. Because we registered myCoutFunction() with this command,
+    as a result the following text will be printed to the console:
+    @code
+    Text: Hello World
+    @endcode
+
+    You can add more attributes to the ConsoleCommand, by using the command-chain feature
+    of SetConsoleCommand(). For example like this:
+    @code
+    SetConsoleCommand("cout", &myCoutFunction)
+        .addGroup("output", "text")
+        .accessLevel(AccessLevel::Offline)
+        .defaultValues("no text");
+    @endcode
+
+    Open the shell again and try it:
+    @code
+    $ cout Hello World
+    Text: Hello World
+    $ output text Hello World
+    Text: Hello World
+    $ cout
+    Text: no text
+    @endcode
+
+    If you execute it online (note: the access level is "Offline"), you will see the
+    following (or something similar):
+    @code
+    $ cout Hello World
+    Error: Can't execute command "cout", access denied.
+    @endcode
+
+    If a command is executed, the arguments are passed to an underlying function,
+    whitch is wrapped by an orxonox::Functor which again is wrapped by an orxonox::Executor.
+    The Functor contains the function-pointer, as well as the object-pointer in
+    case of a non-static member-function. The executor stores possible default-values
+    for each argument of the function.
+
+    The function of a command can be changed at any time. It's possible to just exchange
+    the function-pointer of the underlying Functor if the headers of the functions are
+    exactly the same. But you can also exchange the Functor itself or even completely
+    replace the Executor. Also the other attributes of a ConsoleCommand can be modified
+    during the game, for example it can be activated or deactivated.
+
+    To do so, the function ModifyConsoleCommand() has to be used. It returns an instance
+    of orxonox::ConsoleCommand::ConsoleCommandManipulator which has an interface similar to
+    orxonox::ConsoleCommand, but with slight differences. You can use it the same way like
+    SetConsoleCommand(), meaning you can use command-chains to change different attributes at
+    the same time. ModifyConsoleCommand() must not be executed statically, but rather in a
+    function at some point of the execution of the program.
+
+    Example:
+    @code
+    void myOtherCoutFunction(const std::string& text)                       // Define a new static function
+    {
+        COUT(0) << "Uppercase: " << getUppercase(text) << std::endl;        // Print the text in uppercase to the console
+    }
+
+    {
+        // ...                                                              // somewhere in the code
+
+        ModifyConsoleCommand("cout").setFunction(&myOtherCoutFunction);     // Modify the underlying function of the command
+
+        // ...
+    }
+    @endcode
+
+    If you now enter the command into the shell, you'll see a different behavior:
+    @code
+    $ cout Hello World
+    Uppercase: HELLO WORLD
+    $ cout
+    Uppercase: NO TEXT
+    @endcode
+
+    A few important notes about changing functions:
+
+    Instead of changing the function with setFunction(), you can also create a command-stack
+    by using pushFunction() and popFunction(). It's important to note a few things about that,
+    because the underlying structure of Executor and Functor has a few pitfalls:
+     - If you push a new function-pointer, the same executor as before will be used (and, if
+       the headers match, even the same functor can be used, which is very fast)
+     - If you push a new Functor, the same executor as before will be used
+     - If you push a new Executor, everything is changed
+
+    Note that the executor contains the @b default @b values, so if you just exchange the
+    Functor, the default values remain the same. However if you decide to change the default
+    values at any point of the stack, <b>this will also change the default values on all
+    other stack-levels</b> that share the same executor. If you don't like this behavior,
+    you have to explicitly push a new executor before changing the default values, either by
+    calling pushFunction(executor) or by calling pushFunction(void) which pushes a copy of
+    the current executor to the stack.
+
+    Another important point are object pointers in case of non-static member-functions.
+    Whenever you set or push a new function, <b>you must add the object pointer again</b>
+    because objects are stored in the Functor which is usually exchanged if you change
+    the function.
+
+    You can also use a stack for objects, but note that this <b>object-stack is different for each
+    function</b> - so if you set a new function, the object-stack will be cleared. If you push
+    a new function, the old object-stack is stored in the stack, so it can be restored if
+    you pop the function.
+
+    %DeclareConsoleCommand():
+
+    Appart from SetConsoleCommand() you can also call DeclareConsoleCommand(). In contrast
+    to SetConsoleCommand(), this doesn't assign a function to the command. Indeed you have
+    to pass a function-pointer to DeclareConsoleCommand(), but it is only used to determine
+    the header of the future command-function. This allows to declare a command statically,
+    thus it's possible to evaluate key-bindings of this command, but the actual function
+    can be assigned at a later point.
+
+    Example:
+    @code
+    DeclareConsoleCommand("cout", &prototype::void__string);
+    @endcode
+
+    If you try to execute the command now, you see the following (or something similar):
+    @code
+    $ cout Hello World
+    Error: Can't execute command "cout", command is not active.
+    @endcode
+
+    You first have to assign a function to use the command:
+    @code
+    {
+        // ...
+
+        ModifyConsoleCommand("cout").setFunction(&myCoutFunction);
+
+        // ...
+    }
+    @endcode
+
+    Now you can use it:
+    @code
+    $ cout Hello World
+    Text: Hello World
+    @endcode
+
+    Note that the initial function prototype::void__string is defined in the namespace
+    orxonox::prototype. If there's no function with the desired header, you can extend
+    the collection of functions or simply use another function that has the same header.
+*/
+
 #ifndef _ConsoleCommand_H__
 #define _ConsoleCommand_H__
@@ -42,26 +230,77 @@
 
 
+/**
+    @brief Defines a console command. The macro is overloaded for 2-4 parameters.
+
+    This is an overloaded macro. Depending on the number of arguments a different
+    overloaded implementation of the macro will be chosen.
+
+    Console commands created with SetConsoleCommand() become active immediately and
+    the given function-pointer (and optionally the object) will be used to execute
+    the command.
+*/
 #define SetConsoleCommand(...) \
     BOOST_PP_EXPAND(BOOST_PP_CAT(SetConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
+/**
+    @brief This macro is executed if you call SetConsoleCommand() with 2 arguments.
+    @param name The name (string) of the console command
+    @param functionpointer The function-pointer of the corresponding command-function
+*/
 #define SetConsoleCommand2(name, functionpointer) \
     SetConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
+/**
+    @brief This macro is executed if you call SetConsoleCommand() with 3 arguments.
+    @param group The group (string) of the console command
+    @param name The name (string) of the console command
+    @param functionpointer The function-pointer of the corresponding command-function
+*/
 #define SetConsoleCommand3(group, name, functionpointer) \
     SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
+/**
+    @brief This macro is executed if you call SetConsoleCommand() with 4 arguments.
+    @param group The group (string) of the console command
+    @param name The name (string) of the console command
+    @param functionpointer The function-pointer of the corresponding command-function
+    @param object The object that will be assigned to the command. Used for member-functions.
+*/
 #define SetConsoleCommand4(group, name, functionpointer, object) \
     SetConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
 
+/// Internal macro
 #define SetConsoleCommandGeneric(group, name, functor) \
     static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor)))
 
 
+/**
+    @brief Declares a console command. The macro is overloaded for 2-3 parameters.
+
+    This is an overloaded macro. Depending on the number of arguments a different
+    overloaded implementation of the macro will be chosen.
+
+    Console commands created with DeclareConsoleCommand() don't use the the given
+    function-pointer to execute the command, it is only used to define the header
+    of the future command-function. The command is inactive until you manually
+    set a function with orxonox::ModifyConsoleCommand(). You can use a different
+    function-pointer than in the final command, as long as it has the same header.
+*/
 #define DeclareConsoleCommand(...) \
     BOOST_PP_EXPAND(BOOST_PP_CAT(DeclareConsoleCommand, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
+/**
+    @brief This macro is executed if you call DeclareConsoleCommand() with 2 arguments.
+    @param name The name (string) of the console command
+    @param functionpointer The function-pointer of an arbitrary function that has the same header as the final function
+*/
 #define DeclareConsoleCommand2(name, functionpointer) \
     DeclareConsoleCommandGeneric("", name, orxonox::createFunctor(functionpointer))
+/**
+    @brief This macro is executed if you call DeclareConsoleCommand() with 3 arguments.
+    @param group The group (string) of the console command
+    @param name The name (string) of the console command
+    @param functionpointer The function-pointer of an arbitrary function that has the same header as the final function
+*/
 #define DeclareConsoleCommand3(group, name, functionpointer) \
     DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer))
-#define DeclareConsoleCommand4(group, name, functionpointer, object) \
-    DeclareConsoleCommandGeneric(group, name, orxonox::createFunctor(functionpointer, object))
-
+
+/// Internal macro
 #define DeclareConsoleCommandGeneric(group, name, functor) \
     static orxonox::ConsoleCommand& BOOST_PP_CAT(__consolecommand_, __LINE__) = (*orxonox::createConsoleCommand(group, name, orxonox::createExecutor(functor), false))
@@ -70,4 +309,8 @@
 namespace orxonox
 {
+    /**
+        @brief A small collection of functions that can be used in DeclareConsoleCommand() if
+        you don't want to use the real function-pointer.
+    */
     namespace prototype
     {
@@ -78,4 +321,7 @@
     namespace AccessLevel
     {
+        /**
+            @brief Possible access levels: A command can only be executed if the program is in the state which is requested by the access level.
+        */
         enum Enum
         {
@@ -91,21 +337,48 @@
     }
 
+    /**
+        @brief The ConsoleCommand class stores all information about a console command which can be executed by CommandExecutor.
+
+        Console commands can be entered by the user into the shell, called in scripts, or
+        used for key-bindings. They are simple text strings that can be executed by
+        CommandExecutor. CommandExecutor will search for a ConsoleCommand with the given
+        group and name and will execute it's Executor (which again calls the Functor and
+        this finally calls the command-function).
+
+        @see See @ref ConsoleCommandExample "ConsoleCommand.h" for more information and some examples.
+    */
     class _CoreExport ConsoleCommand
     {
         friend struct ConsoleCommandManipulator;
 
+        /**
+            @brief Helper class that is used to put the current state of the ConsoleCommand on a stack.
+        */
         struct Command
         {
-            ExecutorPtr executor_;
-            FunctorPtr functor_;
-            std::vector<void*> objectStack_;
+            ExecutorPtr executor_;              ///< The executor
+            FunctorPtr functor_;                ///< The function that is used with the executor - has to be stored separatley because the executor is often used with different functors
+            std::vector<void*> objectStack_;    ///< The object stack
         };
 
         public:
+            /**
+                @brief Helper class that is used to manipulate console commands.
+
+                An instance of this class is returned if you call the ModifyConsoleCommand macro.
+                This class provides an interface which wraps some functions of ConsoleCommand. It
+                allows access to some private functions like setFunction() (that can't be called
+                right after SetConsoleCommand()) but it also hides some functions that shouln't be
+                called after the static declaration like addShortcut() or description().
+
+                @see See @ref ConsoleCommandExample "ConsoleCommand.h" for more information and examples.
+            */
             struct ConsoleCommandManipulator
             {
                 public:
+                    /// Constructor: Creates a manipulator for a given ConsoleCommand.
                     ConsoleCommandManipulator(const ConsoleCommand* command) : command_(const_cast<ConsoleCommand*>(command)) {}
 
+                    /// Changes the current function of the command. @param function The new function-pointer @param bForce If true, the new function-pointer is always assigned, even if the headers don't match
                     template <class F>
                     inline ConsoleCommandManipulator& setFunction(F function, bool bForce = false)
@@ -113,4 +386,5 @@
                             if (this->command_)
                             {
+                                // check if the headers match. If they do, only change the function-pointer of the current Functor instead of creating a new Functor
                                 if (this->command_->getExecutor() && this->command_->getExecutor()->getFunctor() && this->command_->getExecutor()->getFunctor()->getFullIdentifier() == typeid(F))
                                 {
@@ -123,4 +397,5 @@
                             return *this;
                         }
+                    /// Changes the current function of the command. @param function The new function-pointer @param object The new object-pointer (for member-functions) @param bForce If true, the new function-pointer is always assigned, even if the headers don't match
                     template <class F, class O>
                     inline ConsoleCommandManipulator& setFunction(F function, O* object, bool bForce = false)
@@ -128,4 +403,5 @@
                             if (this->command_)
                             {
+                                // check if the headers match. If they do, only change the function-pointer of the current Functor instead of creating a new Functor
                                 if (this->command_->getExecutor() && this->command_->getExecutor()->getFunctor() && this->command_->getExecutor()->getFunctor()->getFullIdentifier() == typeid(F))
                                 {
@@ -139,77 +415,106 @@
                             return *this;
                         }
+                    /// Changes the current Functor of the command. @param functor The new Functor @param bForce If true, the new Functor is always assigned, even if the headers don't match
                     inline ConsoleCommandManipulator& setFunction(const FunctorPtr& functor, bool bForce = false)
                         { if (this->command_) { this->command_->setFunction(functor, bForce); } return *this; }
+                    /// Changes the current Executor of the command. @param executor The new Executor @param bForce If true, the new Executor is always assigned, even if the headers don't match
                     inline ConsoleCommandManipulator& setFunction(const ExecutorPtr& executor, bool bForce = false)
                         { if (this->command_) { this->command_->setFunction(executor, bForce); } return *this; }
 
+                    /// Pushes a copy of the current Executor on the command-stack, that can be altered without changing the old Executor. @details This function is especially useful if you don't wan't to change the function, but only the default values of the executor.
                     inline ConsoleCommandManipulator& pushFunction()
                         { if (this->command_) { this->command_->pushFunction(); } return *this; }
+                    /// Pushes a new function on the command-stack. @param function The new function-pointer @param bForce If true, the new function-pointer is always assigned, even if the headers don't match
                     template <class F>
                     inline ConsoleCommandManipulator& pushFunction(F function, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(createFunctor(function), bForce); } return *this; }
+                    /// Pushes a new function on the command-stack. @param function The new function-pointer @param object The new object-pointer (for member-functions) @param bForce If true, the new function-pointer is always assigned, even if the headers don't match
                     template <class F, class O>
                     inline ConsoleCommandManipulator& pushFunction(F function, O* object, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(createFunctor(function, object), bForce); } return *this; }
+                    /// Pushes a new Functor on the command-stack. @param functor The new Functor @param bForce If true, the new Functor is always assigned, even if the headers don't match
                     inline ConsoleCommandManipulator& pushFunction(const FunctorPtr& functor, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(functor, bForce); } return *this; }
+                    /// Pushes a new Executor on the command-stack. @param executor The new Executor @param bForce If true, the new Executor is always assigned, even if the headers don't match
                     inline ConsoleCommandManipulator& pushFunction(const ExecutorPtr& executor, bool bForce = false)
                         { if (this->command_) { this->command_->pushFunction(executor, bForce); } return *this; }
 
+                    /// Removes the current function from the stack and restores the old state. If there's no other function on the stack, the command is deactivated.
                     inline ConsoleCommandManipulator& popFunction()
                         { if (this->command_) { this->command_->popFunction(); } return *this; }
 
+                    /// Sets the current function-pointer to NULL, which also deactivates the command.
                     inline ConsoleCommandManipulator& resetFunction()
                         { if (this->command_) { this->command_->resetFunction(); } return *this; }
 
+                    /// Changes the current object (used for member-functions).
                     inline ConsoleCommandManipulator& setObject(void* object)
                         { if (this->command_) { this->command_->setObject(object); } return *this; }
+                    /// Pushes a new object on the object-stack.
                     inline ConsoleCommandManipulator& pushObject(void* object)
                         { if (this->command_) { this->command_->pushObject(object); } return *this; }
+                    /// Removes the current object from the object-stack and restores the old object (or NULL if there's no object left on the stack).
                     inline ConsoleCommandManipulator& popObject()
                         { if (this->command_) { this->command_->popObject(); } return *this; }
 
+                    /// Changes the activity of the command.
                     inline ConsoleCommandManipulator& setActive(bool bActive)
                         { if (this->command_) { this->command_->setActive(bActive); } return *this; }
+                    /// Activates the command.
                     inline ConsoleCommandManipulator& activate()
                         { return this->setActive(true); }
+                    /// Deactivates the command.
                     inline ConsoleCommandManipulator& deactivate()
                         { return this->setActive(false); }
 
+                    /// Changes the visibility of the command.
                     inline ConsoleCommandManipulator& setHidden(bool bHidden)
                         { if (this->command_) { this->command_->setHidden(bHidden); } return *this; }
+                    /// Hides the command (can still be executed, but is not visible in the list of available commands).
                     inline ConsoleCommandManipulator& hide()
                         { return this->setHidden(true); }
+                    /// Makes the command visible.
                     inline ConsoleCommandManipulator& show()
                         { return this->setHidden(false); }
 
-                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1)
-                        { if (this->command_) { this->command_->defaultValues(param1); } return *this; }
-                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2)
-                        { if (this->command_) { this->command_->defaultValues(param1, param2); } return *this; }
-                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
-                        { if (this->command_) { this->command_->defaultValues(param1, param2, param3); } return *this; }
-                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
-                        { if (this->command_) { this->command_->defaultValues(param1, param2, param3, param4); } return *this; }
-                    inline ConsoleCommandManipulator& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
-                        { if (this->command_) { this->command_->defaultValues(param1, param2, param3, param4, param5); } return *this; }
-                    inline ConsoleCommandManipulator& defaultValue(unsigned int index, const MultiType& param)
-                        { if (this->command_) { this->command_->defaultValue(index, param); } return *this; }
-
+                    /// Changes the default values of the current executor (doesn't modify executors on deeper levels of the command-stack).
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& arg1)
+                        { if (this->command_) { this->command_->defaultValues(arg1); } return *this; }
+                    /// Changes the default values of the current executor (doesn't modify executors on deeper levels of the command-stack).
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& arg1, const MultiType& arg2)
+                        { if (this->command_) { this->command_->defaultValues(arg1, arg2); } return *this; }
+                    /// Changes the default values of the current executor (doesn't modify executors on deeper levels of the command-stack).
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3)
+                        { if (this->command_) { this->command_->defaultValues(arg1, arg2, arg3); } return *this; }
+                    /// Changes the default values of the current executor (doesn't modify executors on deeper levels of the command-stack).
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4)
+                        { if (this->command_) { this->command_->defaultValues(arg1, arg2, arg3, arg4); } return *this; }
+                    /// Changes the default values of the current executor (doesn't modify executors on deeper levels of the command-stack).
+                    inline ConsoleCommandManipulator& defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5)
+                        { if (this->command_) { this->command_->defaultValues(arg1, arg2, arg3, arg4, arg5); } return *this; }
+                    /// Changes the default value of the argument with given index of the current executor (doesn't modify executors on deeper levels of the command-stack).
+                    inline ConsoleCommandManipulator& defaultValue(unsigned int index, const MultiType& arg)
+                        { if (this->command_) { this->command_->defaultValue(index, arg); } return *this; }
+
+                    /// Changes the access level of the command.
                     inline ConsoleCommandManipulator& accessLevel(AccessLevel::Enum level)
                         { if (this->command_) { this->command_->accessLevel(level); } return *this; }
 
-                    inline ConsoleCommandManipulator& argumentCompleter(unsigned int param, ArgumentCompleter* completer)
-                        { if (this->command_) { this->command_->argumentCompleter(param, completer); } return *this; }
-
+                    /// Changes the argument completer for the given parameter.
+                    inline ConsoleCommandManipulator& argumentCompleter(unsigned int index, ArgumentCompleter* completer)
+                        { if (this->command_) { this->command_->argumentCompleter(index, completer); } return *this; }
+
+                    /// Defines the command to be an input command.
                     inline ConsoleCommandManipulator& setAsInputCommand()
                         { if (this->command_) { this->command_->setAsInputCommand(); } return *this; }
+                    /// Changes the keybind mode of the command.
                     inline ConsoleCommandManipulator& keybindMode(KeybindMode::Value mode)
                         { if (this->command_) { this->command_->keybindMode(mode); } return *this; }
+                    /// Sets the input configured param to the given index.
                     inline ConsoleCommandManipulator& inputConfiguredParam(int index)
                         { if (this->command_) { this->command_->inputConfiguredParam(index); } return *this; }
 
                 private:
-                    ConsoleCommand* command_;
+                    ConsoleCommand* command_;   ///< The command which is being manipulated by this object
             };
 
@@ -223,22 +528,30 @@
             ConsoleCommand& addGroup(const std::string& group, const std::string&  name);
 
+            /// Returns the name that was first used for this command.
             inline const std::string& getName() const
                 { return this->baseName_; }
 
             const ExecutorPtr& getExecutor() const;
+            /// Returns the functor that defines the required header for this command (but isn't necessarily executed).
             inline const FunctorPtr& getBaseFunctor() const
                 { return this->baseFunctor_; }
 
+            /// Changes the activity of the command.
             inline ConsoleCommand& setActive(bool bActive)
                 { this->bActive_ = bActive; return *this; }
+            /// Activates the command.
             inline ConsoleCommand& activate()
                 { return this->setActive(true); }
+            /// Deactivates the command.
             inline ConsoleCommand& deactivate()
                 { return this->setActive(false); }
 
+            /// Changes the visibility of the command.
             inline ConsoleCommand& setHidden(bool bHidden)
                 { this->bHidden_ = bHidden; return *this; }
+            /// Hides the command (can still be executed, but is not visible in the list of available commands).
             inline ConsoleCommand& hide()
                 { return this->setHidden(true); }
+            /// Makes the command visible.
             inline ConsoleCommand& show()
                 { return this->setHidden(false); }
@@ -246,4 +559,5 @@
             bool isActive() const;
             bool hasAccess() const;
+            /// Returns true if the command is currently hidden.
             inline bool isHidden() const
                 { return this->bHidden_; }
@@ -252,25 +566,28 @@
             const std::string& getDescription() const;
 
-            ConsoleCommand& descriptionParam(unsigned int param, const std::string& description);
-            const std::string& getDescriptionParam(unsigned int param) const;
+            ConsoleCommand& descriptionParam(unsigned int index, const std::string& description);
+            const std::string& getDescriptionParam(unsigned int index) const;
 
             ConsoleCommand& descriptionReturnvalue(const std::string& description);
-            const std::string& getDescriptionReturnvalue(int param) const;
-
-            ConsoleCommand& defaultValues(const MultiType& param1);
-            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2);
-            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
-            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
-            ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
-            ConsoleCommand& defaultValue(unsigned int index, const MultiType& param);
-
+            const std::string& getDescriptionReturnvalue(int index) const;
+
+            ConsoleCommand& defaultValues(const MultiType& arg1);
+            ConsoleCommand& defaultValues(const MultiType& arg1, const MultiType& arg2);
+            ConsoleCommand& defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3);
+            ConsoleCommand& defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4);
+            ConsoleCommand& defaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5);
+            ConsoleCommand& defaultValue(unsigned int index, const MultiType& arg);
+
+            /// Changes the access level of the command.
             inline ConsoleCommand& accessLevel(AccessLevel::Enum level)
                 { this->accessLevel_ = level; return *this; }
+            /// Returns the access level of the command.
             inline AccessLevel::Enum getAccessLevel() const
                 { return this->accessLevel_; }
 
-            ConsoleCommand& argumentCompleter(unsigned int param, ArgumentCompleter* completer);
-            ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
-
+            ConsoleCommand& argumentCompleter(unsigned int index, ArgumentCompleter* completer);
+            ArgumentCompleter* getArgumentCompleter(unsigned int index) const;
+
+            /// Defines the command to be an input command
             inline ConsoleCommand& setAsInputCommand()
             {
@@ -281,14 +598,19 @@
             }
 
+            /// Changes the keybind mode.
             inline ConsoleCommand& keybindMode(KeybindMode::Value mode)
                 { this->keybindMode_ = mode; return *this; }
+            /// Returns the keybind mode
             inline KeybindMode::Value getKeybindMode() const
                 { return this->keybindMode_; }
 
+            /// Changes the input configured param to the given index.
             inline ConsoleCommand& inputConfiguredParam(int index)
                 { this->inputConfiguredParam_ = index; return *this; }
+            /// Returns the input configured param.
             inline int getInputConfiguredParam_() const
                 { return this->inputConfiguredParam_; }
 
+            /// Returns a manipulator for this command.
             inline ConsoleCommandManipulator getManipulator() const
                 { return this; }
@@ -311,31 +633,35 @@
             void* getObject() const;
 
-            bool bActive_;
-            bool bHidden_;
-            AccessLevel::Enum accessLevel_;
-            std::string baseName_;
-            FunctorPtr baseFunctor_;
-
-            ExecutorPtr executor_;
-            std::stack<Command> commandStack_;
-            std::vector<void*> objectStack_;
-
-            ArgumentCompleter* argumentCompleter_[5];
-
-            KeybindMode::Value keybindMode_;
-            int inputConfiguredParam_;
-
-            LanguageEntryLabel description_;
-            LanguageEntryLabel descriptionReturnvalue_;
-            LanguageEntryLabel descriptionParam_[MAX_FUNCTOR_ARGUMENTS];
+            bool bActive_;                                                  ///< True if the command should be active (it can still be inactive, for example if the function is missing)
+            bool bHidden_;                                                  ///< True if the command is hidden (it is still executable, but not visible in the list of available commands)
+            AccessLevel::Enum accessLevel_;                                 ///< The access level (the state of the game in which you can access the command)
+            std::string baseName_;                                          ///< The name that was first assigned to the command
+            FunctorPtr baseFunctor_;                                        ///< The functor that defines the header of the command-function
+
+            ExecutorPtr executor_;                                          ///< The Executor that is used to execute the command
+            std::stack<Command> commandStack_;                              ///< A stack of commands, used to push and pop different functions
+            std::vector<void*> objectStack_;                                ///< A stack of objects, used to push and pop different objects for a function
+
+            ArgumentCompleter* argumentCompleter_[MAX_FUNCTOR_ARGUMENTS];   ///< ArgumentCompleter for each argument
+
+            KeybindMode::Value keybindMode_;                                ///< The keybind mode
+            int inputConfiguredParam_;                                      ///< The input configured param
+
+            LanguageEntryLabel description_;                                ///< The description of the command
+            LanguageEntryLabel descriptionReturnvalue_;                     ///< A description of the return-value
+            LanguageEntryLabel descriptionParam_[MAX_FUNCTOR_ARGUMENTS];    ///< A description for each argument
 
         public:
+            /// Returns the map with all groups and commands.
             static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommands()
                 { return ConsoleCommand::getCommandMap(); }
+            /// Returns the map with all groups and commands in lowercase.
             static inline const std::map<std::string, std::map<std::string, ConsoleCommand*> >& getCommandsLC()
                 { return ConsoleCommand::getCommandMapLC(); }
 
+            /// Returns a command (shortcut) with given name. @param name The name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
             static inline const ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
                 { return ConsoleCommand::getCommand("", name, bPrintError); }
+            /// Returns a command (shortcut) with given name in lowercase. @param name The lowercase name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
             static inline const ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
                 { return ConsoleCommand::getCommandLC("", name, bPrintError); }
@@ -354,11 +680,39 @@
     };
 
+    /**
+        @brief Creates a new ConsoleCommand.
+        @param name The name of the command
+        @param executor The executor of the command
+        @param bInitialized If true, the command is ready to be executed, otherwise it has to be activated first.
+    */
     inline ConsoleCommand* createConsoleCommand(const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
         { return new ConsoleCommand("", name, executor, bInitialized); }
+    /**
+        @brief Creates a new ConsoleCommand.
+        @param group The group of the command
+        @param name The name of the command
+        @param executor The executor of the command
+        @param bInitialized If true, the command is ready to be executed, otherwise it has to be activated first.
+    */
     inline ConsoleCommand* createConsoleCommand(const std::string& group, const std::string& name, const ExecutorPtr& executor, bool bInitialized = true)
         { return new ConsoleCommand(group, name, executor, bInitialized); }
 
+
+    /**
+        @brief Returns a manipulator for a command with the given name.
+
+        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
+        but it can still be used without checks, because all functions of ConsoleCommandManipulator
+        check internally if the command exists.
+    */
     inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& name)
         { return ConsoleCommand::getCommand(name, true); }
+    /**
+        @brief Returns a manipulator for a command with the given group and name.
+
+        @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
+        but it can still be used without checks, because all functions of ConsoleCommandManipulator
+        check internally if the command exists.
+    */
     inline ConsoleCommand::ConsoleCommandManipulator ModifyConsoleCommand(const std::string& group, const std::string& name)
         { return ConsoleCommand::getCommand(group, name, true); }
Index: code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc
===================================================================
--- code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/ConsoleCommandCompilation.cc	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @brief Implementation of some console commands.
+*/
 
 #include "ConsoleCommandCompilation.h"
@@ -51,4 +56,7 @@
     SetConsoleCommand("calculate", calculate);
 
+    /**
+        @brief Reads the content of a file and executes the commands in it line by line.
+    */
     void source(const std::string& filename)
     {
@@ -86,4 +94,7 @@
     }
 
+    /**
+        @brief Simply returns the arguments.
+    */
     std::string echo(const std::string& text)
     {
@@ -91,4 +102,7 @@
     }
 
+    /**
+        @brief Writes text to the console, depending on the first argument with or without a line-break after it.
+    */
     void puts(bool newline, const std::string& text)
     {
@@ -103,4 +117,7 @@
     }
 
+    /**
+        @brief Writes text to a file.
+    */
     void write(const std::string& filename, const std::string& text)
     {
@@ -118,4 +135,7 @@
     }
 
+    /**
+        @brief Appends text to a file.
+    */
     void append(const std::string& filename, const std::string& text)
     {
@@ -133,4 +153,7 @@
     }
 
+    /**
+        @brief Reads text from a file
+    */
     std::string read(const std::string& filename)
     {
@@ -158,4 +181,7 @@
     }
 
+    /**
+        @brief Parses the mathematical expression and returns the result.
+    */
     float calculate(const std::string& calculation)
     {
Index: code/trunk/src/libraries/core/command/ConsoleCommandCompilation.h
===================================================================
--- code/trunk/src/libraries/core/command/ConsoleCommandCompilation.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/ConsoleCommandCompilation.h	(revision 7401)
@@ -27,4 +27,10 @@
  */
 
+/**
+    @file
+    @ingroup Command ConsoleCommand
+    @brief Declaration of some console commands.
+*/
+
 #ifndef _ConsoleCommandCompilation_H__
 #define _ConsoleCommandCompilation_H__
Index: code/trunk/src/libraries/core/command/Executor.cc
===================================================================
--- code/trunk/src/libraries/core/command/Executor.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/Executor.cc	(revision 7401)
@@ -27,4 +27,9 @@
  *   Inspiration: Executor by Benjamin Grauer
  */
+
+/**
+    @file
+    @brief Implementation of orxonox::Executor
+*/
 
 #include "Executor.h"
@@ -40,4 +45,9 @@
 namespace orxonox
 {
+    /**
+        @brief Constructor: Creates an executor.
+        @param functor The wrapped functor
+        @param name The name of the executor (optional, used mostly for debug output)
+    */
     Executor::Executor(const FunctorPtr& functor, const std::string& name)
     {
@@ -46,4 +56,7 @@
     }
 
+    /**
+        @brief Copy-constructor: Creates a new executor with the same values and a clone of the wrapped Functor.
+    */
     Executor::Executor(const Executor& other) : name_(other.name_)
     {
@@ -53,8 +66,19 @@
     }
 
+    /**
+        @brief Destructor
+    */
     Executor::~Executor()
     {
     }
 
+    /**
+        @brief Calls the wrapped function with arguments that are passed in a string.
+        @param arguments The arguments that should be passed to the function, separated by @a delimiter
+        @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param delimiter The delimiter that is used to separate the arguments in the string @a arguments
+        @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
+        @return Returns the return value of the function (or MT_Type::Null if there is no return value)
+    */
     MultiType Executor::parse(const std::string& arguments, int* error, const std::string& delimiter, bool bPrintError) const
     {
@@ -62,31 +86,50 @@
     }
 
+    /**
+        @brief Calls the wrapped function with arguments that are passed as tokens in a SubString
+        @param arguments The arguments that should be passed to the function
+        @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
+        @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
+        @return Returns the return value of the function (or MT_Type::Null if there is no return value)
+    */
     MultiType Executor::parse(const SubString& arguments, int* error, const std::string& delimiter, bool bPrintError) const
     {
-        MultiType param[MAX_FUNCTOR_ARGUMENTS];
-        unsigned int paramCount = this->evaluateParams(arguments, param, error, delimiter);
-
+        // evaluate the arguments
+        MultiType arg[MAX_FUNCTOR_ARGUMENTS];
+        unsigned int argCount = this->evaluateArguments(arguments, arg, error, delimiter);
+
+        // check if an error occurred
         if (error && *error)
         {
             if (bPrintError)
-                COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough parameters or default values given (input: " << arguments.join() << ")." << std::endl;
+                COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << std::endl;
             return MT_Type::Null;
         }
 
-        COUT(5) << "Executor::parse: \"" << arguments.join(delimiter) << "\" -> " << paramCount << " params: " << param[0] << " / " << param[1] << " / " << param[2] << " / " << param[3] << " / " << param[4] << std::endl;
-
-        switch (paramCount)
+        COUT(5) << "Executor::parse: \"" << arguments.join(delimiter) << "\" -> " << argCount << " arguments: " << arg[0] << " / " << arg[1] << " / " << arg[2] << " / " << arg[3] << " / " << arg[4] << std::endl;
+
+        // execute the function with the evaluated arguments (the default values of the executor are also included in these arguments)
+        switch (argCount)
         {
             case 0:  return (*this->functor_)();
-            case 1:  return (*this->functor_)(param[0]);
-            case 2:  return (*this->functor_)(param[0], param[1]);
-            case 3:  return (*this->functor_)(param[0], param[1], param[2]);
-            case 4:  return (*this->functor_)(param[0], param[1], param[2], param[3]);
+            case 1:  return (*this->functor_)(arg[0]);
+            case 2:  return (*this->functor_)(arg[0], arg[1]);
+            case 3:  return (*this->functor_)(arg[0], arg[1], arg[2]);
+            case 4:  return (*this->functor_)(arg[0], arg[1], arg[2], arg[3]);
             case 5:
-            default: return (*this->functor_)(param[0], param[1], param[2], param[3], param[4]);
+            default: return (*this->functor_)(arg[0], arg[1], arg[2], arg[3], arg[4]);
         }
     }
 
-    int Executor::evaluateParams(const SubString& arguments, MultiType param[MAX_FUNCTOR_ARGUMENTS], int* error, const std::string& delimiter) const
+    /**
+        @brief Converts the arguments in a SubString to the right type, so they can be used to execute the function without further conversions.
+        @param arguments The arguments that should be converted
+        @param arg An array of MultiType where the converted arguments will be stored
+        @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
+        @return Returns the number of evaluated arguments
+    */
+    int Executor::evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error, const std::string& delimiter) const
     {
         unsigned int paramCount = this->functor_->getParamCount();
@@ -106,17 +149,17 @@
         // assign all given arguments to the multitypes
         for (unsigned int i = 0; i < std::min(std::min(argumentCount, paramCount), MAX_FUNCTOR_ARGUMENTS); i++)
-            param[i] = arguments[i];
+            arg[i] = arguments[i];
 
         // fill the remaining multitypes with default values
         for (unsigned int i = argumentCount; i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
-            param[i] = this->defaultValue_[i];
+            arg[i] = this->defaultValue_[i];
 
         // assign the remaining arguments all to the last parameter if it is a string
         if ((paramCount <= MAX_FUNCTOR_ARGUMENTS) &&(argumentCount > paramCount) && (paramCount == 1 || this->functor_->getTypenameParam(paramCount - 1) == "string"))
-            param[paramCount - 1] = arguments.subSet(paramCount - 1).join(delimiter);
-
-        // evaluate the param types through the functor
+            arg[paramCount - 1] = arguments.subSet(paramCount - 1).join(delimiter);
+
+        // evaluate the parameter types through the functor
         for (unsigned int i = 0; i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
-            this->functor_->evaluateParam(i, param[i]);
+            this->functor_->evaluateArgument(i, arg[i]);
 
         if (error)
@@ -125,45 +168,52 @@
     }
 
-    void Executor::setDefaultValues(const MultiType& param1)
-    {
-        this->defaultValue_[0] = param1;
-    }
-
-    void Executor::setDefaultValues(const MultiType& param1, const MultiType& param2)
-    {
-        this->defaultValue_[0] = param1;
-        this->defaultValue_[1] = param2;
-    }
-
-    void Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
-    {
-        this->defaultValue_[0] = param1;
-        this->defaultValue_[1] = param2;
-        this->defaultValue_[2] = param3;
-    }
-
-    void Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
-    {
-        this->defaultValue_[0] = param1;
-        this->defaultValue_[1] = param2;
-        this->defaultValue_[2] = param3;
-        this->defaultValue_[3] = param4;
-    }
-
-    void Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
-    {
-        this->defaultValue_[0] = param1;
-        this->defaultValue_[1] = param2;
-        this->defaultValue_[2] = param3;
-        this->defaultValue_[3] = param4;
-        this->defaultValue_[4] = param5;
-    }
-
-    void Executor::setDefaultValue(unsigned int index, const MultiType& param)
+    /// Defines the default value for the first parameter.
+    void Executor::setDefaultValues(const MultiType& arg1)
+    {
+        this->defaultValue_[0] = arg1;
+    }
+
+    /// Defines the default value for the first two parameters.
+    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2)
+    {
+        this->defaultValue_[0] = arg1;
+        this->defaultValue_[1] = arg2;
+    }
+
+    /// Defines the default value for the first three parameters.
+    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3)
+    {
+        this->defaultValue_[0] = arg1;
+        this->defaultValue_[1] = arg2;
+        this->defaultValue_[2] = arg3;
+    }
+
+    /// Defines the default value for the first four parameters.
+    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4)
+    {
+        this->defaultValue_[0] = arg1;
+        this->defaultValue_[1] = arg2;
+        this->defaultValue_[2] = arg3;
+        this->defaultValue_[3] = arg4;
+    }
+
+    /// Defines the default value for the first five parameters.
+    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5)
+    {
+        this->defaultValue_[0] = arg1;
+        this->defaultValue_[1] = arg2;
+        this->defaultValue_[2] = arg3;
+        this->defaultValue_[3] = arg4;
+        this->defaultValue_[4] = arg5;
+    }
+
+    /// Defines the default value for a parameter with given index (the first parameter has index 0).
+    void Executor::setDefaultValue(unsigned int index, const MultiType& arg)
     {
         if (index < MAX_FUNCTOR_ARGUMENTS)
-            this->defaultValue_[index] = param;
-    }
-
+            this->defaultValue_[index] = arg;
+    }
+
+    /// Returns true if the executor has a default value for each parameter of the wrapped function, so it can be called without passing additional arguments.
     bool Executor::allDefaultValuesSet() const
     {
Index: code/trunk/src/libraries/core/command/Executor.h
===================================================================
--- code/trunk/src/libraries/core/command/Executor.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/Executor.h	(revision 7401)
@@ -28,4 +28,54 @@
  */
 
+/**
+    @defgroup FunctorExecutor Functor and Executor
+    @ingroup Command
+*/
+
+/**
+    @file
+    @ingroup Command FunctorExecutor
+    @brief Declaration of the orxonox::Executor class and the createExecutor() functions.
+
+    @anchor ExecutorExample
+
+    orxonox::Executor is used to wrap an orxonox::Functor and to store default values for
+    its parameters. Usually one uses the function createExecutor() to create a new executor.
+    This function returns an orxonox::ExecutorPtr which is a typedef of @ref orxonox::SharedPtr
+    "SharedPtr<Executor>", used to manage the pointer to the executor.
+
+    Executors are mostly used to execute callbacks. Because some callback functions need arguments,
+    Executor provides an easy interface to store these arguments as default values, so the
+    executor can also be executed without arguments because it will use these default values.
+
+    The Executor doesn't contain the function-pointer directly. Instead it wraps an instance
+    of orxonox::Functor. See @ref FunctorExample "Functor.h" for more information and some
+    examples.
+
+    Example:
+    @code
+    void myFunction(int a, int b)                           // declare a static function
+    {
+        COUT(0) << "The sum is " << (a + b) << std::endl;   // print the sum of a and b to the console
+    }
+
+    FunctorPtr functor = createFunctor(&myFunction);        // create a functor that wraps the function-pointer
+    ExecutorPtr executor = createExecutor(functor);         // create an executor that wraps the functor
+
+    (*executor)(2, 5);                                      // calls the executor with arguments 2 and 5, prints "The sum is 7" to the console
+
+    executor->setDefaultValue(1, 10);                       // sets the default-value for the second parameter (note: paramters start at index 0) to 10
+
+    (*executor)(2);                                         // calls the executor with argument 2 and default-value 10, prints "The sum is 12"
+
+    executor->setDefaultValue(0, 5);                        // sets the default-value for the first parameter to 5
+
+    (*executor)();                                          // calls the executor with default-values only, prints "The sum is 15"
+    @endcode
+
+    Because executors that were created with createExecutor() are managed by an orxonox::SharedPtr,
+    they don't need to be deleted after usage.
+*/
+
 #ifndef _Executor_H__
 #define _Executor_H__
@@ -40,4 +90,9 @@
 namespace orxonox
 {
+    /**
+        @brief This class is used to wrap a Functor and to store default values for any of its parameters.
+
+        @see See @ref ExecutorExample "Executor.h" for an example.
+    */
     class _CoreExport Executor
     {
@@ -47,50 +102,66 @@
             virtual ~Executor();
 
+            /// Calls the wrapped function with 0 arguments. If the function needs more arguments, the executor's default values are used.
             inline MultiType operator()() const
                 { return (*this->functor_)(this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const MultiType& param1) const
-                { return (*this->functor_)(param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const MultiType& param1, const MultiType& param2) const
-                { return (*this->functor_)(param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3) const
-                { return (*this->functor_)(param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
-                { return (*this->functor_)(param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline MultiType operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
-                { return (*this->functor_)(param1, param2, param3, param4, param5); }
+            /// Calls the wrapped function with 1 argument. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(const MultiType& arg1) const
+                { return (*this->functor_)(arg1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            /// Calls the wrapped function with 2 arguments. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(const MultiType& arg1, const MultiType& arg2) const
+                { return (*this->functor_)(arg1, arg2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            /// Calls the wrapped function with 3 arguments. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3) const
+                { return (*this->functor_)(arg1, arg2, arg3, this->defaultValue_[3], this->defaultValue_[4]); }
+            /// Calls the wrapped function with 4 arguments. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4) const
+                { return (*this->functor_)(arg1, arg2, arg3, arg4, this->defaultValue_[4]); }
+            /// Calls the wrapped function with 5 arguments. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5) const
+                { return (*this->functor_)(arg1, arg2, arg3, arg4, arg5); }
 
             MultiType parse(const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
             MultiType parse(const SubString& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
 
-            int evaluateParams(const SubString& arguments, MultiType param[MAX_FUNCTOR_ARGUMENTS], int* error = 0, const std::string& delimiter = " ") const;
-
+            int evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error = 0, const std::string& delimiter = " ") const;
+
+            /// Changes the functor.
             inline void setFunctor(const FunctorPtr& functor)
                 { this->functor_ = functor; }
+            /// Returns the functor.
             inline const FunctorPtr& getFunctor() const
                 { return this->functor_; }
 
+            /// Changes the name of the executor.
             inline void setName(const std::string& name)
                 { this->name_ = name; }
+            /// Returns the name of the executor.
             inline const std::string& getName() const
                 { return this->name_; }
 
+            /// Returns the number of parameters of the wrapped function.
             inline unsigned int getParamCount() const
                 { return this->functor_->getParamCount(); }
+            /// Returns true if the wrapped function returns a value.
             inline bool hasReturnvalue() const
                 { return this->functor_->hasReturnvalue(); }
+            /// Returns the type of the wrapped function (static or member).
             inline Functor::Type::Enum getType() const
                 { return this->functor_->getType(); }
+            /// Returns the name of the type of a parameter with given index (the first parameter has index 0).
             inline std::string getTypenameParam(unsigned int param) const
                 { return this->functor_->getTypenameParam(param); }
+            /// Returns the name of the type of the return value.
             inline std::string getTypenameReturnvalue() const
                 { return this->functor_->getTypenameReturnvalue(); }
 
-            void setDefaultValues(const MultiType& param1);
-            void setDefaultValues(const MultiType& param1, const MultiType& param2);
-            void setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
-            void setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
-            void setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
-            void setDefaultValue(unsigned int index, const MultiType& param);
-
+            void setDefaultValues(const MultiType& arg1);
+            void setDefaultValues(const MultiType& arg1, const MultiType& arg2);
+            void setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3);
+            void setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4);
+            void setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5);
+            void setDefaultValue(unsigned int index, const MultiType& arg);
+
+            /// Returns the default value for a parameter with given index (the first parameter has index 0).
             inline MultiType getDefaultValue(unsigned int index) const
             {
@@ -102,4 +173,6 @@
 
             bool allDefaultValuesSet() const;
+
+            /// Returns true if the executor contains a default value for the parameter with given index (the first parameter has index 0).
             inline bool defaultValueSet(unsigned int index) const
             {
@@ -111,65 +184,75 @@
 
         protected:
-            FunctorPtr functor_;
-            std::string name_;
-            MultiType defaultValue_[MAX_FUNCTOR_ARGUMENTS];
+            FunctorPtr functor_;                                ///< The underlying Functor that wraps a function
+            std::string name_;                                  ///< The name of the executor
+            MultiType defaultValue_[MAX_FUNCTOR_ARGUMENTS];     ///< The default values, one for each parameter
     };
 
+    /**
+        @brief A child class of Executor, used to distinguish executors that wrap static functions from executors that wrap member-functions.
+
+        Behaves exactly like Executor, because static functions need no special treatment.
+    */
     class _CoreExport ExecutorStatic : public Executor
     {
         public:
+            /// Constructor: Initializes the parent class
             ExecutorStatic(const FunctorStaticPtr& functor, const std::string& name = "") : Executor(functor, name) {}
+            /// Destructor
             virtual ~ExecutorStatic() {}
     };
 
+    /**
+        @brief A child class of Executor, used for easier handling of non-static member-functions.
+
+        Overloads some functions that call the underlying FunctorMember and additionally pass
+        an object-pointer that is needed for non-static member-functions.
+    */
     template <class T>
     class ExecutorMember : public Executor
     {
         public:
+            /// Constructor: Initializes the parent class and the pointer to the member-functor.
             ExecutorMember(const FunctorMemberPtr<T>& functor, const std::string& name = "") : Executor(functor, name), functorMember_(functor) {}
+            /// Destructor
             virtual ~ExecutorMember() {}
 
             using Executor::operator();
 
+            /// Calls the wrapped function with 0 arguments and an object-pointer. If the function needs more arguments, the executor's default values are used.
             inline MultiType operator()(T* object) const
                 { return (*this->functorMember_)(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(T* object, const MultiType& param1) const
-                { return (*this->functorMember_)(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(T* object, const MultiType& param1, const MultiType& param2) const
-                { return (*this->functorMember_)(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
-                { return (*this->functorMember_)(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
-                { return (*this->functorMember_)(object, param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline MultiType operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
-                { return (*this->functorMember_)(object, param1, param2, param3, param4, param5); }
-
-
-            inline MultiType operator()(const T* object) const
-                { return (*this->functorMember_)(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const T* object, const MultiType& param1) const
-                { return (*this->functorMember_)(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const T* object, const MultiType& param1, const MultiType& param2) const
-                { return (*this->functorMember_)(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
-                { return (*this->functorMember_)(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline MultiType operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
-                { return (*this->functorMember_)(object, param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline MultiType operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
-                { return (*this->functorMember_)(object, param1, param2, param3, param4, param5); }
-
+            /// Calls the wrapped function with 1 argument and an object-pointer. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(T* object, const MultiType& arg1) const
+                { return (*this->functorMember_)(object, arg1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            /// Calls the wrapped function with 2 arguments and an object-pointer. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(T* object, const MultiType& arg1, const MultiType& arg2) const
+                { return (*this->functorMember_)(object, arg1, arg2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
+            /// Calls the wrapped function with 3 arguments and an object-pointer. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(T* object, const MultiType& arg1, const MultiType& arg2, const MultiType& arg3) const
+                { return (*this->functorMember_)(object, arg1, arg2, arg3, this->defaultValue_[3], this->defaultValue_[4]); }
+            /// Calls the wrapped function with 4 arguments and an object-pointer. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(T* object, const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4) const
+                { return (*this->functorMember_)(object, arg1, arg2, arg3, arg4, this->defaultValue_[4]); }
+            /// Calls the wrapped function with 5 arguments and an object-pointer. If the function needs more arguments, the executor's default values are used.
+            inline MultiType operator()(T* object, const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5) const
+                { return (*this->functorMember_)(object, arg1, arg2, arg3, arg4, arg5); }
+
+            /// Changes the object-pointer of the underlying FunctorMember.
             inline void setObject(T* object) const
                 { this->functorMember_->setObject(object); }
-            inline void setObject(const T* object) const
-                { this->functorMember_->setObject(object); }
+            /// Returns the object-pointer of the underlying FunctorMember.
+            inline T* getObject() const
+                { return this->functorMember_->getObject(); }
 
             using Executor::parse;
 
-            MultiType parse(T* object, const std::string& params, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const
+            /// Overloads Executor::parse() with an additional object-pointer.
+            MultiType parse(T* object, const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const
             {
                 T* oldobject = this->functorMember_->getObject();
 
                 this->functorMember_->setObject(object);
-                const MultiType& result = this->Executor::parse(params, error, delimiter, bPrintError);
+                const MultiType& result = this->Executor::parse(arguments, error, delimiter, bPrintError);
                 this->functorMember_->setObject(oldobject);
 
@@ -177,19 +260,9 @@
             }
 
-            MultiType parse(const T* object, const std::string& params, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const
-            {
-                T* oldobject = this->functorMember_->getObject();
-
-                this->functorMember_->setObject(object);
-                const MultiType& result = this->Executor::parse(params, error, delimiter, bPrintError);
-                this->functorMember_->setObjects(oldobject);
-
-                return result;
-            }
-
         protected:
-            FunctorMemberPtr<T> functorMember_;
+            FunctorMemberPtr<T> functorMember_;     ///< A pointer to the FunctorMember is stored separately to avoid casting when executing the function.
     };
 
+    /// Creates a new Executor that wraps a given Functor.
     inline ExecutorPtr createExecutor(const FunctorPtr& functor, const std::string& name = "")
     {
@@ -197,4 +270,5 @@
     }
 
+    /// Creates a new ExecutorMember that wraps a given FunctorMember.
     template <class T>
     inline ExecutorMemberPtr<T> createExecutor(const FunctorMemberPtr<T>& functor, const std::string& name = "")
@@ -203,4 +277,5 @@
     }
 
+    /// Creates a new ExecutorStatic that wraps a given FunctorStatic.
     inline ExecutorStaticPtr createExecutor(const FunctorStaticPtr& functor, const std::string& name = "")
     {
Index: code/trunk/src/libraries/core/command/ExecutorPtr.h
===================================================================
--- code/trunk/src/libraries/core/command/ExecutorPtr.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/ExecutorPtr.h	(revision 7401)
@@ -27,4 +27,22 @@
  */
 
+/**
+    @file
+    @ingroup Command FunctorExecutor
+    @brief Typedefs and definitions of ExecutorPtr, ExecutorStaticPtr, and ExecutorMemberPtr
+
+    Instances of orxonox::Executor are usually managed by an orxonox::SharedPtr. This ensures
+    that Executors will be destroyed after usage. To make things easier, there's a typedef
+    that defines ExecutorPtr as SharedPtr<Executor>.
+
+    Because there's not only orxonox::Executor, but also orxonox::ExecutorStatic, and
+    orxonox::ExecutorMember, the shared pointers need to store them all and also reflect
+    their hierarchy - ExecutorStatic and ExecutorMember should not be mixed, but both can
+    be converted to Executor. This is achieved by using orxonox::SharedChildPtr.
+
+    Because it's not possible to use a typedef for a template, we have to define the
+    helper class ExecutorMemberPtr<T> that makes it easier to use ExecutorMember.
+*/
+
 #ifndef _ExecutorPtr_H__
 #define _ExecutorPtr_H__
@@ -35,8 +53,11 @@
 namespace orxonox
 {
+    /// ExecutorPtr is just a typedef of SharedPtr
     typedef SharedPtr<Executor> ExecutorPtr;
 
+    /// ExecutorStaticPtr is just a typedef of SharedChildPtr
     typedef SharedChildPtr<ExecutorStatic, ExecutorPtr> ExecutorStaticPtr;
 
+    /// It's not possible to use a typedef for ExecutorMemberPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
     template <class T>
     class ExecutorMemberPtr : public SharedChildPtr<ExecutorMember<T>, ExecutorPtr>
Index: code/trunk/src/libraries/core/command/Functor.h
===================================================================
--- code/trunk/src/libraries/core/command/Functor.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/Functor.h	(revision 7401)
@@ -27,4 +27,88 @@
  */
 
+/**
+    @file
+    @ingroup Command FunctorExecutor
+    @brief Definition of orxonox::Functor and its specialized subclasses, as well as the createFunctor() functions.
+
+    @anchor FunctorExample
+
+    Functors can be used to wrap function-pointers. While function-pointers have a very
+    complicated syntax in C++, Functors are always the same and you can call the wrapped
+    function-pointer independently of its parameter with arguments of type MultiType. These
+    arguments are then automatically converted to the right type.
+
+    To create a Functor, the helper function createFunctor() is used. It returns an instance
+    of orxonox::FunctorPtr which is simply a typedef of @ref orxonox::SharedPtr "SharedPtr<Functor>".
+    This means you don't have to delete the Functor after using it, because it is managed
+    by the SharedPtr.
+
+    Example:
+    @code
+    int myStaticFunction(int value)                         // Definition of a static function
+    {
+        return (value * 2);                                 // Return the double of the value
+    }
+
+    FunctorPtr functor = createFunctor(&myStaticFunction);  // Create a Functor
+
+    int result = (*functor)(5);                             // Calls the functor with value = 5, result == 10
+
+    int result = (*functor)("7");                           // Calls the functor with a string which is converted to an integer, result == 14
+    @endcode
+
+    Functors can also be used if you work with member-functions. In this case createFunctor()
+    returns an instance of orxonox::FunctorMemberPtr - this allows you to define the object
+    that will be used to call the function.
+
+    Example:
+    @code
+    class MyClass                                                   // Define a class
+    {
+        public:
+            MyClass(const std::string& text)                        // Constructor
+            {
+                this->text_ = text;
+            }
+
+            bool contains(const std::string& word)                  // Function that searches for "word" in "text"
+            {
+                return (this->text_.find(word) != std::string::npos);
+            }
+
+        private:
+            std::string text_;                                      // Member variable
+    };
+
+    MyClass* object = new MyClass("Hello World");                   // Create an object of type MyClass and set its text to "Hello World"
+
+    FunctorPtr functor = createFunctor(&MyClass:contains, object);  // Create a Functor (note the object!)
+
+    bool result = (*functor)("World");                              // result == true
+    bool result = (*functor)("test");                               // result == false
+    @endcode
+
+    Instead of assigning the object directly to the functor when creating it, you can also define
+    it at any later point or when you call the functor. Note however that this works only with
+    orxonox::FunctorMember.
+
+    @code
+    MyClass* object1 = new MyClass("Hello World");                  // Create an object
+    MyClass* object2 = new MyClass("this is a test");               // Create another object
+
+    FunctorMemberPtr functor = createFunctor(&MyClass:contains);    // Create a FunctorMember (note: no object this time)
+
+    bool result = (*functor)("World");                              // result == false and an error: "Error: Can't execute FunctorMember, no object set."
+
+    bool result = (*functor)(object1, "World");                     // result == true
+    bool result = (*functor)(object1, "test");                      // result == false
+    bool result = (*functor)(object2, "test");                      // result == true
+
+    functor->setObject(object1);                                    // Assign an object to the FunctorMember
+
+    bool result = (*functor)("World");                              // result == true (no error this time, because the object was set using setObject())
+    @endcode
+*/
+
 #ifndef _Functor_H__
 #define _Functor_H__
@@ -40,35 +124,52 @@
 namespace orxonox
 {
-    const unsigned int MAX_FUNCTOR_ARGUMENTS = 5;
-
+    const unsigned int MAX_FUNCTOR_ARGUMENTS = 5;   ///< The maximum number of parameters of a function that is supported by Functor
+
+    namespace detail
+    {
+        template <class T>
+        inline std::string _typeToString() { return "unknown"; }
+
+        template <> inline std::string _typeToString<void>()               { return "void"; }
+        template <> inline std::string _typeToString<int>()                { return "int"; }
+        template <> inline std::string _typeToString<unsigned int>()       { return "uint"; }
+        template <> inline std::string _typeToString<char>()               { return "char"; }
+        template <> inline std::string _typeToString<unsigned char>()      { return "uchar"; }
+        template <> inline std::string _typeToString<short>()              { return "short"; }
+        template <> inline std::string _typeToString<unsigned short>()     { return "ushort"; }
+        template <> inline std::string _typeToString<long>()               { return "long"; }
+        template <> inline std::string _typeToString<unsigned long>()      { return "ulong"; }
+        template <> inline std::string _typeToString<long long>()          { return "longlong"; }
+        template <> inline std::string _typeToString<unsigned long long>() { return "ulonglong"; }
+        template <> inline std::string _typeToString<float>()              { return "float"; }
+        template <> inline std::string _typeToString<double>()             { return "double"; }
+        template <> inline std::string _typeToString<long double>()        { return "longdouble"; }
+        template <> inline std::string _typeToString<bool>()               { return "bool"; }
+        template <> inline std::string _typeToString<std::string>()        { return "string"; }
+        template <> inline std::string _typeToString<Vector2>()            { return "Vector2"; }
+        template <> inline std::string _typeToString<Vector3>()            { return "Vector3"; }
+        template <> inline std::string _typeToString<Quaternion>()         { return "Quaternion"; }
+        template <> inline std::string _typeToString<ColourValue>()        { return "ColourValue"; }
+        template <> inline std::string _typeToString<Radian>()             { return "Radian"; }
+        template <> inline std::string _typeToString<Degree>()             { return "Degree"; }
+    }
+
+    /// Returns the name of type @a T as string.
     template <class T>
-    inline std::string _typeToString() { return "unknown"; }
-
-    template <> inline std::string _typeToString<void>()               { return ""; }
-    template <> inline std::string _typeToString<int>()                { return "int"; }
-    template <> inline std::string _typeToString<unsigned int>()       { return "uint"; }
-    template <> inline std::string _typeToString<char>()               { return "char"; }
-    template <> inline std::string _typeToString<unsigned char>()      { return "uchar"; }
-    template <> inline std::string _typeToString<short>()              { return "short"; }
-    template <> inline std::string _typeToString<unsigned short>()     { return "ushort"; }
-    template <> inline std::string _typeToString<long>()               { return "long"; }
-    template <> inline std::string _typeToString<unsigned long>()      { return "ulong"; }
-    template <> inline std::string _typeToString<long long>()          { return "longlong"; }
-    template <> inline std::string _typeToString<unsigned long long>() { return "ulonglong"; }
-    template <> inline std::string _typeToString<float>()              { return "float"; }
-    template <> inline std::string _typeToString<double>()             { return "double"; }
-    template <> inline std::string _typeToString<long double>()        { return "longdouble"; }
-    template <> inline std::string _typeToString<bool>()               { return "bool"; }
-    template <> inline std::string _typeToString<std::string>()        { return "string"; }
-    template <> inline std::string _typeToString<Vector2>()            { return "Vector2"; }
-    template <> inline std::string _typeToString<Vector3>()            { return "Vector3"; }
-    template <> inline std::string _typeToString<Quaternion>()         { return "Quaternion"; }
-    template <> inline std::string _typeToString<ColourValue>()        { return "ColourValue"; }
-    template <> inline std::string _typeToString<Radian>()             { return "Radian"; }
-    template <> inline std::string _typeToString<Degree>()             { return "Degree"; }
-
-    template <class T>
-    inline std::string typeToString() { return _typeToString<typename Loki::TypeTraits<T>::UnqualifiedReferredType>(); }
-
+    inline std::string typeToString() { return detail::_typeToString<typename Loki::TypeTraits<T>::UnqualifiedReferredType>(); }
+
+    /**
+        @brief The Functor classes are used to wrap function pointers.
+
+        Function-pointers in C++ have a pretty complicated syntax and you can't store
+        and call them unless you know the exact type. A Functor can be used to wrap
+        a function-pointer and to store it independent of its type. You can also call
+        it independently of its parameters by passing the arguments as MultiType. They
+        are converted automatically to the right type.
+
+        Functor is a pure virtual base class.
+
+        @see See @ref FunctorExample "Functor.h" for some examples.
+    */
     class _CoreExport Functor
     {
@@ -76,4 +177,5 @@
             struct Type
             {
+                /// Defines the type of a function (static or member)
                 enum Enum
                 {
@@ -84,33 +186,35 @@
 
         public:
+            /// Calls the function-pointer with up to five arguments. In case of a member-function, the assigned object-pointer is used to call the function. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
             virtual MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
 
+            /// Creates a new instance of Functor with the same values like this (used instead of a copy-constructor)
             virtual FunctorPtr clone() = 0;
 
+            /// Returns the type of the function: static or member.
             virtual Type::Enum getType() const = 0;
+            /// Returns the number of parameters of the function.
             virtual unsigned int getParamCount() const = 0;
+            /// Returns true if the function has a return-value.
             virtual bool hasReturnvalue() const = 0;
 
-            virtual std::string getTypenameParam(unsigned int param) const = 0;
+            /// Returns the type-name of the parameter with given index (the first parameter has index 0).
+            virtual std::string getTypenameParam(unsigned int index) const = 0;
+            /// Returns the type-name of the return-value.
             virtual std::string getTypenameReturnvalue() const = 0;
 
-            virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
-
-            virtual void setRawObjectPointer(void* object) {}
-            virtual void* getRawObjectPointer() const { return 0; }
-
-            template <class F>
-            inline bool setFunction(F* function)
-            {
-                if (this->getFullIdentifier() == typeid(F*))
-                {
-                    modifyFunctor(this, function);
-                    return true;
-                }
-                return false;
-            }
-
+            /// Converts a given argument to the type of the parameter with given index (the first parameter has index 0).
+            virtual void evaluateArgument(unsigned int index, MultiType& argument) const = 0;
+
+            /// Assigns an object-pointer to the functor which is used to execute a member-function.
+            virtual void setRawObjectPointer(void* object) = 0;
+            /// Returns the object-pointer.
+            virtual void* getRawObjectPointer() const = 0;
+
+            /// Returns the full identifier of the function-pointer which is defined as typeid(@a F), where @a F is the type of the stored function-pointer. Used to compare functors.
             virtual const std::type_info& getFullIdentifier() const = 0;
+            /// Returns an identifier of the header of the function (doesn't include the function's class). Used to compare functors.
             virtual const std::type_info& getHeaderIdentifier() const = 0;
+            /// Returns an identifier of the header of the function (doesn't include the function's class), but regards only the first @a params parameters. Used to compare functions if an Executor provides default-values for the other parameters.
             virtual const std::type_info& getHeaderIdentifier(unsigned int params) const = 0;
     };
@@ -118,4 +222,5 @@
     namespace detail
     {
+        // helper class to determine if a functor is static or not
         template <class O>
         struct FunctorTypeStatic
@@ -126,14 +231,29 @@
     }
 
+    /**
+        @brief FunctorMember is a child class of Functor and expands it with an object-pointer, that
+        is used for member-functions, as well as an overloaded execution operator.
+
+        @param O The type of the function's class (or void if it's a static function)
+
+        Note that FunctorMember is also used for static functions, but with T = void. FunctorStatic
+        is a typedef of FunctorMember<void>. The void* object-pointer is ignored in this case.
+
+        @see See @ref FunctorExample "Functor.h" for some examples.
+    */
     template <class O>
     class FunctorMember : public Functor
     {
         public:
+            /// Constructor: Stores the object-pointer.
             FunctorMember(O* object = 0) : object_(object) {}
 
+            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
             virtual MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
 
+            // see Functor::operator()()
             MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
             {
+                // call the function if it is static or if an object was assigned
                 if (detail::FunctorTypeStatic<O>::result || this->object_)
                     return (*this)(this->object_, param1, param2, param3, param4, param5);
@@ -145,43 +265,67 @@
             }
 
+            // see Functor::getType()
             Functor::Type::Enum getType() const
                 { return detail::FunctorTypeStatic<O>::result ? Functor::Type::Static : Functor::Type::Member; }
 
+            /// Assigns an object-pointer to the functor which is used to execute a member-function.
             inline void setObject(O* object)
                 { this->object_ = object;}
+            /// Returns the object-pointer.
             inline O* getObject() const
                 { return this->object_; }
 
+            // see Functor::setRawObjectPointer()
             inline void setRawObjectPointer(void* object)
                 { this->object_ = (O*)object; }
+            // see Functor::getRawObjectPointer()
             inline void* getRawObjectPointer() const
                 { return this->object_; }
 
         protected:
-            O* object_;
+            O* object_;     ///< The stored object-pointer, used to execute a member-function (or NULL for static functions)
     };
 
+    /// FunctorStatic is just a typedef of FunctorMember with @a T = void.
     typedef FunctorMember<void> FunctorStatic;
 
+    /**
+        @brief FunctorPointer is a child class of FunctorMember and expands it with a function-pointer.
+        @param F The type of the function-pointer
+        @param O The type of the function's class (or void if it's a static function)
+
+        The template FunctorPointer has an additional template parameter that defines the type
+        of the function-pointer. This can be handy if you want to get or set the function-pointer.
+        You can then use a static_cast to cast a Functor to FunctorPointer if you know the type
+        of the function-pointer.
+
+        However FunctorPointer is not aware of the types of the different parameters or the
+        return value.
+    */
     template <class F, class O = void>
     class FunctorPointer : public FunctorMember<O>
     {
         public:
+            /// Constructor: Initializes the base class and stores the function-pointer.
             FunctorPointer(F functionPointer, O* object = 0) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
 
+            /// Changes the function-pointer.
             inline void setFunction(F functionPointer)
                 { this->functionPointer_ = functionPointer; }
+            /// Returns the function-pointer.
             inline F getFunction() const
                 { return this->functionPointer_; }
 
+            // see Functor::getFullIdentifier()
             const std::type_info& getFullIdentifier() const
                 { return typeid(F); }
 
         protected:
-            F functionPointer_;
+            F functionPointer_;     ///< The stored function-pointer
     };
 
     namespace detail
     {
+        // Helper class to get the type of the function pointer with the given class, parameters, return-value, and constness
         template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctionPointer                                            { typedef R (O::*Type)(P1, P2, P3, P4, P5); };
         template <class R, class O, class P1, class P2, class P3, class P4, class P5>               struct FunctionPointer<R, O, false, P1, P2, P3, P4, P5>           { typedef R (O::*Type)(P1, P2, P3, P4, P5); };
@@ -204,4 +348,5 @@
         template <class R>                                                   struct FunctionPointer<R, void, false, void, void, void, void, void> { typedef R (*Type)(); };
 
+        // Helper class, used to call a function-pointer with a given object and parameters and to return its return-value (if available)
         template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller                                              { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3, param4, param5); } };
         template <class R, class O, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<R, O, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3, param4); } };
@@ -229,8 +374,10 @@
         template <bool isconst>                                                   struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(); return MT_Type::Null; } };
 
+        // Helper class, used to identify the header of a function-pointer (independent of its class)
         template <class R, class P1, class P2, class P3, class P4, class P5>
         struct FunctorHeaderIdentifier
         {};
 
+        // Helper class to determine if a function has a returnvalue
         template <class T>
         struct FunctorHasReturnvalue
@@ -240,4 +387,5 @@
         { enum { result = false }; };
 
+        // Helper class to count the number of parameters
         template <class P1, class P2, class P3, class P4, class P5>
         struct FunctorParamCount
@@ -260,10 +408,32 @@
     }
 
+    /**
+        @brief FunctorTemplate is a child class of FunctorPointer and implements all functions
+        that need to know the exact types of the parameters, return-value, and class.
+
+        @param R The type of the return-value of the function
+        @param O The class of the function
+        @param isconst True if the function is a const member-function
+        @param P1 The type of the first parameter
+        @param P2 The type of the second parameter
+        @param P3 The type of the third parameter
+        @param P4 The type of the fourth parameter
+        @param P5 The type of the fifth parameter
+
+        This template has many parameters and is usually not used directly. It is created by
+        createFunctor(), but only the base-classes Functor, FunctorMember, and FunctorPointer
+        are used directly. It implements all the virtual functions that are declared by its
+        base classes.
+
+        All template arguments can be void.
+    */
     template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5>
     class FunctorTemplate : public FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>
     {
         public:
+            /// Constructor: Initializes the base class.
             FunctorTemplate(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object = 0) : FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>(functionPointer, object) {}
 
+            // see FunctorMember::operator()()
             MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
             {
@@ -271,4 +441,5 @@
             }
 
+            // see Functor::clone()
             FunctorPtr clone()
             {
@@ -276,16 +447,18 @@
             }
 
-            void evaluateParam(unsigned int index, MultiType& param) const
+            // see Functor::evaluateArgument()
+            void evaluateArgument(unsigned int index, MultiType& argument) const
             {
                 switch (index)
                 {
-                    case 0: param.convert<P1>(); break;
-                    case 1: param.convert<P2>(); break;
-                    case 2: param.convert<P3>(); break;
-                    case 3: param.convert<P4>(); break;
-                    case 4: param.convert<P5>(); break;
+                    case 0: argument.convert<P1>(); break;
+                    case 1: argument.convert<P2>(); break;
+                    case 2: argument.convert<P3>(); break;
+                    case 3: argument.convert<P4>(); break;
+                    case 4: argument.convert<P5>(); break;
                 }
             }
 
+            // see Functor::getParamCount()
             unsigned int getParamCount() const
             {
@@ -293,4 +466,5 @@
             }
 
+            // see Functor::hasReturnvalue()
             bool hasReturnvalue() const
             {
@@ -298,7 +472,8 @@
             }
 
-            std::string getTypenameParam(unsigned int param) const
-            {
-                switch (param)
+            // see Functor::getTypenameParam()
+            std::string getTypenameParam(unsigned int index) const
+            {
+                switch (index)
                 {
                     case 0:  return typeToString<P1>();
@@ -311,4 +486,5 @@
             }
 
+            // see Functor::getTypenameReturnvalue()
             std::string getTypenameReturnvalue() const
             {
@@ -316,4 +492,5 @@
             }
 
+            // see Functor::getHeaderIdentifier()
             const std::type_info& getHeaderIdentifier() const
             {
@@ -321,4 +498,5 @@
             }
 
+            // see Functor::getHeaderIdentifier(unsigned int)
             const std::type_info& getHeaderIdentifier(unsigned int params) const
             {
@@ -335,36 +513,36 @@
     };
 
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5), OO* object) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer, object); }
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4), OO* object)     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer, object); }
-    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3), OO* object)         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer, object); }
-    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2), OO* object)             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer, object); }
-    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1), OO* object)                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer, object); }
-    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(), OO* object)                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer, object); }
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const, OO* object) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer, object); }
-    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const, OO* object)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer, object); }
-    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const, OO* object)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer, object); }
-    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const, OO* object)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer, object); }
-    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const, OO* object)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer, object); }
-    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const, OO* object)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer, object); }
-
-    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer); }
-    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer); }
-    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer); }
-    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2))             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer); }
-    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1))                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer); }
-    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)())                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer); }
-    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer); }
-    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer); }
-    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer); }
-    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer); }
-    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer); }
-    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer); }
-
-    template <class R, class P1, class P2, class P3, class P4, class P5> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>(functionPointer); }
-    template <class R, class P1, class P2, class P3, class P4>           inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, void>(functionPointer); }
-    template <class R, class P1, class P2, class P3>                     inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, void, false, P1, P2, P3, void, void>(functionPointer); }
-    template <class R, class P1, class P2>                               inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2))             { return new FunctorTemplate<R, void, false, P1, P2, void, void, void>(functionPointer); }
-    template <class R, class P1>                                         inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1))                 { return new FunctorTemplate<R, void, false, P1, void, void, void, void>(functionPointer); }
-    template <class R>                                                   inline FunctorStaticPtr createFunctor(R (*functionPointer)())                   { return new FunctorTemplate<R, void, false, void, void, void, void, void>(functionPointer); }
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5), OO* object) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4), OO* object)     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3), OO* object)         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2), OO* object)             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1), OO* object)                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(), OO* object)                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const, OO* object) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const, OO* object)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const, OO* object)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const, OO* object)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const, OO* object)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+    template <class R, class O, class OO>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const, OO* object)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer, object); }   ///< Creates a new FunctorMember with the given function-pointer and an assigned object
+
+    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, O, false, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, O, false, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2))             { return new FunctorTemplate<R, O, false, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1))                 { return new FunctorTemplate<R, O, false, P1, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)())                   { return new FunctorTemplate<R, O, false, void, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3, class P4, class P5> inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4, P5) const) { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3, class P4>           inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3, P4) const)     { return new FunctorTemplate<R, O, true, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2, class P3>                     inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2, P3) const)         { return new FunctorTemplate<R, O, true, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1, class P2>                               inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1, P2) const)             { return new FunctorTemplate<R, O, true, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O, class P1>                                         inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)(P1) const)                 { return new FunctorTemplate<R, O, true, P1, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+    template <class R, class O>                                                   inline FunctorMemberPtr<O> createFunctor(R (O::*functionPointer)() const)                   { return new FunctorTemplate<R, O, true, void, void, void, void, void>(functionPointer); }   ///< Creates a new FunctorMember with the given function-pointer
+
+    template <class R, class P1, class P2, class P3, class P4, class P5> inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4, P5)) { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, P5>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1, class P2, class P3, class P4>           inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3, P4))     { return new FunctorTemplate<R, void, false, P1, P2, P3, P4, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1, class P2, class P3>                     inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2, P3))         { return new FunctorTemplate<R, void, false, P1, P2, P3, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1, class P2>                               inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1, P2))             { return new FunctorTemplate<R, void, false, P1, P2, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R, class P1>                                         inline FunctorStaticPtr createFunctor(R (*functionPointer)(P1))                 { return new FunctorTemplate<R, void, false, P1, void, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
+    template <class R>                                                   inline FunctorStaticPtr createFunctor(R (*functionPointer)())                   { return new FunctorTemplate<R, void, false, void, void, void, void, void>(functionPointer); }   ///< Creates a new Functor with the given function-pointer
 }
 
Index: code/trunk/src/libraries/core/command/FunctorPtr.h
===================================================================
--- code/trunk/src/libraries/core/command/FunctorPtr.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/FunctorPtr.h	(revision 7401)
@@ -27,4 +27,24 @@
  */
 
+/**
+    @file
+    @ingroup Command FunctorExecutor
+    @brief Typedefs and definitions of FunctorPtr, FunctorMemberPtr, FunctorStaticPtr, and FunctorPointerPtr
+
+    Instances of orxonox::Functor are usually managed by an orxonox::SharedPtr. This ensures
+    that Functors will be destroyed after usage. To make things easier, there's a typedef
+    that defines FunctorPtr as SharedPtr<Functor>.
+
+    Because there's not only orxonox::Functor, but also orxonox::FunctorStatic, and
+    orxonox::FunctorMember, the shared pointers need to store them all and also reflect
+    their hierarchy - FunctorStatic and FunctorMember should not be mixed, but both can
+    be converted to Functor. This is achieved by using orxonox::SharedChildPtr.
+
+    Because it's not possible to use a typedef for a template, we have to define the
+    helper class FunctorMemberPtr<T> that makes it easier to use FunctorMember. The
+    same is also done for FunctorPointerPtr<T>, which can be converted to both,
+    FunctorMemberPtr<T> as well as FunctorPtr.
+*/
+
 #ifndef _FunctorPtr_H__
 #define _FunctorPtr_H__
@@ -35,6 +55,8 @@
 namespace orxonox
 {
+    /// FunctorPtr is just a typedef of SharedPtr
     typedef SharedPtr<Functor> FunctorPtr;
 
+    /// It's not possible to use a typedef for FunctorMemberPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
     template <class T>
     class FunctorMemberPtr : public SharedChildPtr<FunctorMember<T>, FunctorPtr>
@@ -46,6 +68,8 @@
     };
 
+    /// FunctorStaticPtr is just FunctorMemberPtr with @a T = void
     typedef FunctorMemberPtr<void> FunctorStaticPtr;
 
+    /// It's not possible to use a typedef for FunctorPointerPtr<T>, so we have to create a child-class instead. It inherits all functions from SharedChildPtr, but needs to (re-)implement some constructors.
     template <class F, class T>
     class FunctorPointerPtr : public SharedChildPtr<FunctorPointer<F, T>, FunctorMemberPtr<T> >
Index: code/trunk/src/libraries/core/command/IOConsole.h
===================================================================
--- code/trunk/src/libraries/core/command/IOConsole.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/IOConsole.h	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @ingroup Command ShellConsole
+*/
+
 #include "OrxonoxConfig.h"
 
Index: code/trunk/src/libraries/core/command/IOConsolePOSIX.h
===================================================================
--- code/trunk/src/libraries/core/command/IOConsolePOSIX.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/IOConsolePOSIX.h	(revision 7401)
@@ -27,4 +27,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup Command ShellConsole
+*/
 
 #ifndef _IOConsole_H__
Index: code/trunk/src/libraries/core/command/IOConsoleWindows.h
===================================================================
--- code/trunk/src/libraries/core/command/IOConsoleWindows.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/IOConsoleWindows.h	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @ingroup Command ShellConsole
+*/
 
 #ifndef _IOConsole_H__
Index: code/trunk/src/libraries/core/command/IRC.cc
===================================================================
--- code/trunk/src/libraries/core/command/IRC.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/IRC.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Implementation of the IRC class and the IRC console commands.
+*/
+
 #include "IRC.h"
 
@@ -39,5 +44,5 @@
 namespace orxonox
 {
-    static const unsigned int IRC_TCL_THREADID  = 1421421421;
+    static const unsigned int IRC_TCL_THREADID  = 1421421421;   ///< The ID of the thread in TclThreadManager that is used for the IRC connection
 
     SetConsoleCommand("IRC", "say",  &IRC::say);
@@ -45,4 +50,18 @@
     SetConsoleCommand("IRC", "nick", &IRC::nick);
 
+    /**
+        @brief Returns the only existing instance of IRC.
+    */
+    IRC& IRC::getInstance()
+    {
+        static IRC instance;
+        return instance;
+    }
+
+    /**
+        @brief Constructor: Doesn't yet connect to IRC nor does it create a Tcl interpreter.
+        The IRC object will automatically connect to the IRC server if one of the registered
+        console commands is used the first time.
+    */
     IRC::IRC()
     {
@@ -50,4 +69,7 @@
     }
 
+    /**
+        @brief Creates and initializes a new multithreaded Tcl-interpreter and defines some callbacks to display IRC-messages in the console.
+    */
     void IRC::initialize()
     {
@@ -70,10 +92,7 @@
     }
 
-    IRC& IRC::getInstance()
-    {
-        static IRC instance;
-        return instance;
-    }
-
+    /**
+        @brief Executes a Tcl-command on the Tcl-interpreter.
+    */
     bool IRC::eval(const std::string& command)
     {
@@ -96,4 +115,5 @@
     }
 
+    /// Console command: Sends a message to the current channel on the IRC server.
     void IRC::say(const std::string& message)
     {
@@ -102,4 +122,5 @@
     }
 
+    /// Console command: Sends a message to a given channel or nickname on the IRC server.
     void IRC::msg(const std::string& channel, const std::string& message)
     {
@@ -108,4 +129,5 @@
     }
 
+    /// Console command: Changes the nickname on the IRC server.
     void IRC::nick(const std::string& nickname)
     {
@@ -114,4 +136,5 @@
     }
 
+    /// Tcl-callback: Prints a message that was received from the current IRC channel to the console.
     void IRC::tcl_say(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
     {
@@ -119,4 +142,5 @@
     }
 
+    /// Tcl-callback: Prints a private message that was received from a user to the console.
     void IRC::tcl_privmsg(Tcl::object const &query, Tcl::object const &nick, Tcl::object const &args)
     {
@@ -124,4 +148,5 @@
     }
 
+    /// Tcl-callback: Prints an action-message (usually /me ...) that was received from the current IRC channel to the console.
     void IRC::tcl_action(Tcl::object const &channel, Tcl::object const &nick, Tcl::object const &args)
     {
@@ -129,4 +154,5 @@
     }
 
+    /// Tcl-callback: Prints all kinds of information that were received from the IRC server or channel (connection info, join, part, modes, ...) to the console.
     void IRC::tcl_info(Tcl::object const &channel, Tcl::object const &args)
     {
Index: code/trunk/src/libraries/core/command/IRC.h
===================================================================
--- code/trunk/src/libraries/core/command/IRC.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/IRC.h	(revision 7401)
@@ -27,4 +27,10 @@
  */
 
+/**
+    @file
+    @ingroup Command Tcl
+    @brief Declaration of IRC helper class, used for IRC connections using Tcl.
+*/
+
 #ifndef _IRC_H__
 #define _IRC_H__
@@ -36,4 +42,8 @@
 namespace orxonox
 {
+    /**
+        @brief The IRC class creates a Tcl-thread (see TclThreadManager) and connects to an IRC server.
+        It provides different console commands to send messages and to perform other actions on the IRC server.
+    */
     class _CoreExport IRC
     {
@@ -55,9 +65,9 @@
 
             IRC();
-            IRC(const IRC& other);
-            ~IRC() {}
+            IRC(const IRC& other);              ///< Copy-constructor: Not implemented
+            ~IRC() {}                           ///< Destructor
 
-            Tcl::interpreter* interpreter_;
-            std::string nickname_;
+            Tcl::interpreter* interpreter_;     ///< The Tcl interpreter that is used for the IRC connection
+            std::string nickname_;              ///< The user's nickname on the IRC server
     };
 }
Index: code/trunk/src/libraries/core/command/Shell.cc
===================================================================
--- code/trunk/src/libraries/core/command/Shell.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/Shell.cc	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @brief Implementation of the Shell class.
+*/
 
 #include "Shell.h"
@@ -48,4 +53,9 @@
     unsigned int Shell::cacheSize_s;
 
+    /**
+        @brief Constructor: Initializes the values and registers itself at OutputHandler.
+        @param consoleName The name of the shell - used to define the name of the soft-debug-level config-value
+        @param bScrollable If true, the user is allowed to scroll through the output-lines
+    */
     Shell::Shell(const std::string& consoleName, bool bScrollable)
         : OutputListener(consoleName)
@@ -88,4 +98,7 @@
     }
 
+    /**
+        @brief Destructor: Unregisters the shell from OutputHandler.
+    */
     Shell::~Shell()
     {
@@ -94,4 +107,7 @@
     }
 
+    /**
+        @brief Defines the config values.
+    */
     void Shell::setConfigValues()
     {
@@ -113,4 +129,7 @@
     }
 
+    /**
+        @brief Config-value callback: Called when the history offset has changed in the config-file.
+    */
     void Shell::commandHistoryOffsetChanged()
     {
@@ -119,4 +138,7 @@
     }
 
+    /**
+        @brief Config-value callback: Called when the length of the command history has changed in the config-file.
+    */
     void Shell::commandHistoryLengthChanged()
     {
@@ -131,4 +153,7 @@
     }
 
+    /**
+        @brief Registers this object as listener for different key-events at the input buffer.
+    */
     void Shell::configureInputBuffer()
     {
@@ -159,16 +184,7 @@
     }
 
-    /*
-    void Shell::history()
-    {
-        Shell& instance = Shell::getInstance();
-
-        for (unsigned int i = instance.historyOffset_; i < instance.commandHistory_.size(); ++i)
-            instance.addOutput(instance.commandHistory_[i] + '\n', -1);
-        for (unsigned int i =  0; i < instance.historyOffset_; ++i)
-            instance.addOutput(instance.commandHistory_[i] + '\n', -1);
-    }
-    */
-
+    /**
+        @brief Registers a shell listener which listens for changes in this shell.
+    */
     void Shell::registerListener(ShellListener* listener)
     {
@@ -176,4 +192,7 @@
     }
 
+    /**
+        @brief Unregisters a shell listener.
+    */
     void Shell::unregisterListener(ShellListener* listener)
     {
@@ -187,4 +206,7 @@
     }
 
+    /**
+        @brief Changes the position of the cursor in the input buffer.
+    */
     void Shell::setCursorPosition(unsigned int cursor)
     {
@@ -193,4 +215,7 @@
     }
 
+    /**
+        @brief Sends output to the internal output buffer.
+    */
     void Shell::addOutput(const std::string& text, LineType type)
     {
@@ -199,4 +224,7 @@
     }
 
+    /**
+        @brief Clears the list of output-lines.
+    */
     void Shell::clearOutput()
     {
@@ -210,4 +238,7 @@
     }
 
+    /**
+        @brief Returns an iterator to the newest line of output (except if the user is currently scrolling through the output).
+    */
     Shell::LineList::const_iterator Shell::getNewestLineIterator() const
     {
@@ -218,4 +249,7 @@
     }
 
+    /**
+        @brief Returns the end() iterator of the list of output-lines.
+    */
     Shell::LineList::const_iterator Shell::getEndIterator() const
     {
@@ -223,4 +257,7 @@
     }
 
+    /**
+        @brief Adds a command to the history of entered commands and writes it to the config-file.
+    */
     void Shell::addToHistory(const std::string& command)
     {
@@ -237,4 +274,7 @@
     }
 
+    /**
+        @brief Returns a command from the history of entered commands (usually the most recent history entry, but the user can scroll through the history).
+    */
     const std::string& Shell::getFromHistory() const
     {
@@ -246,4 +286,7 @@
     }
 
+    /**
+        @brief Called by OutputHandler or internally whenever output was sent to the output buffer. Reads from the buffer and writes the new output-lines to the list.
+    */
     void Shell::outputChanged(int lineType)
     {
@@ -251,28 +294,34 @@
         do
         {
+            // get the first line from the buffer
             std::string output;
             std::getline(this->outputBuffer_, output);
 
+            // check the state of the buffer
             bool eof = this->outputBuffer_.eof();
             bool fail = this->outputBuffer_.fail();
             if (eof)
-                this->outputBuffer_.flush();
+                this->outputBuffer_.flush(); // check if more output was received in the meantime
             if (eof || fail)
-                this->outputBuffer_.clear();
+                this->outputBuffer_.clear(); // clear the error flags
+
+            // the line is terminated with a line-break if neither an error occurred nor the end of the file was reached
             newline = (!eof && !fail);
 
+            // no output retrieved - break the loop
             if (!newline && output.empty())
                 break;
 
+            // check if the last line was terminated with a line-break
             if (this->bFinishedLastLine_)
             {
+                // yes it was - push the new line to the list
                 this->outputLines_.push_front(std::make_pair(output, static_cast<LineType>(lineType)));
 
+                // adjust the scroll position if needed
                 if (this->scrollPosition_)
                     this->scrollPosition_++;
                 else
                     this->scrollIterator_ = this->outputLines_.begin();
-
-                this->bFinishedLastLine_ = newline;
 
                 if (!this->scrollPosition_)
@@ -281,13 +330,18 @@
             else
             {
+                // no it wasn't - add the new output to the last line
                 this->outputLines_.front().first += output;
-                this->bFinishedLastLine_ = newline;
                 this->updateListeners<&ShellListener::onlyLastLineChanged>();
             }
+
+            // remember if the last line was terminated with a line-break
             this->bFinishedLastLine_ = newline;
 
-        } while (newline);
-    }
-
+        } while (newline); // loop as long as more lines are in the buffer
+    }
+
+    /**
+        @brief Clears the text in the input buffer.
+    */
     void Shell::clearInput()
     {
@@ -298,8 +352,4 @@
     }
 
-    void Shell::setPromptPrefix(const std::string& str)
-    {
-    }
-
 
     // ##########################################
@@ -307,4 +357,5 @@
     // ##########################################
 
+    /// InputBuffer callback: Called if the input changes.
     void Shell::inputChanged()
     {
@@ -313,4 +364,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that executes a command (usually [return]).
     void Shell::execute()
     {
@@ -340,4 +392,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that shows hints and completes a command (usually [tab]).
     void Shell::hintAndComplete()
     {
@@ -349,4 +402,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that deletes the character before the cursor (usually [backspace]).
     void Shell::backspace()
     {
@@ -356,19 +410,5 @@
     }
 
-    void Shell::exit()
-    {
-        if (this->inputBuffer_->getSize() > 0)
-        {
-            this->clearInput();
-            return;
-        }
-
-        this->clearInput();
-        this->scrollPosition_ = 0;
-        this->scrollIterator_ = this->outputLines_.begin();
-
-        this->updateListeners<&ShellListener::exit>();
-    }
-
+    /// InputBuffer callback: Called if a key was pressed that deletes the character after the cursor (usually [delete]).
     void Shell::deleteChar()
     {
@@ -377,4 +417,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that moves the input cursor the right (usually [arrow right]).
     void Shell::cursorRight()
     {
@@ -383,4 +424,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that moves the input cursor the left (usually [arrow left]).
     void Shell::cursorLeft()
     {
@@ -389,4 +431,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that moves the input cursor the end of the input line (usually [end]).
     void Shell::cursorEnd()
     {
@@ -395,4 +438,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that moves the input cursor the beginning of the input line (usually [home]).
     void Shell::cursorHome()
     {
@@ -401,4 +445,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that scrolls upwards through the history of entered commands (usually [arrow up]).
     void Shell::historyUp()
     {
@@ -410,4 +455,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that scrolls downwards through the history of entered commands (usually [arrow down]).
     void Shell::historyDown()
     {
@@ -419,4 +465,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that searches upwards through the history for a command stat starts like the one the user is currently typing (usually [page up]). Only if the shell is not scrollable.
     void Shell::historySearchUp()
     {
@@ -437,4 +484,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that searches downwards through the history for a command stat starts like the one the user is currently typing (usually [page down]). Only if the shell is not scrollable.
     void Shell::historySearchDown()
     {
@@ -455,4 +503,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that scrolls upwards through the output history (usually [page up]). Only if the shell is scrollable.
     void Shell::scrollUp()
     {
@@ -466,4 +515,5 @@
     }
 
+    /// InputBuffer callback: Called if a key was pressed that scrolls downwards through the output history (usually [page down]). Only if the shell is scrollable.
     void Shell::scrollDown()
     {
@@ -476,3 +526,19 @@
         }
     }
+
+    /// InputBuffer callback: Called if a key was pressed that clears the text in the input buffer or closes the shell (usually [esc]).
+    void Shell::exit()
+    {
+        if (this->inputBuffer_->getSize() > 0)
+        {
+            this->clearInput();
+            return;
+        }
+
+        this->clearInput();
+        this->scrollPosition_ = 0;
+        this->scrollIterator_ = this->outputLines_.begin();
+
+        this->updateListeners<&ShellListener::exit>();
+    }
 }
Index: code/trunk/src/libraries/core/command/Shell.h
===================================================================
--- code/trunk/src/libraries/core/command/Shell.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/Shell.h	(revision 7401)
@@ -27,4 +27,15 @@
  */
 
+/**
+    @defgroup ShellConsole Shell and console
+    @ingroup Command
+*/
+
+/**
+    @file
+    @ingroup Command ShellConsole
+    @brief Declaration of the Shell and ShellListener classes.
+*/
+
 #ifndef _Shell_H__
 #define _Shell_H__
@@ -43,4 +54,7 @@
 namespace orxonox
 {
+    /**
+        @brief An interface, used to get a notification if the state of the Shell changes.
+    */
     class _CoreExport ShellListener
     {
@@ -51,17 +65,28 @@
 
         private:
-            virtual void linesChanged() {}
-            virtual void onlyLastLineChanged() {}
-            virtual void lineAdded() {}
-            virtual void inputChanged() {}
-            virtual void cursorChanged() {}
-            virtual void executed() {}
-            virtual void exit() {}
+            virtual void linesChanged() {}          ///< Called if all output-lines have changed
+            virtual void onlyLastLineChanged() {}   ///< Called if only the last output-line has changed
+            virtual void lineAdded() {}             ///< Called if a new line was added to the output
+            virtual void inputChanged() {}          ///< Called if the input has changed
+            virtual void cursorChanged() {}         ///< Called if the cursor in the input line has changed
+            virtual void executed() {}              ///< Called if a command from the input line was executed
+            virtual void exit() {}                  ///< Called if the console should be closed
     };
 
 
+    /**
+        @brief The Shell is the logical component of the console that displays output to the user and allows him to enter commands.
+
+        The Shell gathers output sent from OutputHandler by inheriting from OutputListener.
+        The output-lines are stored in the shell, so they can be displayed in a graphical
+        console. Additionally the Shell has an InputBuffer which is needed by the user to
+        enter commands.
+
+        Different graphical consoles build upon a Shell, for example InGameConsole and IOConsole.
+    */
     class _CoreExport Shell : virtual public OrxonoxClass, public OutputListener
     {
         public:
+            /// Defines the type of a line of text in the Shell - some types depend on the output level, others are of internal use.
             enum LineType
             {
@@ -88,11 +113,14 @@
             void unregisterListener(ShellListener* listener);
 
+            /// Returns the input buffer which is needed by the user to enter text into the shell.
             inline InputBuffer* getInputBuffer()
                 { return this->inputBuffer_; }
 
             void setCursorPosition(unsigned int cursor);
+            /// Returns the current position of the cursor in the input buffer.
             inline unsigned int getCursorPosition() const
                 { return this->inputBuffer_->getCursorPosition(); }
 
+            /// Returns the current content of the input buffer (the text which was entered by the user)
             inline const std::string& getInput() const
                 { return this->inputBuffer_->get(); }
@@ -105,12 +133,12 @@
             void clearOutput();
 
+            /// Returns the number of output-lines that are displayed in the shell.
             inline unsigned int getNumLines() const
                 { return this->outputLines_.size(); }
+            /// Returns the line which is currently viewed if the user scrolls through the older output-lines in the shell.
             inline unsigned int getScrollPosition() const
                 { return this->scrollPosition_; }
 
-            inline const std::string& getPromptPrefix() const { return this->promptPrefix_; }
-            void setPromptPrefix(const std::string& str);
-
+            /// Returns the cache size that is actually used in CommandExecutor, but placed here for better readability of the config file.
             static inline unsigned int getCacheSize()
                 { return Shell::cacheSize_s; }
@@ -145,4 +173,5 @@
             void exit();
 
+            /// Iterates through all registered @ref ShellListener "shell listeners" and calls the function @a F.
             template <void (ShellListener::*F)()>
             void updateListeners()
@@ -152,23 +181,22 @@
             }
 
-            std::list<ShellListener*> listeners_;
-            InputBuffer*              inputBuffer_;
-            std::stringstream         outputBuffer_;
-            bool                      bFinishedLastLine_;
-            LineList                  outputLines_;
-            LineList::const_iterator  scrollIterator_;
-            unsigned int              scrollPosition_;
-            unsigned int              historyPosition_;
-
-            std::string               promptPrefix_;
-            const std::string         consoleName_;
-            const bool                bScrollable_;
+            std::list<ShellListener*> listeners_;           ///< The registered shell listeners
+            InputBuffer*              inputBuffer_;         ///< The input buffer that is needed by the user to enter text
+            std::stringstream         outputBuffer_;        ///< The output buffer that is used to retrieve lines of output from OutputListener
+            bool                      bFinishedLastLine_;   ///< Stores if the most recent output-line was terminated with a line-break or if more output is expected for this line
+            LineList                  outputLines_;         ///< A list of all output-lines that were displayed in the shell so far
+            LineList::const_iterator  scrollIterator_;      ///< An iterator to an entry of the list of output-lines, changes if the user scrolls through the output in the shell
+            unsigned int              scrollPosition_;      ///< The number of the line that is currently being referenced by scrollIterator_
+            unsigned int              historyPosition_;     ///< If the user scrolls through the history of entered commands (stored in commandHistory_), this contains the currently viewed history entry
+
+            const std::string         consoleName_;         ///< The name of this shell - used to define the name of the soft-debug-level config-value
+            const bool                bScrollable_;         ///< If true, the user can scroll through the output-lines
 
             // Config values
-            unsigned int              maxHistoryLength_;
-            unsigned int              historyOffset_;
-            std::vector<std::string>  commandHistory_;
-            int                       softDebugLevel_;
-            static unsigned int       cacheSize_s;
+            unsigned int              maxHistoryLength_;    ///< The maximum number of saved commands
+            unsigned int              historyOffset_;       ///< The command history is a circular buffer, this variable defines the current write-offset
+            std::vector<std::string>  commandHistory_;      ///< The history of commands that were entered by the user
+            int                       softDebugLevel_;      ///< The maximum level of output that is displayed in the shell (will be passed to OutputListener to filter output)
+            static unsigned int       cacheSize_s;          ///< The maximum cache size of the CommandExecutor - this is stored here for better readability of the config file and because CommandExecutor is no OrxonoxClass
     };
 }
Index: code/trunk/src/libraries/core/command/TclBind.cc
===================================================================
--- code/trunk/src/libraries/core/command/TclBind.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/TclBind.cc	(revision 7401)
@@ -49,4 +49,8 @@
     TclBind* TclBind::singletonPtr_s = 0;
 
+    /**
+        @brief Constructor: Initializes the Tcl-interpreter with a given data path.
+        @param datapath Path to the directory that contains the Orxonox-specific Tcl-files
+    */
     TclBind::TclBind(const std::string& datapath)
     {
@@ -56,4 +60,7 @@
     }
 
+    /**
+        @brief Destructor: Deletes the Tcl-interpreter.
+    */
     TclBind::~TclBind()
     {
@@ -62,4 +69,7 @@
     }
 
+    /**
+        @brief Defines the path to the directory that contains the Orxonox-specific Tcl-files and initializes the Tcl-interpreter accordingly.
+    */
     void TclBind::setDataPath(const std::string& datapath)
     {
@@ -71,4 +81,7 @@
     }
 
+    /**
+        @brief Creates and initializes the Tcl-interpreter by registering all callbacks and defining some useful functions.
+    */
     void TclBind::initializeTclInterpreter()
     {
@@ -96,4 +109,8 @@
     }
 
+    /**
+        @brief Creates and initializes a new Tcl-interpreter and calls the Orxonox-specific
+        init.tcl script that defines some special functions which are required by Orxonox.
+    */
     Tcl::interpreter* TclBind::createTclInterpreter()
     {
@@ -116,4 +133,7 @@
     }
 
+    /**
+        @brief Returns the path to the Tcl-library (not the Orxonox-specific Tcl-files).
+    */
     std::string TclBind::getTclLibraryPath()
     {
@@ -128,4 +148,7 @@
     }
 
+    /**
+        @brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor and to send its result back to Tcl.
+    */
     std::string TclBind::tcl_query(Tcl::object const &args)
     {
@@ -151,4 +174,7 @@
     }
 
+    /**
+        @brief Callback: Used to send an Orxonox-command from Tcl to the CommandExecutor.
+    */
     void TclBind::tcl_execute(Tcl::object const &args)
     {
@@ -162,4 +188,8 @@
     }
 
+    /**
+        @brief Console command, executes Tcl code. Can be used to bind Tcl-commands to a key, because native
+        Tcl-commands can not be evaluated and are thus not supported by the key-binder.
+    */
     std::string TclBind::tcl(const std::string& tclcode)
     {
@@ -182,4 +212,8 @@
     }
 
+    /**
+        @brief Console command and implementation of the Tcl-feature "bgerror" which is called if an error
+        occurred in the background of a Tcl-script.
+    */
     void TclBind::bgerror(const std::string& error)
     {
@@ -187,4 +221,10 @@
     }
 
+    /**
+        @brief Executes Tcl-code and returns the return-value.
+        @param tclcode A string that contains Tcl-code
+        @param error A pointer to an integer (or NULL) that is used to write an error-code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
+        @return Returns the return-value of the executed code (or an empty string if there's no return-value)
+    */
     std::string TclBind::eval(const std::string& tclcode, int* error)
     {
@@ -194,4 +234,5 @@
         try
         {
+            // execute the code
             return TclBind::getInstance().interpreter_->eval(tclcode);
         }
Index: code/trunk/src/libraries/core/command/TclBind.h
===================================================================
--- code/trunk/src/libraries/core/command/TclBind.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/TclBind.h	(revision 7401)
@@ -27,4 +27,53 @@
  */
 
+/**
+    @defgroup Tcl Tcl
+    @ingroup Command
+*/
+
+/**
+    @file
+    @ingroup Command Tcl
+    @brief Declaration of the TclBind class.
+
+    @anchor TclBindExample
+
+    orxonox::TclBind is a wrapper class for a Tcl interpreter. It is implemented as
+    singleton, so it can be accessed by everyone, but all share the same static
+    Tcl interpreter. If you need a Tcl interpreter at your own, see orxonox::TclThreadManager
+    for more information.
+
+    orxonox::TclBind is used by orxonox::CommandExecutor to execute Tcl commands. It can
+    also be used to execute Tcl commands from different sources, but note that they may
+    interfer with the ingame console if used improperly. By no means execute blocking
+    commands such as endless loops or the tcl command @c vwait. Use orxonox::TclThreadManager
+    and execute these commands in a multithreaded Tcl interpreter instead.
+
+    TclBind also defines different callback functions to return commands from the
+    Tcl interpreter back to Orxonox. Because of that it's possible to send a mixture
+    of Orxonox- and Tcl-commands to TclBind::eval() and still get the desired behavior.
+
+    Example:
+    @code
+    TclBind::eval("puts \"Hello World\"");                              // calls the tcl command "puts", prints "Hello World" to the console
+    TclBind::eval("log Hello World");                                   // calls the orxonox command "log", prints "Hello World" to the console
+
+    TclBind::eval("log [expr 1+1]");                                    // prints "2" to the console (which is the result of the tcl command "expr")
+
+    TclBind::eval("puts -nonewline Hello; log World");                  // prints "HelloWorld" to the console
+
+    TclBind::eval("for {set i 0} {$i < 10} {incr i} {log test: $i}");   // prints "test: 0", ..., "test: 9" to the console
+    @endcode
+
+    Note that @c puts and @c log behave slightly different, even though both can print
+    text to the console. @c puts needs quotation marks around multi-word output, while
+    @c log doesn't. @c puts on the other hand supports the flag @c -nonewline.
+
+    TclBind::eval() can also be used to obtain the return-value of a Tcl command:
+    @code
+    std::string result = TclBind::eval("expr 1+1");                     // result == "2"
+    @endcode
+*/
+
 #ifndef _TclBind_H__
 #define _TclBind_H__
@@ -38,4 +87,13 @@
 namespace orxonox
 {
+    /**
+        @brief A wrapper class for a Tcl interpreter. Used to execute Tcl commands.
+
+        TclBind is used to execute Tcl commands, for example if sent to CommandExecutor::execute().
+        It also defines different callbacks for Tcl, which allows to combine Orxonox-console-commands
+        and Tcl-function without problems.
+
+        @see See @ref TclBindExample "TclBind.h" for more information and an example.
+    */
     class _CoreExport TclBind : public Singleton<TclBind>
     {
@@ -49,10 +107,14 @@
 
             void setDataPath(const std::string& datapath);
-            const std::string& getTclDataPath() const { return this->tclDataPath_; }
             static std::string getTclLibraryPath();
+            /// Returns the path to the Orxonox-specific Tcl-files.
+            inline const std::string& getTclDataPath() const
+                { return this->tclDataPath_; }
 
             void initializeTclInterpreter();
             static Tcl::interpreter* createTclInterpreter();
-            Tcl::interpreter* getTclInterpreter() const { return this->interpreter_; }
+            /// Returns the Tcl-interpreter
+            inline Tcl::interpreter* getTclInterpreter() const
+                { return this->interpreter_; }
 
             static std::string tcl_query(Tcl::object const &args);
@@ -62,11 +124,11 @@
 
         private:
-            TclBind(const TclBind& other);
+            TclBind(const TclBind& other);      ///< Copy-constructor, not implemented
 
-            Tcl::interpreter* interpreter_;
-            std::string tclDataPath_;
-            bool bSetTclDataPath_;
+            Tcl::interpreter* interpreter_;     ///< The wrapped Tcl interpreter
+            std::string tclDataPath_;           ///< The path to the directory that contains the Orxonox-specific Tcl-files
+            bool bSetTclDataPath_;              ///< True if tclDataPath_ was defined (after a call to setDataPath())
 
-            static TclBind* singletonPtr_s;
+            static TclBind* singletonPtr_s;     ///< The singleton pointer
     };
 }
Index: code/trunk/src/libraries/core/command/TclThreadList.h
===================================================================
--- code/trunk/src/libraries/core/command/TclThreadList.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/TclThreadList.h	(revision 7401)
@@ -27,4 +27,10 @@
  */
 
+/**
+    @file
+    @ingroup Command Tcl
+    @brief Definition of TclThreadList.
+*/
+
 #ifndef _TclThreadList_H__
 #define _TclThreadList_H__
@@ -40,4 +46,7 @@
 namespace orxonox
 {
+    /**
+        @brief A thread-safe implementation of a message queue, used by TclThreadManager.
+    */
     template <class T>
     class TclThreadList
@@ -71,5 +80,5 @@
 
             /**
-                @brief Returns a reference to the mutex which might be useful if you want to iterate through the list (see @ref begin and @ref end).
+                @brief Returns a reference to the mutex which might be useful if you want to iterate through the list (see @ref getList()).
             */
             inline boost::shared_mutex& getMutex() const
Index: code/trunk/src/libraries/core/command/TclThreadManager.cc
===================================================================
--- code/trunk/src/libraries/core/command/TclThreadManager.cc	(revision 7380)
+++ code/trunk/src/libraries/core/command/TclThreadManager.cc	(revision 7401)
@@ -26,4 +26,9 @@
  *
  */
+
+/**
+    @file
+    @brief Implementation of TclThreadManager.
+*/
 
 #include "TclThreadManager.h"
@@ -251,5 +256,5 @@
     void TclThreadManager::initialize(TclInterpreterBundle* bundle)
     {
-        const std::string& id_string = getConvertedValue<unsigned int, std::string>(bundle->id_);
+        const std::string& id_string = multi_cast<std::string>(bundle->id_);
 
         // Initialize the new interpreter
@@ -303,5 +308,5 @@
     /**
         @brief Sends a command to the queue of a given Tcl-interpreter
-        @param id The id of the target interpreter
+        @param target_id The id of the target interpreter
         @param command The command to be sent
     */
@@ -326,4 +331,5 @@
         @brief This function can be called from Tcl to send a command to the queue of any interpreter.
         @param target_id The id of the target thread
+        @param args Contains the content of the command
     */
     void TclThreadManager::tcl_crossexecute(int target_id, const Tcl::object& args)
@@ -334,5 +340,5 @@
     /**
         @brief Sends a command to the queue of a given Tcl-interpreter
-        @param id The id of the target interpreter
+        @param target_id The id of the target interpreter
         @param command The command to be sent
     */
@@ -347,5 +353,5 @@
     /**
         @brief Sends a query to a given Tcl-interpreter and waits for the result
-        @param id The id of the target interpreter
+        @param target_id The id of the target interpreter
         @param command The command to be sent
         @return The result of the command
@@ -359,4 +365,5 @@
         @brief This function can be called from Tcl to send a query to the main thread.
         @param source_id The id of the calling thread
+        @param args Contains the content of the query
 
         A query waits for the result of the command. This means, the calling thread will be blocked until
@@ -373,4 +380,5 @@
         @param source_id The id of the calling thread
         @param target_id The id of the target thread
+        @param args Contains the content of the query
     */
     std::string TclThreadManager::tcl_crossquery(int source_id, int target_id, const Tcl::object& args)
@@ -384,5 +392,5 @@
         @param target_id The id of the target thread
         @param command The command to send as a query
-        @param bUseCommandExecutor Only used if the target_id is 0 (which references the main interpreter). In this case it means if the command should be passed to the CommandExecutor (true) or to the main Tcl interpreter (false). This is true when called by tcl_query and false when called by tcl_crossquery.
+        @param bUseCommandExecutor Only used if the target_id is 0 (which references the main interpreter). In this case it means if the command should be passed to the CommandExecutor (true) or to the main Tcl interpreter (false). This is true when called by tcl_query() and false when called by tcl_crossquery().
     */
     std::string TclThreadManager::_query(unsigned int source_id, unsigned int target_id, const std::string& command, bool bUseCommandExecutor)
@@ -400,8 +408,8 @@
             {
                 // This query would lead to a deadlock - return with an error
-                TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + getConvertedValue<unsigned int, std::string>(source_bundle->id_) \
-                            + " -> " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
-                            + "), couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) \
-                            + " from other interpreter with ID " + getConvertedValue<unsigned int, std::string>(source_bundle->id_) + '.');
+                TclThreadManager::error("Error: Circular query (" + this->dumpList(source_bundle->queriers_.getList()) + ' ' + multi_cast<std::string>(source_bundle->id_) \
+                            + " -> " + multi_cast<std::string>(target_bundle->id_) \
+                            + "), couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) \
+                            + " from other interpreter with ID " + multi_cast<std::string>(source_bundle->id_) + '.');
             }
             else
@@ -469,5 +477,5 @@
                     // This happens if the main thread tries to query a busy interpreter
                     // To avoid a lock of the main thread, we simply don't proceed with the query in this case
-                    TclThreadManager::error("Error: Couldn't query Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(target_bundle->id_) + ", interpreter is busy right now.");
+                    TclThreadManager::error("Error: Couldn't query Tcl-interpreter with ID " + multi_cast<std::string>(target_bundle->id_) + ", interpreter is busy right now.");
                 }
             }
@@ -515,5 +523,5 @@
         else
         {
-            TclThreadManager::error("Error: No Tcl-interpreter with ID " + getConvertedValue<unsigned int, std::string>(id) + " existing.");
+            TclThreadManager::error("Error: No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
             return 0;
         }
@@ -531,5 +539,5 @@
                 output += ' ';
 
-            output += getConvertedValue<unsigned int, std::string>(*it);
+            output += multi_cast<std::string>(*it);
         }
         return output;
@@ -583,5 +591,5 @@
         if (cc != TCL_OK)
         {
-            TclThreadManager::error("Tcl error (" + action + ", ID " + getConvertedValue<unsigned int, std::string>(bundle->id_) + "): " + static_cast<std::string>(result));
+            TclThreadManager::error("Tcl error (" + action + ", ID " + multi_cast<std::string>(bundle->id_) + "): " + static_cast<std::string>(result));
             return "";
         }
Index: code/trunk/src/libraries/core/command/TclThreadManager.h
===================================================================
--- code/trunk/src/libraries/core/command/TclThreadManager.h	(revision 7380)
+++ code/trunk/src/libraries/core/command/TclThreadManager.h	(revision 7401)
@@ -26,4 +26,10 @@
  *
  */
+
+/**
+    @file
+    @ingroup Command Tcl
+    @brief Declaration of TclThreadManager, used to create multithreaded Tcl interpreters.
+*/
 
 #ifndef _TclThreadManager_H__
Index: code/trunk/src/libraries/core/input/Button.cc
===================================================================
--- code/trunk/src/libraries/core/input/Button.cc	(revision 7380)
+++ code/trunk/src/libraries/core/input/Button.cc	(revision 7401)
@@ -176,5 +176,5 @@
                 // evaluate the command
                 CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
-                if (!eval.isValid() || eval.evaluateParams(true))
+                if (!eval.isValid() || eval.evaluateArguments(true))
                 {
                     parseError("Command evaluation of \"" + commandStr + "\"failed.", true);
Index: code/trunk/src/libraries/core/input/InputCommands.cc
===================================================================
--- code/trunk/src/libraries/core/input/InputCommands.cc	(revision 7380)
+++ code/trunk/src/libraries/core/input/InputCommands.cc	(revision 7401)
@@ -53,5 +53,5 @@
         if (this->abs_ != 0.0f || this->rel_ != 0.0f)
         {
-            evaluation_.setEvaluatedParameter(paramIndex_, Vector2(abs_, rel_));
+            evaluation_.setEvaluatedArgument(paramIndex_, Vector2(abs_, rel_));
             // reset
             rel_ = 0.0;
Index: code/trunk/src/libraries/core/input/InputManager.cc
===================================================================
--- code/trunk/src/libraries/core/input/InputManager.cc	(revision 7380)
+++ code/trunk/src/libraries/core/input/InputManager.cc	(revision 7401)
@@ -140,8 +140,4 @@
         Creates the OIS::InputMananger, the keyboard, the mouse and
         the joys ticks. If either of the first two fail, this method throws an exception.
-    @param windowWidth
-        The width of the render window
-    @param windowHeight
-        The height of the render window
     */
     void InputManager::loadDevices()
Index: code/trunk/src/libraries/core/input/InputManager.h
===================================================================
--- code/trunk/src/libraries/core/input/InputManager.h	(revision 7380)
+++ code/trunk/src/libraries/core/input/InputManager.h	(revision 7401)
@@ -122,4 +122,8 @@
         @param name
             Unique name of the InputState when referenced as string
+        @param bAlwaysGetsInput
+            InputState always gets the input when activated
+        @param bTransparent
+            InputState will not prevent underlaying state from receiving input
         @param priority
             Priority matters when multiple states are active. You can specify any
Index: code/trunk/src/libraries/core/input/InputState.h
===================================================================
--- code/trunk/src/libraries/core/input/InputState.h	(revision 7380)
+++ code/trunk/src/libraries/core/input/InputState.h	(revision 7401)
@@ -128,5 +128,5 @@
         void resetExpiration() { bExpired_ = false; }
 
-        //! Updates one specific device handler with #device#Updated
+        //! Updates one specific device handler with deviceUpdated
         void update(float dt, unsigned int device);
         //! Updates all handlers with allDevicesUpdated
Index: code/trunk/src/libraries/core/input/KeyBinder.cc
===================================================================
--- code/trunk/src/libraries/core/input/KeyBinder.cc	(revision 7380)
+++ code/trunk/src/libraries/core/input/KeyBinder.cc	(revision 7401)
@@ -495,6 +495,10 @@
     @brief
         Event handler for the mouseMoved Event.
-    @param e
-        Mouse state information
+    @param abs_
+        The absolute position of the mouse
+    @param rel_
+        The relative movement of the mouse
+    @param clippingSize
+        Mouse screen area in pixels (usually 1024x1024)
     */
     void KeyBinder::mouseMoved(IntVector2 abs_, IntVector2 rel_, IntVector2 clippingSize)
@@ -551,5 +555,6 @@
     /**
     @brief Event handler for the mouseScrolled Event.
-    @param e Mouse state information
+    @param abs The absolute position of the scroll wheel
+    @param rel The relative movement of the scroll wheel
     */
     void KeyBinder::mouseScrolled(int abs, int rel)
Index: code/trunk/src/libraries/network/ClientInformation.cc
===================================================================
--- code/trunk/src/libraries/network/ClientInformation.cc	(revision 7380)
+++ code/trunk/src/libraries/network/ClientInformation.cc	(revision 7401)
@@ -230,4 +230,5 @@
   * This function should only be applied to the head of the list
   * @param clientID id to look for
+  * @param look_backwards FIXME - add doc? parameter unused?
   * @return pointer to the last element in the list or 0 if the search was unsuccessfull
   */
@@ -244,5 +245,6 @@
   * This function goes forward through the list and looks for an element with clientID
   * This function should only be applied to the head of the list
-  * @param peer peer to look for
+  * @param address peer to look for
+  * @param look_backwards FIXME - add doc? parameter unused?
   * @return pointer to the element in the list
   */
Index: code/trunk/src/libraries/network/GamestateClient.cc
===================================================================
--- code/trunk/src/libraries/network/GamestateClient.cc	(revision 7380)
+++ code/trunk/src/libraries/network/GamestateClient.cc	(revision 7401)
@@ -105,6 +105,6 @@
   * @return iterator pointing to the next object in the list
   */
-  void GamestateClient::removeObject(ObjectList<Synchronisable>::iterator &it) {
-    ObjectList<Synchronisable>::iterator temp=it;
+  void GamestateClient::removeObject(ObjectListIterator<Synchronisable> &it) {
+    ObjectListIterator<Synchronisable> temp=it;
     ++it;
     temp->destroy(); // or delete?
Index: code/trunk/src/libraries/network/synchronisable/Synchronisable.cc
===================================================================
--- code/trunk/src/libraries/network/synchronisable/Synchronisable.cc	(revision 7380)
+++ code/trunk/src/libraries/network/synchronisable/Synchronisable.cc	(revision 7401)
@@ -217,4 +217,5 @@
    * length of varx: size saved int syncvarlist
    * @param mem pointer to allocated memory with enough size
+   * @param sizes FIXME - add doc!
    * @param id gamestateid of the gamestate to be saved (important for priorities)
    * @param mode defines the direction in which the data will be send/received
@@ -288,4 +289,5 @@
    * @param mem pointer to the bytestream
    * @param mode same as in getData
+   * @param forceCallback FIXME - add doc!
    * @return true/false
    */
@@ -364,4 +366,5 @@
    * This function determines, wheter the object should be saved to the bytestream (according to its syncmode/direction)
    * @param id gamestate id
+   * @param mode FIXME - add doc!
    * @return true/false
    */
Index: code/trunk/src/libraries/tools/ResourceCollection.cc
===================================================================
--- code/trunk/src/libraries/tools/ResourceCollection.cc	(revision 7380)
+++ code/trunk/src/libraries/tools/ResourceCollection.cc	(revision 7401)
@@ -52,8 +52,8 @@
     }
 
-    void ResourceCollection::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    void ResourceCollection::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        XMLPortParam(ResourceCollection, "resourceGroup", setResourceGroup, getResourceGroup, xmlElement, mode);
-        XMLPortObject(ResourceCollection, ResourceLocation, "", addResourceLocation, getResourceLocation, xmlElement, mode);
+        XMLPortParam(ResourceCollection, "resourceGroup", setResourceGroup, getResourceGroup, xmlelement, mode);
+        XMLPortObject(ResourceCollection, ResourceLocation, "", addResourceLocation, getResourceLocation, xmlelement, mode);
     }
 
Index: code/trunk/src/libraries/tools/ResourceCollection.h
===================================================================
--- code/trunk/src/libraries/tools/ResourceCollection.h	(revision 7380)
+++ code/trunk/src/libraries/tools/ResourceCollection.h	(revision 7401)
@@ -44,5 +44,5 @@
         virtual ~ResourceCollection();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         void setResourceGroup(const std::string& resourceGroup);
Index: code/trunk/src/libraries/tools/ResourceLocation.cc
===================================================================
--- code/trunk/src/libraries/tools/ResourceLocation.cc	(revision 7380)
+++ code/trunk/src/libraries/tools/ResourceLocation.cc	(revision 7401)
@@ -56,9 +56,9 @@
     }
 
-    void ResourceLocation::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    void ResourceLocation::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        XMLPortParam(ResourceLocation, "path",        setPath,        getPath,        xmlElement, mode);
-        XMLPortParam(ResourceLocation, "archiveType", setArchiveType, getArchiveType, xmlElement, mode);
-        XMLPortParam(ResourceLocation, "recursive",   setRecursive,   getRecursive,   xmlElement, mode);
+        XMLPortParam(ResourceLocation, "path",        setPath,        getPath,        xmlelement, mode);
+        XMLPortParam(ResourceLocation, "archiveType", setArchiveType, getArchiveType, xmlelement, mode);
+        XMLPortParam(ResourceLocation, "recursive",   setRecursive,   getRecursive,   xmlelement, mode);
         if (path_.empty())
             ThrowException(AbortLoading, "ResourceLocation: No path given.");
Index: code/trunk/src/libraries/tools/ResourceLocation.h
===================================================================
--- code/trunk/src/libraries/tools/ResourceLocation.h	(revision 7380)
+++ code/trunk/src/libraries/tools/ResourceLocation.h	(revision 7401)
@@ -46,5 +46,5 @@
         virtual ~ResourceLocation();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         void setPath(const std::string& path) { path_ = path; }
Index: code/trunk/src/libraries/tools/Timer.cc
===================================================================
--- code/trunk/src/libraries/tools/Timer.cc	(revision 7380)
+++ code/trunk/src/libraries/tools/Timer.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Implementation of the Timer class.
+*/
+
 #include "Timer.h"
 
@@ -45,5 +50,5 @@
 
     /**
-        @brief Calls a console command after 'delay' seconds.
+        @brief Console-command: Calls another console command after @a delay seconds.
         @param delay The delay in seconds
         @param command The console command
@@ -60,6 +65,6 @@
 
     /**
-        @brief Executes the command.
-        @param timer The timer to destroy after the command-execution
+        @brief Helper function for delay(), executes the command and destroys the timer.
+        @param timer The timer which called this function.
         @param command The command to execute
     */
@@ -72,5 +77,5 @@
 
     /**
-        @brief Kills all delayed commands.
+        @brief Console-command: Kills all scheduled commands that were delayed using delay().
     */
     void killdelays()
@@ -92,8 +97,9 @@
 
     /**
-        @brief Constructor: Initializes the Timer with given values.
-        @param interval The timer-interval in seconds
-        @param bLoop If true, the function gets called every 'interval' seconds
-        @param exeuctor A executor of the function to call
+        @brief Constructor: Initializes and starts the timer, which will call an executor after some time.
+        @param interval         The timer-interval in seconds
+        @param bLoop            If true, the executor gets called every @a interval seconds
+        @param executor         The executor that will be called
+        @param bKillAfterCall   If true, the timer will be deleted after the executor was called
     */
     Timer::Timer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall)
@@ -120,5 +126,5 @@
 
     /**
-        @brief Executes the executor.
+        @brief Calls the executor and destroys the timer if requested.
     */
     void Timer::run()
Index: code/trunk/src/libraries/tools/Timer.h
===================================================================
--- code/trunk/src/libraries/tools/Timer.h	(revision 7380)
+++ code/trunk/src/libraries/tools/Timer.h	(revision 7401)
@@ -27,33 +27,49 @@
  */
 
-/*!
+/**
+    @defgroup Timer Timer
+    @ingroup Tools
+*/
+
+/**
     @file
-    @brief Definition and Implementation of the Timer class.
+    @ingroup Timer
+    @brief Declaration of the Timer class, used to call functions after a given time-interval.
 
-    The Timer is a callback-object, calling a given function after a given time-interval.
+    @anchor TimerExample
 
-    Usage:
+    Timer is a helper class that executes a function after a given amount of time.
+
+    Usage: <br>
     header.h:
-        class ClassName
-        {
-            public:
-                ClassName();
-                void functionName();
-                Timer myTimer;
-        };
+    @code
+    class MyClass
+    {
+        public:
+            MyClass();
+            void functionName();
+
+        private:
+            Timer myTimer;
+    };
+    @endcode
 
     source.cc:
-        #include "core/command/Executor.h"
+    @code
+    #include "core/command/Executor.h"
 
-        ClassName::ClassName()
-        {
-            myTimer.setTimer(interval_in_seconds, bLoop, createExecutor(createFunctor(&ClassName::functionName, this)));
-        }
+    MyClass::MyClass()
+    {
+        myTimer.setTimer(3, false, createExecutor(createFunctor(&ClassName::myFunction, this)));
+    }
 
-        void ClassName::functionName()
-        {
-            whateveryouwant();
-            something(else);
-        }
+    void MyClass::myFunction()
+    {
+        COUT(0) << "Hello World" << std::endl;
+    }
+    @endcode
+
+    The code in this example prints "Hello World" to the console, 3 seconds after creating
+    an instance of MyClass.
 */
 
@@ -73,5 +89,9 @@
     void executeDelayedCommand(Timer* timer, const std::string& command);
 
-    //! The Timer is a callback-object, calling a given function after a given time-interval.
+    /**
+        @brief Timer is a helper class that executes a function after a given amount of time.
+
+        @see See @ref TimerExample "Timer.h" for an example.
+    */
     class _ToolsExport Timer : public TimeFactorListener
     {
@@ -82,9 +102,9 @@
 
             /**
-                @brief Initializes the Timer with given values.
-                @param interval The timer-interval in seconds
-                @param bLoop If true, the function gets called every 'interval' seconds
-                @param object The object owning the timer and the function
-                @param executor A executor of the function to call
+                @brief Initializes and starts the timer, which will call an executor after some time.
+                @param interval         The timer-interval in seconds
+                @param bLoop            If true, the executor gets called every @a interval seconds
+                @param executor         The executor that will be called
+                @param bKillAfterCall   If true, the timer will be deleted after the executor was called
             */
             void setTimer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall = false)
@@ -101,32 +121,32 @@
             void run();
 
-            /** @brief Starts the Timer: Function-call after 'interval' seconds. */
+            /// Re-starts the Timer: The executor will be called after @a interval seconds.
             inline void startTimer()
                 { this->bActive_ = true; this->time_ = this->interval_; }
-            /** @brief Stops the Timer. */
+            /// Stops the Timer.
             inline void stopTimer()
                 { this->bActive_ = false; this->time_ = this->interval_; }
-            /** @brief Pauses the Timer - it will continue with the actual state if you unpause it. */
+            /// Pauses the Timer - it will continue with the actual state if you call unpauseTimer().
             inline void pauseTimer()
                 { this->bActive_ = false; }
-            /** @brief Unpauses the Timer - continues with the given state. */
+            /// Unpauses the Timer - continues with the given state.
             inline void unpauseTimer()
                 { this->bActive_ = true; }
-            /** @brief Returns true if the Timer is active (= not stoped, not paused). @return True = Time is active */
+            /// Returns true if the Timer is active (neither stoped nor paused).
             inline bool isActive() const
                 { return this->bActive_; }
-            /** @brief Returns the remaining time until the Timer calls the function. @return The remaining time */
+            /// Returns the remaining time until the Timer calls the executor.
             inline float getRemainingTime() const
                 { return static_cast<float>(this->time_ / 1000000.0f); }
-            /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */
+            /// Increases the remaining time of the Timer by the given amount of time (in seconds).
             inline void addTime(float time)
                 { if (time > 0.0f) this->time_ += static_cast<long long>(time * 1000000.0f); }
-            /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */
+            /// Decreases the remaining time of the Timer by the given amount of time (in seconds)
             inline void removeTime(float time)
                 { if (time > 0.0f) this->time_ -= static_cast<long long>(time * 1000000.0f); }
-            /** @brief Sets the interval of the Timer. @param interval The interval */
+            /// Changes the calling interval.
             inline void setInterval(float interval)
                 { this->interval_ = static_cast<long long>(interval * 1000000.0f); }
-            /** @brief Sets bLoop to a given value. @param bLoop True = loop */
+            /// Defines if the timer call the executor every @a interval seconds or only once.
             inline void setLoop(bool bLoop)
                 { this->bLoop_ = bLoop; }
@@ -137,12 +157,12 @@
             void init();
 
-            ExecutorPtr executor_;  //!< The executor of the function that should be called when the time expires
+            ExecutorPtr executor_;  //!< The executor of the function that will be called when the time expires
 
             long long interval_;    //!< The time-interval in micro seconds
-            bool bLoop_;            //!< If true, the function gets called every 'interval' seconds
-            bool bActive_;          //!< If true, the Timer ticks and calls the function if the time's up
-            bool bKillAfterCall_;   //!< If true the timer gets deleted after it called the function
+            bool bLoop_;            //!< If true, the executor gets called every @a interval seconds
+            bool bActive_;          //!< If true, the Timer ticks and calls the executor if the time's up
+            bool bKillAfterCall_;   //!< If true the timer gets deleted after it expired and called the executor
 
-            long long time_;        //!< Internal variable, counting the time till the next function-call
+            long long time_;        //!< Internal variable, counting the time untill the next executor-call
     };
 }
Index: code/trunk/src/libraries/util/Clipboard.cc
===================================================================
--- code/trunk/src/libraries/util/Clipboard.cc	(revision 7380)
+++ code/trunk/src/libraries/util/Clipboard.cc	(revision 7401)
@@ -54,6 +54,5 @@
 
     /**
-        @brief Puts text into the windows-clipboard
-        @param text The text
+        @brief Puts text into the Windows-clipboard
         @return True if the action was successful
     */
@@ -119,10 +118,9 @@
 namespace orxonox
 {
-    static std::string clipboard; //!< Keeps the text of our internal clipboard
+    static std::string clipboard; ///< Keeps the text of our internal clipboard
 
     /**
         @brief Default implementation if there is no OS-specific implementation or no clipboard. Copies the text into an internal clipboard.
-        @param text The text
-        @return True
+        @see fromClipboard()
     */
     bool toClipboard(const std::string& text)
@@ -134,5 +132,5 @@
     /**
         @brief Default implementation if there is no OS-specific implementation or no clipboard. Gets the text from the internal clipboard.
-        @return The text
+        @see toClipboard()
     */
     std::string fromClipboard()
Index: code/trunk/src/libraries/util/Clipboard.h
===================================================================
--- code/trunk/src/libraries/util/Clipboard.h	(revision 7380)
+++ code/trunk/src/libraries/util/Clipboard.h	(revision 7401)
@@ -29,12 +29,13 @@
 /**
     @file
-    @brief Some functions to exchange text between the OS clipboard and Orxonox.
+    @ingroup Util Command
+    @brief Some functions to exchange text between the OS clipboard and the Shell in Orxonox.
 
     Use fromClipboard() to get text from the clipboard (if there is any text) and
-    toClipboard(text) to put text into the clipboard.
+    toClipboard() to put text into the clipboard.
 
-    Those functions can only work properly if there's an OS-specific implementation.
-    If an OS isn't supported, the clipboard only works within Orxonox, but exchange
-    with other programs isn't possible.
+    These functions can only work properly if there's an OS-specific implementation
+    in Clipboard.cc. If a specific OS is not supported, the clipboard only works
+    within Orxonox, but the exchange with other programs is not possible.
 */
 
Index: code/trunk/src/libraries/util/Clock.cc
===================================================================
--- code/trunk/src/libraries/util/Clock.cc	(revision 7380)
+++ code/trunk/src/libraries/util/Clock.cc	(revision 7401)
@@ -45,13 +45,4 @@
     }
 
-    /**
-    @remarks
-        Mind the types! Ogre::Timer::getMicroseconds() will return an unsigned
-        long, which will eventually overflow. But if you use the subtraction of
-        the current time minus the last time the timer gave us and sum these up to
-        a 64 bit integer, we get the desired result.
-        Also mind that we don't have to store the last timer's time as unsigned long
-        as well because (unsigned long)tickTime_ will do exactly that.
-    */
     void Clock::capture()
     {
Index: code/trunk/src/libraries/util/Clock.h
===================================================================
--- code/trunk/src/libraries/util/Clock.h	(revision 7380)
+++ code/trunk/src/libraries/util/Clock.h	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @ingroup Util
+*/
+
 #ifndef _Clock_H__
 #define _Clock_H__
@@ -35,29 +40,73 @@
 namespace orxonox
 {
+    /** Simple real time clock based on Ogre::Timer
+    @details
+        The class can be used to both capture the current real time or to
+        incrementally capture the time and then distribute that time information
+        via Clock& references (for instance for the game tick). <br>
+        Precision: <br>
+    @par Precision
+        The maximum precision is given by the Ogre::Timer and that is somewhere
+        in the microsecond range for both Windows and UNIX.
+    @par Remarks for Usage on Windows
+        For proper functionality this class MUST be used in the same thread! <br>
+        Furthermore it might be possible that the Ogre::Timer has a performance
+        caveat because it will only capture the time on the same CPU core.
+        Confining the main thread to one process could speed up the game.
+        See \ref cmdargspage "Ccommandline Argument" 'limitToCPU' (only on Windows)
+    */
     class _UtilExport Clock
     {
     public:
+        /// Starts the time at 0
         Clock();
         ~Clock();
 
+        /** Internally captures the time and stays at that particular time
+        @remarks
+            Mind the types! Ogre::Timer::getMicroseconds() will return an unsigned
+            long, which will eventually overflow. But if you use the subtraction of
+            the current time minus the last time the timer gave us and sum these up to
+            a 64 bit integer, we get the desired result. <br>
+            Also mind that we don't have to store the last timer's time as unsigned long
+            as well because (unsigned long)tickTime_ will do exactly that.
+        */
         void capture();
 
-        unsigned long long getMicroseconds()   const { return tickTime_; }
-        unsigned long long getMilliseconds()   const { return tickTime_ / 1000; }
-        unsigned long      getSeconds()        const { return static_cast<long> (tickTime_ / 1000000); }
-        float              getSecondsPrecise() const { return static_cast<float>(tickTime_ / 1000000.0f); }
+        /// Returns the last captured absolute time in microseconds
+        unsigned long long getMicroseconds() const
+            { return tickTime_; }
+        /// Returns the last captured absolute time in milliseconds
+        unsigned long long getMilliseconds() const
+            { return tickTime_ / 1000; }
+        /// Returns the last captured absolute time in seconds
+        unsigned long getSeconds() const
+            { return static_cast<long> (tickTime_ / 1000000); }
+        /// Returns the last captured absolute time in seconds as float
+        float getSecondsPrecise() const
+            { return static_cast<float>(tickTime_ / 1000000.0f); }
 
-        float              getDeltaTime()      const { return tickDtFloat_; }
-        long               getDeltaTimeMicroseconds() const { return tickDt_; }
+        /// Returns the timespan in seconds between the last two calls to capture()
+        float getDeltaTime() const
+            { return tickDtFloat_; }
+        /// Returns the timespan in microseconds between the last two calls to capture()
+        long getDeltaTimeMicroseconds() const
+            { return tickDt_; }
 
+        /** Returns the current real time in microseconds
+        @note
+            This is especially useful to measure execution times because of the
+            high precision.
+        */
         unsigned long long getRealMicroseconds() const;
 
     private:
+        /// Undefined
         Clock(const Clock& instance);
 
-        Ogre::Timer*       timer_;
-        unsigned long long tickTime_;
-        long               tickDt_;
-        float              tickDtFloat_;
+        Ogre::Timer*       timer_;       ///< Ogre timer object
+        unsigned long long tickTime_;    ///< Currently captured time
+        long               tickDt_;      ///< Delta time in microseconds (cache value)
+        float              tickDtFloat_; ///< Delta time in seconds (cache value)
     };
 }
Index: code/trunk/src/libraries/util/Convert.cc
===================================================================
--- code/trunk/src/libraries/util/Convert.cc	(revision 7380)
+++ code/trunk/src/libraries/util/Convert.cc	(revision 7401)
@@ -32,5 +32,4 @@
 namespace orxonox
 {
-    //template <class FromType, class ToType>
     bool ConverterExplicit<std::string, bool>::convert(bool* output, const std::string& input)
     {
Index: code/trunk/src/libraries/util/Convert.h
===================================================================
--- code/trunk/src/libraries/util/Convert.h	(revision 7380)
+++ code/trunk/src/libraries/util/Convert.h	(revision 7401)
@@ -28,7 +28,94 @@
  */
 
-/*!
-    @file
-    @brief Definition and Implementation of the Convert class.
+/**
+    @defgroup Convert Conversion functions
+    @ingroup Util
+*/
+
+/** Functions that convert values between different types.
+@file
+@ingroup Convert
+@par Usage
+    There are three ways to use the conversions depending on what you need. <br>
+    - For simply converting values without having to know whether the conversion
+      was successful (for instance float --> string), use orxonox::multi_cast
+      which effectively works exactly like static_cast, etc.
+      @code
+        float input = 42.0;
+        std::string output = multi_cast<std::string>(input);
+      @endcode
+    - If you care about whether the conversion was successful,
+      use orxonox::convertValue.
+      @code
+        std::string input("3.4");
+        float output;
+        bool success = convertValue(&output, input);
+      @endcode
+    - If you care about success and if you can also feed a fallback value,
+      use orxonox::convertValue.
+      @code
+        std::string input("3.4");
+        float output;
+        bool success = convertValue(&output, input, 0.0);
+      @endcode
+    - If success doesn't matter but you can feed a fallback value,
+      use orxonox::getConvertedValue.
+      @code
+        std::string input("3.4");
+        float output = getConvertedValue(input, 0.0);
+      @endcode
+@details
+    The back end of these functions are the actual implementations for the
+    specific conversions, for instance from Ogre::Vector3 to std::string and
+    vice versa. Some of them also use the iostream operators. <br>
+    The real deal is evaluating which function is needed for a conversion based
+    on the input and output type. But there are lots of catches in conjunction
+    with templates which explains why there are so many functions in this file.
+    <br> <br>
+@par Search Order
+    Finding the right function is governed by priority rules: <br>
+    -# (Partial) template specialisation of orxonox::ConverterExplicit::convert()
+    -# An implicit conversion. This includes 'FooBar' to 'int' if FooBar
+       defines operator int() or float().
+    -# Global or member operators for iostream when converting from or
+       to std::string (and FROM const char*)
+    -# (Partial) template specialisation of orxonox::ConverterFallback::convert()
+    -# Fallback function that displays "Could not convert value" with type
+       information obtained from typeid().
+@par Implementing conversion functions
+    To do that you probably need to know a thing or two about the types
+    involved. So, get ready with that. <br>
+    Usually the best way to do it is specialising of the orxonox::ConverterFallback
+    template, like this:
+    @code
+    template <>
+    struct _UtilExport ConverterFallback<std::string, MyType>
+    {
+        static bool convert(MyType* output, const std::string& input)
+        {
+           ...
+           return success;
+        }
+    };
+    @endcode
+    This piece of code converts an std::string to MyType and returns whether the
+    conversion was successful. You can also use partial specialisation.<br>
+    The advantage with orxonox::ConverterFallback is that it has a low priority
+    meaning that when there is an implicit conversion or an iostream method, that
+    comes first and you don't have to deal with it (and the accompanying
+    function call ambiguity). <br>
+    However sometimes you would like to explicitely replace such a conversion.
+    That's where orxonox::ConverterExplicit comes in handy (for instance we
+    replaced the operator << conversions for Ogre::VectorX with our own functions).
+@note
+    There has to be an exact type match when using template specialisations. <br>
+    Template specialisations can be defined after including this file.
+    But any implicit cast function or iostream operator has to be included
+    in this file!
+@par Understanding the Code
+    In order to understand how the templates work, it is probably best to study
+    the functions in order of calling. There are lots of comments explaining
+    what happens, but you'll need to understand a deal about partial template
+    specialisation and function headers are matched in C++.
 */
 
@@ -46,33 +133,4 @@
 #include "ImplicitConversion.h"
 
-////////////////////////////////////
-//// ACTUAL CONVERSION SEQUENCE ////
-////////////////////////////////////
-/*
-    There is a distinct priority when choosing the right conversion function:
-    Overwrite:
-    1. (Partial) template specialisation of ConverterExplicit::convert()
-    Fallbacks:
-    2. Any possible implicit conversion. This includes 'FooBar' --> 'int' if FooBar defines operator float().
-    3. Global or member operators for stringstream when converting from or to std::string (or FROM const char*)
-    4. (Partial) template specialisation of ConverterFallback::convert()
-    5. Function that simply displays "Could not convert value" with type information obtained from typeid().
-
-    Notes:
-    There has to be an exact type match when using template specialisations.
-    Template specialisations can be defined after including this file. Any implicit cast function or iostream
-    operator has to be declared BEFORE this file gets parsed.
-
-    Defining your own functions:
-    There are obviously 4 ways to specify a user defined conversion. What should you use?
-
-    Usually, ConverterFallback fits quite well. You won't have to deal with the conversion from
-    'MyClass' to 'MyClass' by using another explicit template specialisation to avoid ambiguities.
-
-    However if you want to overwrite an implicit conversion or an iostream operator, you really need to
-    make use of ConverterExplicit. We have to do this for the Ogre classes for instance because they
-    define stream operators we don't particulary like.
-*/
-
 namespace orxonox
 {
@@ -81,5 +139,5 @@
     ///////////////////
 
-    // Default template. No conversion available at all.
+    /// Default template. No conversion available at all.
     template <class FromType, class ToType>
     struct ConverterFallback
@@ -93,5 +151,5 @@
     };
 
-    // If all else fails, try a dynamic_cast for pointer types.
+    /// If all else fails, try a dynamic_cast for pointer types.
     template <class FromType, class ToType>
     struct ConverterFallback<FromType*, ToType*>
@@ -109,32 +167,4 @@
         }
     };
-
-    ////////////
-    // upcast //
-    ////////////
-    namespace detail
-    {
-        // perform a static cast if ToType is a base of FromType
-        template<class ToType, class FromType>
-        FORCEINLINE ToType upcast(FromType input, Loki::Int2Type<true>)
-        {
-            return static_cast<ToType>(input);
-        }
-
-        // return zero if ToType is not a base of FromType
-        template<class ToType, class FromType>
-        FORCEINLINE ToType upcast(FromType input, Loki::Int2Type<false>)
-        {
-            return 0;
-        }
-    }
-
-    // performs an upcast if ToType is a base of FromType, returns zero otherwise
-    template <class ToType, class FromType>
-    FORCEINLINE ToType upcast(FromType input)
-    {
-        enum { probe = ImplicitConversion<FromType, ToType>::exists };
-        return detail::upcast<ToType, FromType>(input, Loki::Int2Type<probe>());
-    }
 }
 
@@ -144,5 +174,9 @@
 ///////////////////////
 
-// Default template for stringstream
+/** Fallback template for stringstream
+@details
+    Neither FromType nor ToType was std::string, therefore
+    delegate to orxonox::ConverterFallback
+*/
 template <class FromType, class ToType>
 struct ConverterStringStream
@@ -159,6 +193,8 @@
 /////////////
 
+/// Extra namespace to avoid exposing the iostream operators in it
 namespace fallbackTemplates
 {
+    /// Fallback operator <<() (delegates to orxonox::ConverterFallback)
     template <class FromType>
     FORCEINLINE bool operator <<(std::ostream& outstream,  const FromType& input)
@@ -175,5 +211,5 @@
 }
 
-// template that evaluates whether we can convert to std::string via ostringstream
+/// Template that evaluates whether we can convert to std::string via ostringstream
 template <class FromType>
 struct ConverterStringStream<FromType, std::string>
@@ -182,6 +218,8 @@
     {
         using namespace fallbackTemplates;
-        // this operator call only chooses fallbackTemplates::operator<< if there's no other fitting function
+        // this operator call only chooses fallbackTemplates::operator<<()
+        // if there's no other fitting function
         std::ostringstream oss;
+        // Note: std::ostream has operator!() to tell whether any error flag was set
         if (oss << input)
         {
@@ -201,13 +239,14 @@
 namespace fallbackTemplates
 {
+    /// Fallback operator >>() (delegates to orxonox::ConverterFallback)
     template <class ToType>
     FORCEINLINE bool operator >>(std::istream& instream, ToType& output)
     {
-        return orxonox::ConverterFallback<std::string, ToType>
-            ::convert(&output, static_cast<std::istringstream&>(instream).str());
+        std::string input(static_cast<std::istringstream&>(instream).str());
+        return orxonox::ConverterFallback<std::string, ToType>::convert(&output, input);
     }
 }
 
-// template that evaluates whether we can convert from std::string via ostringstream
+/// Template that evaluates whether we can convert from std::string via istringstream
 template <class ToType>
 struct ConverterStringStream<std::string, ToType>
@@ -216,6 +255,8 @@
     {
         using namespace fallbackTemplates;
+        // this operator call chooses fallbackTemplates::operator>>()
+        // only if there's no other fitting function
         std::istringstream iss(input);
-        // this operator call only chooses fallbackTemplates::operator>> if there's no other fitting function
+        // Note: std::istream has operator!() to tell whether any error flag was set
         if (iss >> (*output))
         {
@@ -229,10 +270,9 @@
 namespace orxonox
 {
-
     ///////////////////
     // Implicit Cast //
     ///////////////////
 
-    // implicit cast not possible, try stringstream conversion next
+    /// %Template delegates to ::ConverterStringStream
     template <class FromType, class ToType>
     FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<false>)
@@ -241,5 +281,5 @@
     }
 
-    // We can cast implicitely
+    /// Makes an implicit cast from \a FromType to \a ToType
     template <class FromType, class ToType>
     FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<true>)
@@ -254,5 +294,9 @@
     ////////////////////////////////
 
-    // Default template if no specialisation is available
+    /** Default template if no orxonox::ConverterExplicit is available
+    @details
+        Evaluates whether \a FromType can be implicitly converted to \a ToType
+        by the use the ImplicitConversion magic.
+    */
     template <class FromType, class ToType>
     struct ConverterExplicit
@@ -261,6 +305,5 @@
         FORCEINLINE static bool convert(ToType* output, const FromType& input)
         {
-            // Try implict cast and probe first. If a simple cast is not possible, it will not compile
-            // We therefore have to out source it into another template function
+            // Use the probe's value to delegate to the right function
             return convertImplicitely(output, input, Loki::Int2Type<probe>());
         }
@@ -275,7 +318,11 @@
     @brief
         Converts any value to any other as long as there exists a conversion.
+    @details
         Otherwise, the conversion will generate a runtime warning and return false.
-        For information about the different conversion methods (user defined too), see the section
-        'Actual conversion sequence' in this file above.
+    @see Convert.h
+    @param output
+        A pointer to the variable where the converted value will be stored
+    @param input
+        The original value
     */
     template <class FromType, class ToType>
@@ -291,7 +338,10 @@
         Converts any value to any other as long as there exists a conversion.
         Otherwise, the conversion will generate a runtime warning and return false.
-        For information about the different conversion methods (user defined too), see the section
-        'Actual conversion sequence' in this file above.
-        If the conversion doesn't succeed, 'fallback' is written to '*output'.
+        If the conversion doesn't succeed, \a fallback is written to \a output.
+    @see Convert.h
+    @param output
+        A pointer to the variable where the converted value will be stored
+    @param input
+        The original value
     @param fallback
         A default value that gets written to '*output' if there is no conversion.
@@ -309,7 +359,26 @@
     }
 
-    // Directly returns the converted value, even if the conversion was not successful.
+    /// Directly returns the converted value, but uses the fallback on failure. @see convertValue
     template<class FromType, class ToType>
-    FORCEINLINE ToType getConvertedValue(const FromType& input)
+    FORCEINLINE ToType getConvertedValue(const FromType& input, const ToType& fallback)
+    {
+        ToType output;
+        convertValue(&output, input, fallback);
+        return output;
+    }
+
+    /**
+    @brief
+        Converts any value to any other as long as there exists a conversion.
+    @details
+        Use exactly the way you use static_cast, etc. <br>
+        A failed conversion will return a default instance of \a ToType
+        (possibly uninitialised)
+    @see Convert.h
+    @param input
+        The original value
+    */
+    template<class ToType, class FromType>
+    FORCEINLINE ToType multi_cast(const FromType& input)
     {
         ToType output;
@@ -318,28 +387,9 @@
     }
 
-    // Directly returns the converted value, but uses the fallback on failure.
-    template<class FromType, class ToType>
-    FORCEINLINE ToType getConvertedValue(const FromType& input, const ToType& fallback)
-    {
-        ToType output;
-        convertValue(&output, input, fallback);
-        return output;
-    }
-
-    // Like getConvertedValue, but the template argument order is in reverse.
-    // That means you can call it exactly like static_cast<ToType>(fromTypeValue).
-    template<class ToType, class FromType>
-    FORCEINLINE ToType multi_cast(const FromType& input)
-    {
-        ToType output;
-        convertValue(&output, input);
-        return output;
-    }
-
     ////////////////////////////////
     // Special string conversions //
     ////////////////////////////////
 
-    // Delegate conversion from const char* to std::string
+    /// Delegates conversion from const char* to std::string
     template <class ToType>
     struct ConverterExplicit<const char*, ToType>
@@ -351,5 +401,5 @@
     };
 
-    // These conversions would exhibit ambiguous << or >> operators when using stringstream
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<char, std::string>
@@ -361,4 +411,5 @@
         }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<unsigned char, std::string>
@@ -370,4 +421,5 @@
         }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<std::string, char>
@@ -382,4 +434,5 @@
         }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<std::string, unsigned char>
@@ -396,5 +449,5 @@
 
 
-    // bool to std::string
+    /// Conversion from bool to std::string
     template <>
     struct ConverterExplicit<bool, std::string>
@@ -410,5 +463,5 @@
     };
 
-    // std::string to bool
+    /// Conversion from std::string to bool
     template <>
     struct _UtilExport ConverterExplicit<std::string, bool>
Index: code/trunk/src/libraries/util/Debug.h
===================================================================
--- code/trunk/src/libraries/util/Debug.h	(revision 7380)
+++ code/trunk/src/libraries/util/Debug.h	(revision 7401)
@@ -29,9 +29,15 @@
 
 /**
+    @defgroup COUT COUT(x) output macro
+    @ingroup Util
+*/
+
+/**
 @file
+@ingroup COUT
 @brief
-    Handles different output-levels of errors, warnings, infos and debug information.
+    Handles different output-levels of errors, warnings, infos, and debug information.
 
-    The COUT(level) macro acts like std::cout, but the output is only performed if the given
+    The COUT(level) macro acts like @c std::cout, but the output is only performed if the given
     level is <= the soft debug level.
 
@@ -39,18 +45,20 @@
      - The hard debug level is used during compile time. It describes the highest allowed output level.
      - The soft debug level is used during runtime and is the maximum of the three configurable
-       output-levels for console, log file and in game shell.
+       output-levels for console, log file, and in game shell.
 
     The separation between the three devices is done by the OutputHandler.
 
+    @anchor COUTlevels
     Possible levels are:
-     0: Very important output
-     1: Errors
-     2: Warnings
-     3: Information
-     4: Debug information
-     5: More debug information
-     6: Crazy debug information
+     - 0: Very important output
+     - 1: Errors
+     - 2: Warnings
+     - 3: Information
+     - 4: Debug information
+     - 5: More debug information
+     - 6: Crazy debug information
 
-@example
+    Example:
+    @code
     COUT(0) << "Very important output" << std::endl;
     COUT(1) << "Error: Something went wrong!" << std::endl;
@@ -58,4 +66,5 @@
     COUT(3) << "Info: It's Monday" << std::endl;
     COUT(4) << "Debug: x is 1.23456" << std::endl;
+    @endcode
 */
 
@@ -90,16 +99,20 @@
 /**
 @brief
-    Logs text output: use exactly like std::cout, but specify an output
-    level as argument.
-@details
-    (a > b ? 0 : c << "text") is equivalent to (a > b ? 0 : (c << "text"))
-    where (a > b ? 0 : ) stands for COUT(x). This should explain how
+    Logs text output: You can use COUT(level) exactly like @c std::cout, but you have to specify an output level as argument.
+@param level
+    The level of the following output (passed with <tt><< "text"</tt>). Lower levels are more important. See @ref COUTlevels "the description above" for a list of possible output levels.
+
+    Example:
+    @code
+    COUT(3) << "Some info" << std::endl; // Output with level 3
+    @endcode
+@note
+    <tt>(a > b ? 0 : c << "text")</tt> is equivalent to <tt>(a > b ? 0 : (c << "text")</tt>
+    where <tt>(a > b ? 0 : )</tt> stands for COUT(x). This should explain how
     this macro magic can possibly even work ;)
-@example
-    COUT(3) << "Some info" << std::endl;
-@note
-    The ? : operator requires both possible results to have the type of
+@remarks
+    The <tt>? :</tt> operator requires both possible results to have the type of
     the first. This is achieved by the int conversion operator dummy
-    in the OutputHandler.
+    in the @ref orxonox::OutputHandler.
 */
 #define COUT(level)                                                    \
Index: code/trunk/src/libraries/util/Exception.cc
===================================================================
--- code/trunk/src/libraries/util/Exception.cc	(revision 7380)
+++ code/trunk/src/libraries/util/Exception.cc	(revision 7401)
@@ -53,10 +53,4 @@
     { }
 
-    /**
-    @remarks
-        The composed full description gets stored to fullDescription_. But for compliance
-        with std::exception, this method has to be const. Hence fullDescription_ is declared
-        as mutable.
-    */
     const std::string& Exception::getFullDescription() const
     {
@@ -89,5 +83,4 @@
     }
 
-    //! Returns the error description
     const char* Exception::what() const throw()
     {
Index: code/trunk/src/libraries/util/Exception.h
===================================================================
--- code/trunk/src/libraries/util/Exception.h	(revision 7380)
+++ code/trunk/src/libraries/util/Exception.h	(revision 7401)
@@ -28,7 +28,29 @@
 
 /**
+    @defgroup ExceptionAssertion Exceptions and assertions
+    @ingroup Util
+*/
+
+/**
 @file
+@ingroup ExceptionAssertion
 @brief
     Declaration of facilities to handle exceptions.
+@details
+    Any exception thrown should inherit from orxonox::Exception. There is a macro
+    \ref CREATE_ORXONOX_EXCEPTION to create a new exception (you can find a list of
+    available exceptions in the docs of this file). <br>
+    Throwing exception is also very simple:
+    @code
+        ThrowException(General, "Something went wrong");
+    @endcode
+    (\c General is a type of exception, see docs of this file) <br>
+    The exception will automatically contain information about file, line number
+    and function name it occurred in. <br><br>
+    There is also some magic you can do for numbers, etc.:
+    @code
+        ThrowException(General, "Error code: " << myInt << ". more info...");
+    @endcode
+    It works with an std::ostringstream, so you can feed it all sorts of values.
 */
 
@@ -45,10 +67,9 @@
 namespace orxonox
 {
-    /**
-    @brief
-        Base class for all exceptions (derived from std::exception).
+    /** Base class for all exceptions (derived from std::exception).
     @details
         This class provides support for information about the file, the line
-        and the function the error occured.
+        and the function the error occurred.
+    @see Exception.h
     */
     class _UtilExport Exception : public std::exception
@@ -60,4 +81,10 @@
         @param description
             Exception description as string. This message is supposed to help developers!
+        @param lineNumber
+            The number of the code-line in which the exception occurred
+        @param filename
+            The file in which the exception occurred
+        @param functionName
+            The function in which the exception occurred
         */
         Exception(const std::string& description, unsigned int lineNumber,
@@ -68,7 +95,13 @@
         //! Needed for compatibility with std::exception
         virtual ~Exception() throw() { }
+        //! Returns the error description
         const char* what() const throw();
 
-        //! Returns a full description with type, line, file and function
+        /** Returns a full description with type, line, file and function
+        @remarks
+            The composed full description gets stored to fullDescription_. But for compliance
+            with std::exception, this method has to be const. Hence fullDescription_ is declared
+            as mutable.
+        */
         virtual const std::string& getFullDescription() const;
         //! Returns the string name of the exception type
@@ -101,5 +134,5 @@
     };
 
-//! Creates a new type of exception that inherits from tracker::Exception
+//! Creates a new type of exception that inherits from orxonox::Exception
 #define CREATE_ORXONOX_EXCEPTION(ExceptionName)                                     \
     class ExceptionName##Exception : public Exception                               \
@@ -123,5 +156,4 @@
     // Creates all possible exception types.
     // If you want to add a new type, simply copy and adjust a new line here.
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
     CREATE_ORXONOX_EXCEPTION(General);
     CREATE_ORXONOX_EXCEPTION(FileNotFound);
@@ -136,9 +168,6 @@
     CREATE_ORXONOX_EXCEPTION(NoGraphics);
     CREATE_ORXONOX_EXCEPTION(AbortLoading);
-#endif
 
-    /**
-    @brief
-        Helper function that forwards an exception and displays the message.
+    /** Helper function that forwards an exception and displays the message.
     @details
         This is necessary because only when using 'throw' the objects storage is managed.
@@ -152,11 +181,10 @@
     }
 
-/**
-@brief
-    Throws an exception and logs a message beforehand.
+/** Throws an exception and logs a message beforehand.
 @param type
     Type of the exception as literal (General, Initialisation, etc.)
 @param description
     Exception description as string
+@see Exception.h
 */
 #define ThrowException(type, description) \
Index: code/trunk/src/libraries/util/ExprParser.h
===================================================================
--- code/trunk/src/libraries/util/ExprParser.h	(revision 7380)
+++ code/trunk/src/libraries/util/ExprParser.h	(revision 7401)
@@ -28,6 +28,7 @@
 
 /**
-  @file
-  @brief Declaration of FloatParser
+@file
+@ingroup Util
+@brief Declaration of FloatParser
 */
 
@@ -42,4 +43,52 @@
 namespace orxonox
 {
+    /** Parser for expressions like \c "3 * cos(5 + 4) / a" where \a a is a predeclared
+        variable.
+    @par Usage
+        Using it is rather simple:
+        @code
+        std::string str("3 + 4");
+        ExprParser expr;
+        expr.parse(str);
+        if (expr.getSuccess())
+        {
+            if (!expr.getRemains().empty())
+            {
+                COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::endl;
+            }
+            double result = expr.getResult();
+        }
+        else
+            COUT(1) << "Error: Cannot calculate expression: Parse error." << std::endl;
+        @endcode
+        getRemains() returns the expression after what could be parsed. For instance
+        \c "2*3 text" will return \c "text" as remains.
+    @details
+        The implementation of this class is really old and sort of a trial for
+        a first C++ class by Reto. That explains why it looks more like C than
+        C++... Also some of the variable names are in German. <br>
+        Explaining how it works exactly is probably not possible anymore, but it
+        is based on recursively parsing the expression character by character.
+        That much I can remember.
+    @par Functions, operators and variables supported
+        - Variables:
+            - e
+            - pi
+        - Functions:
+            - sin, asin, sinh, asinh
+            - cos, acos, cosh, acosh
+            - tan, atan, tanh, atanh
+            - int, floor, ceil, abs, sign
+            - pow, sqrt, exp, ln, log
+            - mod, div
+            - min, max
+            - radians, degrees
+        - Operators:
+            - +, -, ! (unary)
+            - +, -, *, /, %, ^, |, &, !, <, >, !=, <=, >=, =
+    @note
+        Operators may not be very consistent with C++ rules, but using the class
+        for plus and minus should be perfectly ok.
+    */
     class _UtilExport ExprParser
     {
Index: code/trunk/src/libraries/util/ImplicitConversion.h
===================================================================
--- code/trunk/src/libraries/util/ImplicitConversion.h	(revision 7380)
+++ code/trunk/src/libraries/util/ImplicitConversion.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup Util
     @brief Declaration of various helper templates.
 */
Index: code/trunk/src/libraries/util/Math.cc
===================================================================
--- code/trunk/src/libraries/util/Math.cc	(revision 7380)
+++ code/trunk/src/libraries/util/Math.cc	(revision 7401)
@@ -91,10 +91,10 @@
         @param mydirection My viewing direction
         @param otherposition The position of the other object
-        @return The angle
-
-        @example
-        If the other object is exactly in front of me, the function returns 0.
-        If the other object is exactly behind me, the function returns pi.
-        If the other object is exactly right/left to me (or above/below), the function returns pi/2.
+        @return The angle in radian
+
+        Examples:
+         - If the other object is exactly in front of me, the function returns 0.
+         - If the other object is exactly behind me, the function returns pi.
+         - If the other object is exactly right/left to me (or above/below), the function returns pi/2.
     */
     float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
@@ -116,10 +116,10 @@
         @return The viewing direction
 
-        @example
-        If the other object is exactly in front of me, the function returns Vector2(0, 0).
-        If the other object is exactly at my left, the function returns Vector2(-1, 0).
-        If the other object is exactly at my right, the function returns Vector2(1, 0).
-        If the other object is only a bit at my right, the function still returns Vector2(1, 0).
-        If the other object is exactly above me, the function returns Vector2(0, 1).
+        Examples:
+         - If the other object is exactly in front of me, the function returns <tt>Vector2(0, 0)</tt>.
+         - If the other object is exactly at my left, the function returns <tt>Vector2(-1, 0)</tt>.
+         - If the other object is exactly at my right, the function returns <tt>Vector2(1, 0)</tt>.
+         - If the other object is only a bit at my right, the function still returns <tt>Vector2(1, 0)</tt>.
+         - If the other object is exactly above me, the function returns <tt>Vector2(0, 1)</tt>.
     */
     orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
@@ -156,10 +156,10 @@
         @return The viewing direction
 
-        @example
-        If the other object is exactly in front of me, the function returns Vector2(0, 0).
-        If the other object is exactly at my left, the function returns Vector2(-0.5, 0).
-        If the other object is exactly at my right, the function returns Vector2(0.5, 0).
-        If the other object is only a bit at my right, the function still returns Vector2(0.01, 0).
-        If the other object is exactly above me, the function returns Vector2(0, 0.5).
+        Examples:
+         - If the other object is exactly in front of me, the function returns <tt>Vector2(0, 0)</tt>.
+         - If the other object is exactly at my left, the function returns <tt>Vector2(-0.5, 0)</tt>.
+         - If the other object is exactly at my right, the function returns <tt>Vector2(0.5, 0)</tt>.
+         - If the other object is only a bit at my right, the function still returns <tt>Vector2(0.01, 0)</tt>.
+         - If the other object is exactly above me, the function returns <tt>Vector2(0, 0.5)</tt>.
     */
     orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
@@ -220,4 +220,7 @@
     }
 
+    /**
+        @brief Returns a unique number. This function will never return the same value twice.
+    */
     unsigned long getUniqueNumber()
     {
Index: code/trunk/src/libraries/util/Math.h
===================================================================
--- code/trunk/src/libraries/util/Math.h	(revision 7380)
+++ code/trunk/src/libraries/util/Math.h	(revision 7401)
@@ -28,5 +28,11 @@
 
 /**
+    @defgroup Math Mathematical functions
+    @ingroup Util
+*/
+
+/**
     @file
+    @ingroup Math
     @brief Declaration and implementation of several math-functions, typedefs of some Ogre::Math classes to the orxonox namespace.
 */
@@ -62,17 +68,17 @@
     namespace math
     {
-        const float pi      = 3.14159265f;
-        const float pi_2    = 1.57079633f;
-        const float pi_4    = 7.85398163e-1f;
-        const float e       = 2.71828183f;
-        const float sqrt2   = 1.41421356f;
-        const float sqrt2_2 = 7.07106781e-1f;
-
-        const double pi_d      = 3.14159265358979324;
-        const double pi_2_d    = 1.57079632679489662;
-        const double pi_4_d    = 7.85398163397448310e-1;
-        const double e_d       = 2.71828182845904524;
-        const double sqrt2_d   = 1.41421356237309505;
-        const double sqrt2_2_d = 7.07106781186547524e-1;
+        const float pi      = 3.14159265f;      ///< PI
+        const float pi_2    = 1.57079633f;      ///< PI / 2
+        const float pi_4    = 7.85398163e-1f;   ///< PI / 4
+        const float e       = 2.71828183f;      ///< e
+        const float sqrt2   = 1.41421356f;      ///< sqrt(2)
+        const float sqrt2_2 = 7.07106781e-1f;   ///< sqrt(2) / 2
+
+        const double pi_d      = 3.14159265358979324;       ///< PI (double)
+        const double pi_2_d    = 1.57079632679489662;       ///< PI / 2 (double)
+        const double pi_4_d    = 7.85398163397448310e-1;    ///< PI / 4 (double)
+        const double e_d       = 2.71828182845904524;       ///< e (double)
+        const double sqrt2_d   = 1.41421356237309505;       ///< sqrt(2) (double)
+        const double sqrt2_2_d = 7.07106781186547524e-1;    ///< sqrt(2) / 2 (double)
     }
 
@@ -101,5 +107,5 @@
 
     /**
-        @brief Keeps a value between a lower and an upper limit.
+        @brief Keeps a value between a lower and an upper limit. Values beyond these limits are limited to either @a min or @a max.
         @param x The value
         @param min The lower limit
@@ -119,5 +125,5 @@
 
     /**
-        @brief Returns the square value (x^2).
+        @brief Returns the squared value (x^2).
     */
     template <typename T>
@@ -128,5 +134,5 @@
 
     /**
-        @brief Returns the cube value (x^3).
+        @brief Returns the cubed value (x^3).
     */
     template <typename T>
@@ -137,5 +143,5 @@
 
     /**
-        @brief Rounds the value.
+        @brief Rounds the value to the nearest integer.
     */
     template <typename T>
@@ -149,4 +155,17 @@
         @param x The value
         @param max The operand
+
+        The built in modulo operator % yields a strange behavior with negative values.
+        This function corrects this - the result is guaranteed to lie always between
+        zero and (max-1).
+
+        Example:
+        @code
+        int var = 11 % 10;      //  1
+        int var = -1 % 10;      // -1
+
+        int var = mod(11, 10);  //  1
+        int var = mod(-1, 10);  //  9
+        @endcode
     */
     template <typename T>
@@ -159,4 +178,12 @@
     }
 
+    /**
+        @brief Returns a "zero" value for the given type.
+        @note This is the default template of the zeroise() function. The template is spezialized for each supported type.
+
+        The exact return value of the function depends on the type. For @c int this is 0,
+        for @c float it's 0.0f. For a @c std::string the function returns "" and for
+        @c Vector3 you get <tt>Vector3(0, 0, 0)</tt>.
+    */
     template <typename T>
     inline T zeroise()
@@ -192,5 +219,8 @@
     template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
 
-    //! Provides zero value symbols that can be returned as reference
+    /**
+        @brief Provides zero value symbols that can be returned as reference
+        @see zeroise()
+    */
     template <typename T>
     struct NilValue
@@ -207,8 +237,8 @@
     /**
         @brief Interpolates between two values for a time between 0 and 1.
-        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-        @param start The value at time = 0
-        @param end The value at time = 1
-        @return The interpolation at a given time
+        @param time The time is a value between 0 and 1 - the function returns @a start if @a time is 0, @a end if @a time is 1, and interpolates if @a time is between 0 and 1.
+        @param start The value at @a time = 0
+        @param end The value at @a time = 1
+        @return The interpolated value at a given time
     */
     template <typename T>
@@ -220,8 +250,8 @@
     /**
         @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
-        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-        @param start The value at time = 0
-        @param end The value at time = 1
-        @return The smoothed interpolation at a given time
+        @param time The time is a value between 0 and 1 - the function returns @a start if @a time is 0, @a end if @a time is 1, and interpolates if @a time is between 0 and 1.
+        @param start The value at @a time = 0
+        @param end The value at @a time = 1
+        @return The interpolated value at a given time
     */
     template <typename T>
@@ -232,5 +262,5 @@
 
     /**
-        @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
+        @brief Returns a random number between 0 and almost 1: <tt>0 <= rnd < 1</tt>.
     */
     inline float rnd()
@@ -240,5 +270,5 @@
 
     /**
-        @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
+        @brief Returns a random number between 0 and almost @a max: <tt>0 <= rnd < max</tt>.
         @param max The maximum
     */
@@ -249,5 +279,5 @@
 
     /**
-        @brief Returns a random number between min and almost max: min <= rnd < max.
+        @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
         @param min The minimum
         @param max The maximum
@@ -268,4 +298,7 @@
     _UtilExport unsigned long getUniqueNumber();
 
+    /**
+        @brief A Vector class containing two integers @a x and @a y.
+    */
     class IntVector2
     {
@@ -277,4 +310,7 @@
     };
 
+    /**
+        @brief A Vector class containing three integers @a x, @a y, and @a z.
+    */
     class IntVector3
     {
Index: code/trunk/src/libraries/util/MathConvert.h
===================================================================
--- code/trunk/src/libraries/util/MathConvert.h	(revision 7380)
+++ code/trunk/src/libraries/util/MathConvert.h	(revision 7401)
@@ -28,7 +28,8 @@
 
 /**
-    @file
-    @brief
-        Math conversion functions. Definitions are in Math.cc
+@file
+@ingroup Convert
+@brief
+    Conversion functions for Math types like Ogre::Vector3 (definitions are in Math.cc)
 */
 
@@ -46,5 +47,5 @@
     ////////////////////
 
-    // Vector2 to std::string
+    /// Ogre::Vector2 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector2, std::string>
@@ -62,5 +63,5 @@
     };
 
-    // Vector3 to std::string
+    /// Ogre::Vector3 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector3, std::string>
@@ -78,5 +79,5 @@
     };
 
-    // Vector4 to std::string
+    /// Ogre::Vector4 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector4, std::string>
@@ -94,5 +95,5 @@
     };
 
-    // Quaternion to std::string
+    /// Ogre::Quaternion to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Quaternion, std::string>
@@ -110,5 +111,5 @@
     };
 
-    // ColourValue to std::string
+    /// Ogre::ColourValue to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::ColourValue, std::string>
@@ -131,17 +132,17 @@
     ////////////////////
 
-    // std::string to Vector2
+    /// std::string to Ogre::Vector2 conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector2>
     { static bool convert(orxonox::Vector2*     output, const std::string& input); };
-    // std::string to Vector3
+    /// std::string to Ogre::Vector3 conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector3>
     { static bool convert(orxonox::Vector3*     output, const std::string& input); };
-    // std::string to Vector4
+    /// std::string to Ogre::Vector4 conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector4>
     { static bool convert(orxonox::Vector4*     output, const std::string& input); };
-    // std::string to Quaternion
+    /// std::string to Ogre::Quaternion conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Quaternion>
     { static bool convert(orxonox::Quaternion*  output, const std::string& input); };
-    // std::string to ColourValue
+    /// std::string to Ogre::ColourValue conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::ColourValue>
     { static bool convert(orxonox::ColourValue* output, const std::string& input); };
@@ -152,5 +153,5 @@
     ///////////////////////////////
 
-    // From Radian
+    /// Delegates conversions from Radian to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Radian, ToType>
@@ -162,5 +163,5 @@
     };
 
-    // From Degree
+    /// Delegates conversions from Degree to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Degree, ToType>
@@ -172,5 +173,5 @@
     };
 
-    // To Radian
+    /// Delegates conversions to Radian to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Radian>
@@ -189,5 +190,5 @@
     };
 
-    // To Degree
+    /// Delegates conversions to Degree to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Degree>
Index: code/trunk/src/libraries/util/MultiType.cc
===================================================================
--- code/trunk/src/libraries/util/MultiType.cc	(revision 7380)
+++ code/trunk/src/libraries/util/MultiType.cc	(revision 7401)
@@ -159,50 +159,50 @@
     }
 
-    MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Char            ) ? (static_cast<MT_Value<char>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedChar    ) ? (static_cast<MT_Value<unsigned char>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Short           ) ? (static_cast<MT_Value<short>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedShort   ) ? (static_cast<MT_Value<unsigned short>      *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Int             ) ? (static_cast<MT_Value<int>                 *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedInt     ) ? (static_cast<MT_Value<unsigned int>        *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Long            ) ? (static_cast<MT_Value<long>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLong    ) ? (static_cast<MT_Value<unsigned long>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongLong        ) ? (static_cast<MT_Value<long long>           *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLongLong) ? (static_cast<MT_Value<unsigned long long>  *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Float           ) ? (static_cast<MT_Value<float>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_Type::Double          ) ? (static_cast<MT_Value<double>              *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongDouble      ) ? (static_cast<MT_Value<long double>         *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Bool            ) ? (static_cast<MT_Value<bool>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::VoidPointer     ) ? (static_cast<MT_Value<void*>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::String          ) ? (static_cast<MT_Value<std::string>         *>(this->value_))->value_ : (*this->value_)) : NilValue<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector2         ) ? (static_cast<MT_Value<orxonox::Vector2>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector3         ) ? (static_cast<MT_Value<orxonox::Vector3>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector4         ) ? (static_cast<MT_Value<orxonox::Vector4>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_Type::ColourValue     ) ? (static_cast<MT_Value<orxonox::ColourValue>*>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Quaternion      ) ? (static_cast<MT_Value<orxonox::Quaternion> *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Radian          ) ? (static_cast<MT_Value<orxonox::Radian>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
-    MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Degree          ) ? (static_cast<MT_Value<orxonox::Degree>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
-
-    template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_Type::Char            ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_Type::UnsignedChar    ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_Type::Short           ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_Type::UnsignedShort   ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_Type::Int             ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_Type::UnsignedInt     ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_Type::Long            ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_Type::UnsignedLong    ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_Type::LongLong        ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_Type::UnsignedLongLong); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_Type::Float           ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_Type::Double          ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_Type::LongDouble      ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_Type::Bool            ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_Type::VoidPointer     ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_Type::String          ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_Type::Vector2         ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_Type::Vector3         ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_Type::Vector4         ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_Type::ColourValue     ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_Type::Quaternion      ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_Type::Radian          ); } /** @brief Creates a new value container for the given type. */
-    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_Type::Degree          ); } /** @brief Creates a new value container for the given type. */
+    MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Char            ) ? (static_cast<MT_Value<char>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedChar    ) ? (static_cast<MT_Value<unsigned char>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Short           ) ? (static_cast<MT_Value<short>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedShort   ) ? (static_cast<MT_Value<unsigned short>      *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Int             ) ? (static_cast<MT_Value<int>                 *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedInt     ) ? (static_cast<MT_Value<unsigned int>        *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Long            ) ? (static_cast<MT_Value<long>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLong    ) ? (static_cast<MT_Value<unsigned long>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongLong        ) ? (static_cast<MT_Value<long long>           *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLongLong) ? (static_cast<MT_Value<unsigned long long>  *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Float           ) ? (static_cast<MT_Value<float>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_Type::Double          ) ? (static_cast<MT_Value<double>              *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongDouble      ) ? (static_cast<MT_Value<long double>         *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Bool            ) ? (static_cast<MT_Value<bool>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::VoidPointer     ) ? (static_cast<MT_Value<void*>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::String          ) ? (static_cast<MT_Value<std::string>         *>(this->value_))->value_ : (*this->value_)) : NilValue<std::string>();          } ///< Returns the current value, converted to the requested type.
+    MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector2         ) ? (static_cast<MT_Value<orxonox::Vector2>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector2>();     } ///< Returns the current value, converted to the requested type.
+    MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector3         ) ? (static_cast<MT_Value<orxonox::Vector3>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector3>();     } ///< Returns the current value, converted to the requested type.
+    MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector4         ) ? (static_cast<MT_Value<orxonox::Vector4>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector4>();     } ///< Returns the current value, converted to the requested type.
+    MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_Type::ColourValue     ) ? (static_cast<MT_Value<orxonox::ColourValue>*>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::ColourValue>(); } ///< Returns the current value, converted to the requested type.
+    MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Quaternion      ) ? (static_cast<MT_Value<orxonox::Quaternion> *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Quaternion>();  } ///< Returns the current value, converted to the requested type.
+    MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Radian          ) ? (static_cast<MT_Value<orxonox::Radian>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Radian>();      } ///< Returns the current value, converted to the requested type.
+    MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Degree          ) ? (static_cast<MT_Value<orxonox::Degree>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Degree>();      } ///< Returns the current value, converted to the requested type.
+
+    template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_Type::Char            ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_Type::UnsignedChar    ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_Type::Short           ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_Type::UnsignedShort   ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_Type::Int             ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_Type::UnsignedInt     ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_Type::Long            ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_Type::UnsignedLong    ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_Type::LongLong        ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_Type::UnsignedLongLong); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_Type::Float           ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_Type::Double          ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_Type::LongDouble      ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_Type::Bool            ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_Type::VoidPointer     ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_Type::String          ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_Type::Vector2         ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_Type::Vector3         ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_Type::Vector4         ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_Type::ColourValue     ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_Type::Quaternion      ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_Type::Radian          ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_Type::Degree          ); } ///< Creates a new value container for the given type.
 }
Index: code/trunk/src/libraries/util/MultiType.h
===================================================================
--- code/trunk/src/libraries/util/MultiType.h	(revision 7380)
+++ code/trunk/src/libraries/util/MultiType.h	(revision 7401)
@@ -28,11 +28,19 @@
 
 /**
+    @defgroup MultiType MultiType
+    @ingroup Util
+*/
+
+/**
     @file
+    @ingroup MultiType
     @brief Declaration of the MultiType and some helper constructs.
 
+    @anchor MultiTypeExamples
+
     The MultiType can hold a value of one of the following types:
-     - all primitives
-     - all pointers
-     - string
+     - all primitives (int, float, bool, etc.)
+     - all pointers (void* and T*)
+     - std::string
      - Vector2, Vector3, Vector4
      - Quaternion
@@ -40,22 +48,43 @@
      - Radian, Degree
 
-    The MultiType has a "type" determined by the first assigned value, either through
-     - the constructor,
-     - the assignment operator= or
-     - setValue(value).
-    If you assign another value of another type, the MultiType keeps "it's" type and
-    converts the new value to this type.
+    The MultiType has an internal "type" determined by the first assigned value, using one of these ways:
+     - @ref orxonox::MultiType::MultiType "The constructor"
+     - The assignment operator= (orxonox::MultiType::operator=())
+     - @ref orxonox::MultiType::setValue() "setValue(value)"
+
+    If you assign another value of another type, the MultiType keeps "its" type and
+    converts the new value to the old type.
 
     If you want to change the type, there are three possibilities:
-     - convert<T>() set's the type to T and converts the currently assigned value
-     - setType<T>() set's the type to T and resets the value
+     - @ref orxonox::MultiType::convert "convert<T>()" sets the type to T and converts the currently assigned value
+     - @ref orxonox::MultiType::setType "setType<T>()" sets the type to T and resets the value to zero using zeroise<T>()
      - setValue<T>(value) assigns a new value and changes the type to T.
 
-    @example
-    MultiType a = 10;;         // a has now the type int and the value 10
+    Examples:
+    @code
+    MultiType a = 10;          // a has now the type int and the value 10
     a.setValue("3.14");        // a has still the type int and "3.14" gets converted, therefore the value is now 3
-    a.setValue<float>("3.14"); // a has now the type float and "3.14" gets converted to 3.14
-    a.convert<bool>();         // converts 3.14 to bool, which is true
+    a.setValue<float>("3.14"); // a has now the type float and "3.14" gets converted to 3.14f
+    a.convert<bool>();         // converts 3.14f to bool, which is true
     a = false;                 // assigns false, this is equivalent to a.setValue(false)
+    @endcode
+
+    You can pass a MultiType to a function as an argument, even if the argument is
+    not of type MultiType. This works, because the MultiType is automatically converted
+    to the right type.
+
+    Example:
+    @code
+    void myfunction(int value)
+    {
+        COUT(0) << "doubled value is " << (2 * value) << std::endl;
+    }
+
+    MultiType a = "50";        // Note: We assigned a string
+    myfunction(a);             // a is converted to int and passed to the function, which prints "value is 100"
+    @endcode
+
+    Note however that it is of course quite expensive to convert values, especially std::string <-> value.
+    So if you can, always assign a value with the right type to avoid conversion.
 
     @note
@@ -127,8 +156,7 @@
          - Radian, Degree
 
-        The internal type of a MultiType is determined by the first assigned value, but can be
-        changed by using setType<T>(), convert<T>() or setValue<T>(value). If a value gets assigned
-        the normal way (operator=, setValue(value)), the value gets converted to the current internal
-        type of the MultiType.
+        For more information and some examples see the description @ref MultiTypeExamples "here".
+
+        @see MultiType.h
     */
     class _UtilExport MultiType
@@ -153,8 +181,8 @@
             virtual bool assimilate(const MultiType& other) = 0;
 
-            /** @brief Returns the type of the current value. */
+            /// Returns the type of the current value.
             const MT_Type::Value& getType() const { return this->type_; }
 
-            /** @brief Checks whether the value is a default one. */
+            /// Checks whether the value is a default one.
             bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
 
@@ -237,45 +265,45 @@
             virtual uint8_t getSize() const=0;
 
-            MT_Type::Value type_;   //!< The type of the current value
-            bool bHasDefaultValue_; //!< True if the last conversion wasn't successful
+            MT_Type::Value type_;   ///< The type of the current value
+            bool bHasDefaultValue_; ///< True if the last conversion wasn't successful
         };
 
         public:
-            inline MultiType()                                  : value_(0) {}                                      /** @brief Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value. */
-            inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::mbool& value)       : value_(0) { this->assignValue((bool)value); }     /** @brief Constructor: Assigns the given mbool and converts it to bool. */
-            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } /** @brief Constructor: Converts the char array to a std::string, assigns the value and sets the type. */
-            inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              /** @brief Copyconstructor: Assigns value and type of the other MultiType. */
-            inline MultiType(MT_Type::Value type)               : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
-
-            /** @brief Destructor: Deletes the MT_Value. */
+            inline MultiType()                                  : value_(0) {}                                      ///< Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
+            inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
+            inline MultiType(const orxonox::mbool& value)       : value_(0) { this->assignValue((bool)value); }     ///< Constructor: Assigns the given mbool and converts it to bool.
+            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } ///< Constructor: Converts the char array to a std::string, assigns the value and sets the type.
+            inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              ///< Copyconstructor: Assigns value and type of the other MultiType.
+            inline MultiType(MT_Type::Value type)               : value_(0) { this->setType(type); }                ///< Constructor: Sets the type, the next assignment will determine the value.
+
+            /// Destructor: Deletes the MT_Value.
             inline ~MultiType() { if (this->value_) { delete this->value_; } }
 
-            template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } /** @brief Assigns a new value. The value will be converted to the current type of the MultiType. */
-            template <typename V> inline MultiType& operator=(V* value)               { this->setValue(value); return (*this); } /** @brief Assigns a pointer. */
-            inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } /** @brief Assigns the value of the other MultiType and converts it to the current type of the MultiType. */
-            inline                       MultiType& operator=(MT_Type::Value type)    { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
+            template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } ///< Assigns a new value. The value will be converted to the current type of the MultiType.
+            template <typename V> inline MultiType& operator=(V* value)               { this->setValue(value); return (*this); } ///< Assigns a pointer.
+            inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } ///< Assigns the value of the other MultiType and converts it to the current type of the MultiType.
+            inline                       MultiType& operator=(MT_Type::Value type)    { this->setType(type);   return (*this); } ///< Resets the value and changes the type.
 
             inline bool                                   setValue(const char& value);
@@ -303,5 +331,5 @@
             inline bool                                   setValue(const orxonox::Degree& value);
             inline bool                                   setValue(const char* value);
-            /** @brief Assigns a pointer. */
+            /// Assigns a pointer.
             template <typename V> inline bool setValue(V* value)
             {
@@ -311,48 +339,53 @@
                     return this->assignValue     (static_cast<void*>(const_cast<typename Loki::TypeTraits<V>::UnqualifiedType*>(value)));
             }
-            /** @brief Assigns the value of the other MultiType and converts it to the current type. */
+            /// Assigns the value of the other MultiType and converts it to the current type.
             bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
-            /** @brief Changes the type to T and assigns the new value (which might be of another type than T - it gets converted). */
+            /// Changes the type to T and assigns the new value (which might be of another type than T - it gets converted).
             template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
 
 
-            /** @brief Copies the other MultiType by assigning value and type. */
+            /// Copies the other MultiType by assigning value and type.
             inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
 
-            template <typename T> inline bool convert()                       { return this->setValue<T>((typename Loki::TypeTraits<T>::UnqualifiedReferredType)(*this));  } /** @brief Converts the current value to type T. */
-            inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
+            /// Converts the current value to type T.
+            template <typename T> inline bool convert()                       { return this->setValue<T>((typename Loki::TypeTraits<T>::UnqualifiedReferredType)(*this));  }
+            /// Converts the current value to the type of the other MultiType.
+            inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); }
             bool                              convert(MT_Type::Value type);
 
-            /** @brief Current content gets deleted. New type is MT_Type::Null */
+            /// Current content gets deleted. New type is MT_Type::Null
             inline void                       reset()                         { if (this->value_) delete this->value_; this->value_ = 0; }
-            /** @brief Current content gets overridden with default zero value */
+            /// Current content gets overridden with default zero value
             inline void                       resetValue()                    { if (this->value_) this->value_->reset(); }
 
-            template <typename T> inline void setType()                       { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); } /** @brief Resets the value and changes the internal type to T. */
-            inline void                       setType(const MultiType& other) { this->setType(other.getType());                                             } /** @brief Resets the value and changes the internal type to the type of the other MultiType. */
-            inline void                       setType(MT_Type::Value type)    { this->reset(); this->convert(type); this->resetValue();                     } /** @brief Resets the value and changes the internal type to the given type. */
-
-            /** @brief Returns the current type. */
+            /// Resets the value and changes the internal type to T.
+            template <typename T> inline void setType()                       { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
+            /// Resets the value and changes the internal type to the type of the other MultiType.
+            inline void                       setType(const MultiType& other) { this->setType(other.getType());                                             }
+            /// Resets the value and changes the internal type to the given type.
+            inline void                       setType(MT_Type::Value type)    { this->reset(); this->convert(type); this->resetValue();                     }
+
+            /// Returns the current type.
             inline MT_Type::Value             getType()                   const { return (this->value_) ? this->value_->type_ : MT_Type::Null; }
-            /** @brief Returns true if the current type equals the given type. */
+            /// Returns true if the current type equals the given type.
             inline bool                       isType(MT_Type::Value type) const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_Type::Null); }
-            /** @brief Returns true if the current type is T. */
+            /// Returns true if the current type is T.
             template <typename T> inline bool isType()                    const { return false; } // Only works for specialized values - see below
             std::string                       getTypename()               const;
 
-            /** @brief Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT */
+            /// Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT
             inline void                       exportData(uint8_t*& mem) const { assert(sizeof(MT_Type::Value)<=8); *static_cast<uint8_t*>(mem) = this->getType(); mem+=sizeof(uint8_t); this->value_->exportData(mem); }
-            /** @brief Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT */
+            /// Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT
             inline void                       importData(uint8_t*& mem) { assert(sizeof(MT_Type::Value)<=8); this->setType(static_cast<MT_Type::Value>(*static_cast<uint8_t*>(mem))); mem+=sizeof(uint8_t); this->value_->importData(mem); }
-            /** @brief Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT */
+            /// Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT
             inline uint8_t*&                  operator << (uint8_t*& mem) { importData(mem); return mem; }
-            /** @brief Loads the value of the MT to a bytestream and increases pointer to bytestream by size of MT */
+            /// Loads the value of the MT to a bytestream and increases pointer to bytestream by size of MT
             inline void                       operator >> (uint8_t*& mem) const { exportData(mem); }
             inline uint32_t                   getNetworkSize() const { assert(this->value_); return this->value_->getSize() + sizeof(uint8_t); }
 
-            /** @brief Checks whether the value is a default one. */
+            /// Checks whether the value is a default one (assigned after a failed conversion)
             bool                              hasDefaultValue() const { return this->value_->hasDefaultValue(); }
 
-            /** @brief Checks if the MT contains no value. */
+            /// Checks if the MT contains no value.
             bool                              null() const { return (!this->value_); }
 
@@ -380,84 +413,84 @@
             operator orxonox::Radian()       const;
             operator orxonox::Degree()       const;
-            /** @brief Returns the current value, converted to a T* pointer. */
+            /// Returns the current value, converted to a T* pointer.
             template <class T> operator T*() const { return (static_cast<T*>(this->operator void*())); }
 
-            inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-            inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-
-            inline char                     getChar()             const { return this->operator char();                 } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } /** @brief Returns the current value, converted to the requested type. */
-            inline short                    getShort()            const { return this->operator short();                } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } /** @brief Returns the current value, converted to the requested type. */
-            inline int                      getInt()              const { return this->operator int();                  } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } /** @brief Returns the current value, converted to the requested type. */
-            inline long                     getLong()             const { return this->operator long();                 } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } /** @brief Returns the current value, converted to the requested type. */
-            inline long long                getLongLong()         const { return this->operator long long();            } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } /** @brief Returns the current value, converted to the requested type. */
-            inline float                    getFloat()            const { return this->operator float();                } /** @brief Returns the current value, converted to the requested type. */
-            inline double                   getDouble()           const { return this->operator double();               } /** @brief Returns the current value, converted to the requested type. */
-            inline long double              getLongDouble()       const { return this->operator long double();          } /** @brief Returns the current value, converted to the requested type. */
-            inline bool                     getBool()             const { return this->operator bool();                 } /** @brief Returns the current value, converted to the requested type. */
-            inline void*                    getVoid()             const { return this->operator void*();                } /** @brief Returns the current value, converted to the requested type. */
-            inline std::string              getString()           const { return this->operator std::string();          } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } /** @brief Returns the current value, converted to the requested type. */
-            template <typename T> inline T* getPointer()          const { return static_cast<T*>(this->getVoid());      } /** @brief Returns the current value, converted to a T* pointer. */
+            inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+            inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+
+            inline char                     getChar()             const { return this->operator char();                 } ///< Returns the current value, converted to the requested type.
+            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } ///< Returns the current value, converted to the requested type.
+            inline short                    getShort()            const { return this->operator short();                } ///< Returns the current value, converted to the requested type.
+            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } ///< Returns the current value, converted to the requested type.
+            inline int                      getInt()              const { return this->operator int();                  } ///< Returns the current value, converted to the requested type.
+            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } ///< Returns the current value, converted to the requested type.
+            inline long                     getLong()             const { return this->operator long();                 } ///< Returns the current value, converted to the requested type.
+            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } ///< Returns the current value, converted to the requested type.
+            inline long long                getLongLong()         const { return this->operator long long();            } ///< Returns the current value, converted to the requested type.
+            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } ///< Returns the current value, converted to the requested type.
+            inline float                    getFloat()            const { return this->operator float();                } ///< Returns the current value, converted to the requested type.
+            inline double                   getDouble()           const { return this->operator double();               } ///< Returns the current value, converted to the requested type.
+            inline long double              getLongDouble()       const { return this->operator long double();          } ///< Returns the current value, converted to the requested type.
+            inline bool                     getBool()             const { return this->operator bool();                 } ///< Returns the current value, converted to the requested type.
+            inline void*                    getVoid()             const { return this->operator void*();                } ///< Returns the current value, converted to the requested type.
+            inline std::string              getString()           const { return this->operator std::string();          } ///< Returns the current value, converted to the requested type.
+            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } ///< Returns the current value, converted to the requested type.
+            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } ///< Returns the current value, converted to the requested type.
+            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } ///< Returns the current value, converted to the requested type.
+            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } ///< Returns the current value, converted to the requested type.
+            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } ///< Returns the current value, converted to the requested type.
+            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } ///< Returns the current value, converted to the requested type.
+            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } ///< Returns the current value, converted to the requested type.
+            template <typename T> inline T* getPointer()          const { return static_cast<T*>(this->getVoid());      } ///< Returns the current value, converted to a T* pointer.
 
         private:
-            inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Char)             { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedChar)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_Type::Short)            { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_Type::UnsignedShort)    { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_Type::Int)              { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_Type::UnsignedInt)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Long)             { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLong)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_Type::LongLong)         { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong) { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_Type::Float)            { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_Type::Double)           { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_Type::LongDouble)       { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Bool)             { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_Type::VoidPointer)      { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_Type::String)           { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector2)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector3)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector4)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_Type::ColourValue)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_Type::Quaternion)       { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_Type::Radian)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-            inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_Type::Degree)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
-
-            /** @brief Changes the value container. */
+            inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Char)             { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedChar)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_Type::Short)            { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_Type::UnsignedShort)    { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_Type::Int)              { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_Type::UnsignedInt)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Long)             { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLong)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_Type::LongLong)         { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong) { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_Type::Float)            { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_Type::Double)           { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_Type::LongDouble)       { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Bool)             { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_Type::VoidPointer)      { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_Type::String)           { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector2)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector3)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector4)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_Type::ColourValue)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_Type::Quaternion)       { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_Type::Radian)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } ///< Assigns a new value by changing type and creating a new container.
+            inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_Type::Degree)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } ///< Assigns a new value by changing type and creating a new container.
+
+            /// Changes the value container.
             template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
-            /** @brief Creates a new value container (works only with specialized types). */
+            /// Creates a new value container (works only with specialized types).
             template <typename T>        void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
 
@@ -465,52 +498,53 @@
     };
 
-    /** @brief Puts the MultiType on a stream by using the native << operator of the current type. */
+    /// Puts the MultiType on a stream by using the native << operator of the current type.
     _UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
 
-    template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Char);             } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedChar);     } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_Type::Short);            } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedShort);    } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_Type::Int);              } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedInt);      } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Long);             } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLong);     } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_Type::LongLong);         } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong); } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_Type::Float);            } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_Type::Double);           } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_Type::LongDouble);       } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Bool);             } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_Type::VoidPointer);      } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_Type::String);           } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector2);          } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector3);          } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector4);          } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_Type::ColourValue);      } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_Type::Quaternion);       } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_Type::Radian);           } /** @brief Returns true if the current type equals the given type. */
-    template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_Type::Degree);           } /** @brief Returns true if the current type equals the given type. */
-
-    template <> inline bool MultiType::convert<void>()                 { this->reset(); return true; } /** @brief Deletes the content, type becomes MT_Type::Null. */
+    template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Char);             } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedChar);     } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_Type::Short);            } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedShort);    } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_Type::Int);              } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedInt);      } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Long);             } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLong);     } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_Type::LongLong);         } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong); } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_Type::Float);            } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_Type::Double);           } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_Type::LongDouble);       } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Bool);             } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_Type::VoidPointer);      } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_Type::String);           } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector2);          } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector3);          } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector4);          } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_Type::ColourValue);      } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_Type::Quaternion);       } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_Type::Radian);           } ///< Returns true if the current type equals the given type.
+    template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_Type::Degree);           } ///< Returns true if the current type equals the given type.
+
+    /// Deletes the content, type becomes MT_Type::Null.
+    template <> inline bool MultiType::convert<void>()                 { this->reset(); return true; }
 
     // Specialization to avoid ambiguities with the conversion operator
-    template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } ///< Converts the current value to the given type.
 
     // Specialization to avoid ambiguities with the conversion operator
-    template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } ///< Converts the current value to the given type.
+    template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } ///< Converts the current value to the given type.
 
     template <> _UtilExport void MultiType::createNewValueContainer(const char& value);
@@ -538,29 +572,30 @@
     template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Degree& value);
 
-    inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-    inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
-
-    inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }  /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
+
+    /// Assigns the given value and converts it to the current type.
+    inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }
 }
 
Index: code/trunk/src/libraries/util/MultiTypeValue.h
===================================================================
--- code/trunk/src/libraries/util/MultiTypeValue.h	(revision 7380)
+++ code/trunk/src/libraries/util/MultiTypeValue.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup MultiType
     @brief Declaration and Implementation of the MT_Value<T> class.
 
@@ -53,14 +54,17 @@
     {
     public:
-        /** @brief Constructor: Assigns the value and the type identifier. */
+        /// Constructor: Assigns the value and the type identifier.
         MT_Value(const T& value, MT_Type::Value type) : MT_ValueBase(type), value_(value) {}
 
-        /** @brief Creates a copy of itself. */
+        /// Creates a copy of itself.
         inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
 
-        /** @brief Resets the current value to the default. */
+        /// Resets the current value to the default.
         inline void reset() { this->value_ = zeroise<T>(); bHasDefaultValue_ = true; }
 
-        /** @brief Assigns the value of the other MultiType, converted to T. @param other The other MultiType */
+        /**
+            @brief Assigns the value of the other MultiType, converted to T.
+            @param other The other MultiType
+        */
         inline bool assimilate(const MultiType& other)
         {
@@ -76,87 +80,87 @@
         }
 
-        inline bool getValue(char*                 value) const { return convertValue<T, char                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned char*        value) const { return convertValue<T, unsigned char       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(short*                value) const { return convertValue<T, short               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned short*       value) const { return convertValue<T, unsigned short      >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(int*                  value) const { return convertValue<T, int                 >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned int*         value) const { return convertValue<T, unsigned int        >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long*                 value) const { return convertValue<T, long                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned long*        value) const { return convertValue<T, unsigned long       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long long*            value) const { return convertValue<T, long long           >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned long long*   value) const { return convertValue<T, unsigned long long  >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(float*                value) const { return convertValue<T, float               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(double*               value) const { return convertValue<T, double              >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Vector3*     value) const { return convertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Vector4*     value) const { return convertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::ColourValue* value) const { return convertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Quaternion*  value) const { return convertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Radian*      value) const { return convertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(orxonox::Degree*      value) const { return convertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-
-        inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !convertValue<char                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !convertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !convertValue<short               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !convertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !convertValue<int                 , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !convertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !convertValue<long                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !convertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !convertValue<long long           , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !convertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !convertValue<float               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !convertValue<double              , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !convertValue<long double         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !convertValue<bool                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !convertValue<void*               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !convertValue<std::string         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !convertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !convertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !convertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !convertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-
-        inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, NilValue<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, NilValue<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, NilValue<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, NilValue<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, NilValue<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, NilValue<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, NilValue<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, NilValue<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
-
-        /** @brief Puts the current value on the stream */
+        inline bool getValue(char*                 value) const { return convertValue<T, char                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned char*        value) const { return convertValue<T, unsigned char       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(short*                value) const { return convertValue<T, short               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned short*       value) const { return convertValue<T, unsigned short      >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(int*                  value) const { return convertValue<T, int                 >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned int*         value) const { return convertValue<T, unsigned int        >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(long*                 value) const { return convertValue<T, long                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned long*        value) const { return convertValue<T, unsigned long       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(long long*            value) const { return convertValue<T, long long           >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned long long*   value) const { return convertValue<T, unsigned long long  >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(float*                value) const { return convertValue<T, float               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(double*               value) const { return convertValue<T, double              >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Vector3*     value) const { return convertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Vector4*     value) const { return convertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::ColourValue* value) const { return convertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Quaternion*  value) const { return convertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Radian*      value) const { return convertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Degree*      value) const { return convertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+
+        inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !convertValue<char                , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !convertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !convertValue<short               , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !convertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !convertValue<int                 , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !convertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !convertValue<long                , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !convertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !convertValue<long long           , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !convertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !convertValue<float               , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !convertValue<double              , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !convertValue<long double         , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !convertValue<bool                , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !convertValue<void*               , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !convertValue<std::string         , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !convertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !convertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !convertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !convertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
+
+        inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
+        inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, NilValue<std::string         >()); } ///< Returns the current value, converted to the requested type.
+        inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, NilValue<orxonox::Vector2    >()); } ///< Returns the current value, converted to the requested type.
+        inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, NilValue<orxonox::Vector3    >()); } ///< Returns the current value, converted to the requested type.
+        inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, NilValue<orxonox::Vector4    >()); } ///< Returns the current value, converted to the requested type.
+        inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, NilValue<orxonox::ColourValue>()); } ///< Returns the current value, converted to the requested type.
+        inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, NilValue<orxonox::Quaternion >()); } ///< Returns the current value, converted to the requested type.
+        inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, NilValue<orxonox::Radian     >()); } ///< Returns the current value, converted to the requested type.
+        inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, NilValue<orxonox::Degree     >()); } ///< Returns the current value, converted to the requested type.
+
+        /// Puts the current value on the stream
         inline void toString(std::ostream& outstream) const { outstream << this->value_; }
 
-        /** @brief loads data from the bytestream (mem) into the MT and increases the bytestream pointer by the size of the data */
+        /// loads data from the bytestream (mem) into the MT and increases the bytestream pointer by the size of the data
         inline void importData( uint8_t*& mem )         { loadAndIncrease( /*(const T&)*/this->value_, mem ); }
-        /** @brief saves data from the MT into the bytestream (mem) and increases the bytestream pointer by the size of the data */
+        /// saves data from the MT into the bytestream (mem) and increases the bytestream pointer by the size of the data
         inline void exportData( uint8_t*& mem ) const   { saveAndIncrease( /*(const T&)*/this->value_, mem ); }
-        /** @brief returns the size of the data that would be saved by exportData */
+        /// returns the size of the data that would be saved by exportData
         inline uint8_t getSize() const { return returnSize( this->value_ ); }
 
-        T value_; //!< The stored value
+        T value_; ///< The stored value
     };
 
Index: code/trunk/src/libraries/util/OrxAssert.h
===================================================================
--- code/trunk/src/libraries/util/OrxAssert.h	(revision 7380)
+++ code/trunk/src/libraries/util/OrxAssert.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
 @file
+@ingroup ExceptionAssertion
 @brief
     Declaration of custom assertion facilities
@@ -41,6 +42,13 @@
 #include "OutputHandler.h"
 
-// define an assert macro that can display a message
 #ifndef NDEBUG
+/** Run time assertion like assert(), but with an embedded message.
+@details
+    The message will be printed as error with COUT(1). <br>
+    You can use the same magic here as you can with \ref ThrowException
+    @code
+        OrxAssert(condition, "Text: " << number << " more text");
+    @endcode
+*/
 #define OrxAssert(Assertion, ErrorMessage) \
     Assertion ? ((void)0) : (void)(orxonox::OutputHandler::getOutStream(1) << ErrorMessage << std::endl); \
Index: code/trunk/src/libraries/util/OrxEnum.h
===================================================================
--- code/trunk/src/libraries/util/OrxEnum.h	(revision 7380)
+++ code/trunk/src/libraries/util/OrxEnum.h	(revision 7401)
@@ -28,7 +28,6 @@
 
 /**
-@file
-@brief
-    Declaration of the OrxEnum class.
+    @file
+    @ingroup Util
 */
 
@@ -40,4 +39,22 @@
 namespace orxonox
 {
+    /** Lightweight enumeration class that can be extended at run time.
+    @details
+        The class accepts type int and also defines operator int(). Therefore
+        int and OrxEnum can be used interchangeably so you can extend the content
+        of the enumeration at run time by adding ints.
+    @par Declaring an OrxEnum
+        Write a struct that inherits OrxEnum and use some macros:
+        @code
+        struct MyEnum : OrxEnum<MyEnum>
+        {
+            OrxEnumConstructors(MyEnum);
+
+            static const int Value1 = -1;
+            static const int Value2 = 0;
+            static const int Value3 = Value2 + 10;
+        };
+        @endcode
+    */
     template <class T>
     struct OrxEnum
@@ -45,8 +62,8 @@
         public:
             OrxEnum() { }
-            OrxEnum(int type)                  { type_ = type; }
+            OrxEnum(int type)            { type_ = type; }
             OrxEnum(const T& instance)   { type_ = instance.type_; }
 
-            operator int()                     { return type_; }
+            operator int()               { return type_; }
             T& operator =(int type)      { type_ = type; return *this; }
             bool operator <(const T& right) const { return (type_ < right.type_); }
@@ -59,4 +76,5 @@
 }
 
+/// See orxonox::OrxEnum for more info
 #define OrxEnumConstructors(enumName)                        \
 enumName() { }                                               \
Index: code/trunk/src/libraries/util/OutputHandler.cc
===================================================================
--- code/trunk/src/libraries/util/OutputHandler.cc	(revision 7380)
+++ code/trunk/src/libraries/util/OutputHandler.cc	(revision 7401)
@@ -67,7 +67,4 @@
         @brief
             Gets temporary log path and starts the log file
-        @param outputHandler
-            This is only required to avoid another call to getInstance (this c'tor was
-            called from getInstance!)
         */
         LogFileWriter()
@@ -117,6 +114,6 @@
 
     private:
-        std::ofstream logFile_;     //! File handle for the log file
-        std::string   logFilename_; //! Filename of the log file
+        std::ofstream logFile_;     //!< File handle for the log file
+        std::string   logFilename_; //!< Filename of the log file
     };
 
@@ -162,7 +159,4 @@
         @brief
             Sets the right soft debug level and registers itself
-        @param outputHandler
-            This is only required to avoid another call to getInstance (this c'tor was
-            called from getInstance!)
         */
         MemoryLogWriter()
@@ -186,6 +180,6 @@
 
     private:
-        std::ostringstream                        buffer_; //! Stream object used to process the output
-        std::vector<std::pair<int, std::string> > output_; //! Vector containing ALL output
+        std::ostringstream                        buffer_; //!< Stream object used to process the output
+        std::vector<std::pair<int, std::string> > output_; //!< Vector containing ALL output
     };
 
Index: code/trunk/src/libraries/util/OutputHandler.h
===================================================================
--- code/trunk/src/libraries/util/OutputHandler.h	(revision 7380)
+++ code/trunk/src/libraries/util/OutputHandler.h	(revision 7401)
@@ -29,6 +29,7 @@
 /**
 @file
+@ingroup Util Output
 @brief
-    Declaration of classes related to output (logging).
+    Declaration of classes related to output (logging), most notably OutputHandler and OutputListener.
 */
 
@@ -50,11 +51,11 @@
         Denotes different levels of text output (log output)
 
-        0, None   : Very important output
-        1, Error  : Errors
-        2, Warning: Warnings
-        3, Info   : Information
-        4, Debug  : Debug information
-        5, Verbose: More debug information
-        6, Ultra  : Crazy debug information
+         - 0, None   : Very important output
+         - 1, Error  : Errors
+         - 2, Warning: Warnings
+         - 3, Info   : Information
+         - 4, Debug  : Debug information
+         - 5, Verbose: More debug information
+         - 6, Ultra  : Crazy debug information
     */
     namespace OutputLevel
@@ -79,11 +80,16 @@
     /**
     @brief
-        The OutputHandler acts like std::cout, but output isn't only shown in the console.
-
-        You can register your own listener for output by inheriting from OutputListner.
+        The OutputHandler acts like @c std::cout, but output isn't only shown in the console.
+
+        Output passed to the OutputHandler is distributed to all registered listeners,
+        for example the console, the logfile, or the ingame shell.
+
+        You can register your own listener for output by inheriting from OutputListener.
         And if you need the output previously processed, iterate over it with
-        OutputHandler::getOutputVector[Begin/End].
+        OutputHandler::getOutputVectorBegin and OutputHandler::getOutputVectorEnd.
+
         The way to output text is to first set the desired output level with
-        OutputHandler::getOutStream(level) and then use the "<<" operator like with std::cout.
+        @ref getOutStream "OutputHandler::getOutStream(level)" and then use
+        the "<<" operator like with @c std::cout. Alternatively you can use the COUT() macro.
     */
     class _UtilExport OutputHandler
@@ -213,5 +219,5 @@
             OutputHandler();
             ~OutputHandler();
-            OutputHandler(const OutputHandler& rhs); //! Unused and undefined
+            OutputHandler(const OutputHandler& rhs);      //!< Copy-constructor: Unused and undefined
 
             std::list<OutputListener*> listeners_;        //!< Array with all registered output listeners
Index: code/trunk/src/libraries/util/Scope.cc
===================================================================
--- code/trunk/src/libraries/util/Scope.cc	(revision 7380)
+++ code/trunk/src/libraries/util/Scope.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Static linkage of the two maps in orxonox::ScopeManager.
+*/
+
 #include "Scope.h"
 
Index: code/trunk/src/libraries/util/Scope.h
===================================================================
--- code/trunk/src/libraries/util/Scope.h	(revision 7380)
+++ code/trunk/src/libraries/util/Scope.h	(revision 7401)
@@ -27,4 +27,27 @@
  */
 
+/**
+@file
+@ingroup SingletonScope
+@brief Declaration of the classes that are needed to use Scopes:
+orxonox::Scope, orxonox::ScopeListener, and orxonox::ScopeManager.
+
+@anchor Scope
+
+A virtual scope can be represented by an instance of class orxonox::Scope. orxonox::Scope<@a scope> is a template
+an its template argument defines the name of the virtual scope. See orxonox::ScopeID for an enumeration of the
+available values for @a scope. The orxonox::Scope object for a given @a scope can be activated or deactivated.
+Instances of orxonox::ScopeListener can register for a given @a scope and will get a notification if the
+corresponding orxonox::Scope object changes its state.
+
+To avoid multiple instances of orxonox::Scope<@a scope> in different libraries, each instance of orxonox::Scope
+registers in orxonox::ScopeManager, where they are linked statically in the util library.
+
+Scopes are usually used to control the creation and destruction of Singletons.
+
+@see orxonox::ScopedSingletonManager
+@see orxonox::Singleton
+*/
+
 #ifndef __Util_Scope_H__
 #define __Util_Scope_H__
@@ -42,5 +65,11 @@
 {
     /**
-        @brief The ScopeManager stores the variables of the scope templates in a statically linked context.
+        @brief The ScopeManager stores the variables of the Scope templates in a statically linked context.
+
+        If all Scope objects are managed by this class, they are statically linked in the util library.
+        Without this, a new instance of Scope<T> for each T would be created in every library of Orxonox,
+        which is of course not the desired behavior.
+
+        @see See @ref Scope "this description" for details about the interrelationship of Scope, ScopeListener, and ScopeManager.
     */
     class _UtilExport ScopeManager
@@ -56,5 +85,8 @@
 
     /**
-        @brief ScopeListeners register themselves in the corresponding scope and wait for notifications.
+        @brief ScopeListeners register themselves in the corresponding Scope and wait for notifications.
+        Notifications are sent if a Scope is activated or deactivated.
+
+        @see See @ref Scope "this description" for details about the interrelationship of Scope, ScopeListener, and ScopeManager.
     */
     class _UtilExport ScopeListener
@@ -86,4 +118,6 @@
         Objects inheriting from a ScopeListener are registered in a list (different for each scope).
         If the scope gets activated or deactivated, all objects in this list are notified.
+
+        @see See @ref Scope "this description" for details about the interrelationship of Scope, ScopeListener, and ScopeManager.
     */
     template <ScopeID::Value scope>
@@ -130,4 +164,5 @@
             }
 
+            //! Deactivates the listeners of this scope in case the scope is destroyed or the construction fails.
             void deactivateListeners()
             {
Index: code/trunk/src/libraries/util/ScopedSingletonManager.cc
===================================================================
--- code/trunk/src/libraries/util/ScopedSingletonManager.cc	(revision 7380)
+++ code/trunk/src/libraries/util/ScopedSingletonManager.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Static linkage of the ScopedSingletonManager maps.
+*/
+
 #include "ScopedSingletonManager.h"
 
Index: code/trunk/src/libraries/util/ScopedSingletonManager.h
===================================================================
--- code/trunk/src/libraries/util/ScopedSingletonManager.h	(revision 7380)
+++ code/trunk/src/libraries/util/ScopedSingletonManager.h	(revision 7401)
@@ -26,4 +26,19 @@
  *
  */
+
+/**
+    @file
+    @ingroup SingletonScope
+    @brief Definition of orxonox::ScopedSingletonManager, orxonox::ClassScopedSingletonManager, and the ManageScopedSingleton macro.
+
+    ScopedSingletonManager is used to create and destroy Singletons that belong to
+    a given Scope. For each one of these singletons, the macro ManageScopedSingleton()
+    has to be called to register the singleton with orxonox::ScopedSingletonManager.
+
+    See @ref SingletonExample "this code" for an example.
+
+    @see orxonox::Singleton
+    @see orxonox::Scope
+*/
 
 #ifndef __ScopedSingletonManager_H__
@@ -38,4 +53,13 @@
 #include "util/Singleton.h"
 
+/**
+    @brief Registers an orxonox::Singleton with orxonox::ScopedSingletonManager.
+    @param className The name of the singleton class
+    @param scope The scope in which the singleton should exist
+    @param allowedToFail If true, the singleton is allowed to fail and thus a try-catch block is used when creating the singleton.
+
+    If this macro is called for a singleton, it is registered with ScopedSingletonManager
+    and will thus be created if its scope becomes active and destroyed if is deactivated.
+*/
 #define ManageScopedSingleton(className, scope, allowedToFail) \
     className* className::singletonPtr_s = NULL; \
@@ -46,7 +70,14 @@
     class OrxonoxClass;
 
+    /**
+        @brief Base class of ClassScopedSingletonManager, implements some static functions
+        used to dispatch calls to preUpdate and postUpdate to all instances of this class.
+        It also keeps track of all existing ScopedSingletonManagers and stores them in a
+        map, sorted by the scope they belong to.
+    */
     class _UtilExport ScopedSingletonManager
     {
         public:
+            /// Constructor: Initializes all the values
             ScopedSingletonManager(const std::string& className, ScopeID::Value scope)
                 : className_(className)
@@ -54,6 +85,9 @@
             { }
             virtual ~ScopedSingletonManager() { }
+
+            /// Adds a new instance of ScopedSingletonManager to the map.
             static void addManager(ScopedSingletonManager* manager);
 
+            /// Calls preUpdate in all instances of ScopedSingletonManager that are registered in the map.
             template<ScopeID::Value scope>
             static void preUpdate(const Clock& time)
@@ -64,4 +98,6 @@
             }
             virtual void preUpdate(const Clock& time) = 0;
+
+            /// Calls postUpdate in all instances of ScopedSingletonManager that are registered in the map.
             template<ScopeID::Value scope>
             static void postUpdate(const Clock& time)
@@ -78,12 +114,29 @@
 
         protected:
-            const std::string className_;
-            const ScopeID::Value scope_;
+            const std::string className_;   ///< The name of the scoped singleton class that is managed by this object
+            const ScopeID::Value scope_;    ///< The scope of the singleton that is managed by this object
     };
 
+    /**
+        @anchor ClassScopedSingletonManager
+
+        @brief Manages a scoped singleton for a given scope.
+        @param T The managed singleton class
+        @param scope The scope in which the singleton @a T should be active
+        @param allowedToFail If true, a specialization of this template is used, that uses try-catch blocks to handle possible failures.
+
+        This class inherits from ScopeListener for the given scope and thus its functions
+        activated() and deactivated() are called whenever the Scope changes its state.
+
+        If the Scope is activated, a new instance of @a T (which must be a singleton) is created.
+        If the Scope is deactivated, the singleton is destroyed.
+
+        @see Singleton
+    */
     template <class T, ScopeID::Value scope, bool allowedToFail>
     class ClassScopedSingletonManager : public ScopedSingletonManager, public ScopeListener
     {
     public:
+        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonManager and ScopeListener
         ClassScopedSingletonManager(const std::string& className)
             : ScopedSingletonManager(className, scope)
@@ -113,8 +166,10 @@
         }
 
+        //! Destroys the singleton instance - overloaded for OrxonoxClass, calls OrxonoxClass::destroy()
         void destroy(OrxonoxClass*)
         {
             singletonPtr_->destroy();
         }
+        //! Destroys the singleton instance - overloaded for all other pointers, calls delete
         void destroy(void*)
         {
@@ -139,11 +194,22 @@
 
     private:
-        T* singletonPtr_;
+        T* singletonPtr_;   ///< Unique instance of the singleton class @a T
     };
 
+    /**
+        @brief This class partially spezializes ClassScopedSingletonManager for classes @a T that are allowed to fail.
+        @param T The managed singleton class
+        @param scope The scope in which the singleton @a T should be active
+
+        Because @a T could fail when being created, this partial spezialization of ClassScopedSingletonManager
+        uses a try-catch block to handle exceptions.
+
+        See @ref ClassScopedSingletonManager for a full documentation of the basis template.
+    */
     template <class T, ScopeID::Value scope>
     class ClassScopedSingletonManager<T, scope, true> : public ScopedSingletonManager, public ScopeListener
     {
     public:
+        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonManager and ScopeListener
         ClassScopedSingletonManager(const std::string& className)
             : ScopedSingletonManager(className, scope)
@@ -180,8 +246,10 @@
         }
 
+        //! Destroys the singleton instance - overloaded for OrxonoxClass, calls OrxonoxClass::destroy()
         void destroy(OrxonoxClass* ptr)
         {
             singletonPtr_->destroy();
         }
+        //! Destroys the singleton instance - overloaded for void*, calls delete
         void destroy(void* ptr)
         {
@@ -208,5 +276,5 @@
 
     private:
-        T* singletonPtr_;
+        T* singletonPtr_;   ///< Unique instance of the singleton class @a T
     };
 }
Index: code/trunk/src/libraries/util/Serialise.h
===================================================================
--- code/trunk/src/libraries/util/Serialise.h	(revision 7380)
+++ code/trunk/src/libraries/util/Serialise.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup Util
     @brief Functions to serialise most of the types/classed used in Orxonox
 */
@@ -53,12 +54,12 @@
     template <class T> inline bool checkEquality( const T& variable, uint8_t* mem );
 
-  
+
   // =========== char*
-    
+
   inline uint32_t returnSize( char*& variable )
   {
     return strlen(variable)+1;
   }
-      
+
   inline void saveAndIncrease( char*& variable, uint8_t*& mem )
   {
@@ -66,5 +67,5 @@
     mem += returnSize(variable);
   }
-        
+
   inline void loadAndIncrease( char*& variable, uint8_t*& mem )
   {
@@ -76,10 +77,10 @@
     mem += len;
   }
-          
+
   inline bool checkEquality( char*& variable, uint8_t* mem )
   {
     return strcmp(variable, (char*)mem)==0;
   }
-    
+
 // =================== Template specialisation stuff =============
 
@@ -423,5 +424,5 @@
         return memcmp(&temp, mem, sizeof(uint64_t))==0;
     }
-        
+
 // =========== string
 
Index: code/trunk/src/libraries/util/SharedPtr.cc
===================================================================
--- code/trunk/src/libraries/util/SharedPtr.cc	(revision 7380)
+++ code/trunk/src/libraries/util/SharedPtr.cc	(revision 7401)
@@ -27,12 +27,20 @@
  */
 
+/**
+    @file
+    @brief Static linkage of the SmallObjectAllocator used by SharedPtr.
+*/
+
 #include "SharedPtr.h"
 
 namespace orxonox
 {
-    SmallObjectAllocator& createSharedCounterPool()
+    namespace detail
     {
-        static SmallObjectAllocator instance(sizeof(SharedCounterImpl<void>));
-        return instance;
+        SmallObjectAllocator& createSharedCounterPool()
+        {
+            static SmallObjectAllocator instance(sizeof(SharedCounterImpl<void>));
+            return instance;
+        }
     }
 }
Index: code/trunk/src/libraries/util/SharedPtr.h
===================================================================
--- code/trunk/src/libraries/util/SharedPtr.h	(revision 7380)
+++ code/trunk/src/libraries/util/SharedPtr.h	(revision 7401)
@@ -27,4 +27,121 @@
  */
 
+/**
+    @defgroup SharedPtr SharedPtr<T>
+    @ingroup Util
+*/
+
+/**
+    @file
+    @ingroup SharedPtr
+    @brief Definition of the SharedPtr template that is used to manage pointers.
+
+    @anchor SharedPtrExample
+
+    The orxonox::SharedPtr template can be used to manage a pointer to an object
+    that was created with new. The SharedPtr acts like the pointer itself, but it
+    keeps track of the number of references to it. If all references are removed,
+    SharedPtr deletes the managed object automatically.
+
+    Example:
+
+    Classic implementation using new and delete:
+    @code
+    void someFunction()
+    {
+        MyClass* object = new MyClass();            // Create a new instance of MyClass
+
+        object->myFunction();                       // Calls MyClass::myFunction()
+
+        delete object;                              // Delete the object at the end of the scope
+    }
+    @endcode
+
+    The same function using SharedPtr:
+    @code
+    void someFunction()
+    {
+        SharedPtr<MyClass> object = new MyClass();  // Create a new instance of MyClass and store its pointer in a SharedPtr
+
+        object->myFunction();                       // Calls MyClass::myFunction()
+
+    }                                               // At the end of the scope, the SharedPtr is destroyed. Because no other SharedPtrs
+                                                    // point at the object, the object itself is also destroyed automatically
+    @endcode
+
+    This is especially handy if you do not know what will happen with an object that was
+    created with new, for example if you pass it to another object. If multiple instances
+    share a pointer to the same object, none of these instances can delete the object
+    without interfering with the other instances. But if none of the instances destroy the
+    object, it will never be destroyed and results in a memory leak. With a SharedPtr
+    however you don't have to think about destroying the object, because the SharedPtr
+    itself keeps track of the references.
+
+    Example:
+
+    Classic implementation using new and delete:
+    @code
+    class OtherClass                                    // Declaration of some class
+    {
+        public:
+            OtherClass(MyClass* object)                 // Constructor
+            {
+                this->object_ = object;                 // Assigns the pointer to the member variable object_
+            }
+
+            ~OtherClass()                               // Destructor
+            {
+                ???                                     // What to do with object_?
+            }
+
+        private:
+            MyClass* object_;                           // A pointer to the object
+    };
+
+    void someFunction()
+    {
+        MyClass* object = new MyClass();                // Create a new instance of MyClass
+
+        OtherClass* other1 = new OtherClass(object);    // Create an instance of OtherClass and pass the object pointer
+        OtherClass* other2 = new OtherClass(object);    // "
+        OtherClass* other3 = new OtherClass(object);    // "
+
+        ???                                             // What happens with object now?
+    }
+    @endcode
+
+    If you use SharedPtr<MyClass> instead of a classic MyClass* pointer, the instance of
+    MyClass would be automatically destroyed if all instances of OtherClass are destroyed.
+    You don't need any code in the destructor and you can completely forget about the
+    object, because its managed by the SharedPtr.
+
+    The same code using SharedPtr:
+    @code
+    class OtherClass                                        // Declaration of some class
+    {
+        public:
+            OtherClass(const SharedPtr<MyClass>& object)    // Constructor
+            {
+                this->object_ = object;                     // Assigns the pointer to the member variable object_
+            }
+
+        private:
+            SharedPtr<MyClass> object_;                     // A SharedPtr to the object
+    };
+
+    void someFunction()
+    {
+        SharedPtr<MyClass> object = new MyClass();          // Create a new instance of MyClass
+
+        OtherClass* other1 = new OtherClass(object);        // Create an instance of OtherClass and pass the object pointer
+        OtherClass* other2 = new OtherClass(object);        // "
+        OtherClass* other3 = new OtherClass(object);        // "
+
+    }                                                       // The SmartPtr "object" is destroyed at the end of the scope,
+                                                            // but the three instances of OtherClass keep the object alive
+                                                            // until they are all destroyed.
+    @endcode
+*/
+
 #ifndef _SharedPtr_H__
 #define _SharedPtr_H__
@@ -39,36 +156,55 @@
 namespace orxonox
 {
-    class SharedCounter
-    {
-        public:
-            SharedCounter() : count_(1) {}
-            virtual void destroy() = 0;
-
-            int count_;
-    };
-
-    template <class T>
-    class SharedCounterImpl : public SharedCounter
-    {
-        public:
-            SharedCounterImpl(T* pointer) : pointer_(pointer) {}
-
-            void destroy()
-            {
-                delete this->pointer_;
-            }
-
-        private:
-            T* pointer_;
-    };
-
-    _UtilExport SmallObjectAllocator& createSharedCounterPool();
-
-    FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
-    {
-        static SmallObjectAllocator& instance = createSharedCounterPool();
-        return instance;
+    namespace detail
+    {
+        /// BaseClass of SharedCounterImpl, has a counter that is initialized with 1
+        class SharedCounter
+        {
+            public:
+                SharedCounter() : count_(1) {}
+                virtual void destroy() = 0;
+
+                int count_;
+        };
+
+        /// Child class of SharedCounter, keeps a pointer to an object of type T that can be destroyed with destroy()
+        template <class T>
+        class SharedCounterImpl : public SharedCounter
+        {
+            public:
+                SharedCounterImpl(T* pointer) : pointer_(pointer) {}
+
+                void destroy()
+                {
+                    delete this->pointer_;
+                }
+
+            private:
+                T* pointer_;
+        };
+
+        _UtilExport SmallObjectAllocator& createSharedCounterPool();
+
+        FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
+        {
+            static SmallObjectAllocator& instance = createSharedCounterPool();
+            return instance;
+        }
     }
 
+    /**
+        @brief The SharedPtr template is a utility to manage pointers to an object.
+        @param T The type of the managed object
+
+        SharedPtr acts like a real pointer, except that it keeps track of the number of
+        references to the object. If the the number of references drops to zero, the
+        object is destroyed automatically.
+
+        @see See @ref SharedPtrExample "this description" for some examples and more information.
+
+        @note The number of references is stored in a separate object that is shared
+        among all instances of SharedPtr that point to the same pointer. This object is
+        also responsible for destroying the pointer if the reference counter becomes zero.
+    */
     template <class T>
     class SharedPtr
@@ -78,17 +214,20 @@
 
         public:
+            /// Default constructor, the pointer is set to NULL.
             inline SharedPtr() : pointer_(0), counter_(0)
             {
             }
 
+            /// Constructor, creates a SharedPtr that points to @a pointer, increments the counter.
             inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0)
             {
                 if (this->pointer_)
                 {
-                    void* chunk = getSharedCounterPool().alloc();
-                    this->counter_ = new (chunk) SharedCounterImpl<T>(this->pointer_);
+                    void* chunk = detail::getSharedCounterPool().alloc();
+                    this->counter_ = new (chunk) detail::SharedCounterImpl<T>(this->pointer_);
                 }
             }
 
+            /// Copy-constructor, this SharedPtr now points to the same object like the other SharedPtr, increments the counter.
             inline SharedPtr(const SharedPtr& other) : pointer_(other.pointer_), counter_(other.counter_)
             {
@@ -97,4 +236,5 @@
             }
 
+            /// Copy-constructor for SharedPtr with another template agument, increments the counter.
             template <class O>
             inline SharedPtr(const SharedPtr<O>& other) : pointer_(other.pointer_), counter_(other.counter_)
@@ -104,4 +244,5 @@
             }
 
+            /// Destructor, decrements the counter and deletes the object if the counter becomes zero.
             inline ~SharedPtr()
             {
@@ -113,9 +254,10 @@
                     {
                         this->counter_->destroy();
-                        getSharedCounterPool().free(this->counter_);
+                        detail::getSharedCounterPool().free(this->counter_);
                     }
                 }
             }
 
+            /// Assigns a new object, decrements the counter of the old object, increments the counter of the new object.
             inline SharedPtr& operator=(const SharedPtr& other)
             {
@@ -124,4 +266,5 @@
             }
 
+            /// Assigns a new object with another template argument, decrements the counter of the old object, increments the counter of the new object.
             template <class O>
             inline SharedPtr& operator=(const SharedPtr<O>& other)
@@ -131,4 +274,5 @@
             }
 
+            /// Casts the pointer to another type
             template <class O>
             inline SharedPtr<O> cast() const
@@ -138,4 +282,5 @@
             }
 
+            /// Overloaded -> operator, returns the pointer to the managed object.
             inline T* operator->() const
             {
@@ -144,4 +289,5 @@
             }
 
+            /// Overloaded * operator, returns a reference ot the managed object.
             inline T& operator*() const
             {
@@ -150,4 +296,5 @@
             }
 
+            /// Returns the pointer to the managed object.
             inline T* get() const
             {
@@ -155,4 +302,5 @@
             }
 
+            /// Returns true if the pointer is not NULL.
             inline operator bool() const
             {
@@ -160,4 +308,5 @@
             }
 
+            /// Swaps the pointer and the counter of two instances of SharedPtr with the same template argument.
             inline void swap(SharedPtr& other)
             {
@@ -167,5 +316,6 @@
 
         private:
-            inline SharedPtr(T* pointer, SharedCounter* counter) : pointer_(pointer), counter_(counter)
+            /// Private constructor, used by the cast() function.
+            inline SharedPtr(T* pointer, detail::SharedCounter* counter) : pointer_(pointer), counter_(counter)
             {
                 if (this->pointer_)
@@ -173,8 +323,39 @@
             }
 
-            T* pointer_;
-            SharedCounter* counter_;
+            T* pointer_;                        ///< A pointer to the managed object of type @a T
+            detail::SharedCounter* counter_;    ///< A pointer to the shared reference counter
     };
 
+    /**
+        @brief A child class of SharedPtr, used to reflect the hierarchy of the underlying class @a T.
+        @param T The type of the managed object
+        @param Parent The type of the SharedPtr that manages the parent class of @a T
+
+        This class is used to reflect the hierarchy of the underlying class @a T.
+        For example the @c Functor classes: While a @c Functor* pointer would be managed by
+        @c SharedPtr<Functor>, the child class @c FunctorStatic is managed by the class
+        <tt>SharedChildPtr<FunctorStatic, SharedPtr<Functor> ></tt>.
+
+        The second template argument @a Parent is used as the parent class of
+        SharedChildPtr. This means that each instance of <tt>SharedChildPtr<T, Parent></tt>
+        can be upcasted to @c Parent.
+
+        So for example this works:
+        @code
+        SharedChildPtr<FunctorStatic, SharedPtr<Functor> > functorStatic = createFunctor(&MyClass::myStaticFunction);
+        SharedPtr<Functor> functor = functorStatic;
+        @endcode
+
+        @note There are some typedefs and more to make the usage of SharedChildPtr easier
+        for the classes Functor and Executor. See FunctorPtr.h and ExecutorPtr.h. The above
+        example could thus be simplified the following way:
+        @code
+        FunctorStaticPtr functorStatic = createFunctor(&MyClass::myStaticFunction);
+        FunctorPtr functor = functorStatic;
+        @endcode
+
+        @see See SharedPtr for more information about the base class SharedPtr.
+        @see See @ref SharedPtrExample "this description" for some examples about how to use SharedPtr.
+    */
     template <class T, class Parent>
     class SharedChildPtr : public Parent
Index: code/trunk/src/libraries/util/SignalHandler.h
===================================================================
--- code/trunk/src/libraries/util/SignalHandler.h	(revision 7380)
+++ code/trunk/src/libraries/util/SignalHandler.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup Util
     @brief Declaration of the SignalHandler class.
 */
@@ -68,4 +69,5 @@
     typedef std::list<SignalCallbackRec> SignalCallbackList;
 
+    /// The SignalHandler is used to catch signals like SIGSEGV and write a backtrace to the logfile.
     class SignalHandler : public Singleton<SignalHandler>
     {
@@ -99,4 +101,5 @@
 namespace orxonox
 {
+    /// The SignalHandler is used to catch signals like SIGSEGV and write a backtrace to the logfile. Not implemented on Windows.
     class _UtilExport SignalHandler : public Singleton<SignalHandler>
     {
Index: code/trunk/src/libraries/util/Singleton.h
===================================================================
--- code/trunk/src/libraries/util/Singleton.h	(revision 7380)
+++ code/trunk/src/libraries/util/Singleton.h	(revision 7401)
@@ -27,4 +27,84 @@
  */
 
+/**
+    @defgroup SingletonScope Singletons and Scope
+    @ingroup Util
+*/
+
+/**
+    @file
+    @ingroup SingletonScope
+    @brief Definition of the Singleton template that is used as base class for classes that allow only one instance.
+
+    @anchor SingletonExample
+
+    Classes that inherit from orxonox::Singleton follow the singleton pattern and thus
+    allow only one instance of the class to exist. This istance is stored in a static
+    variable called @c singletonPtr_s. orxonox::Singleton will access this variable, but
+    it must be implemented in the deriving class.
+
+    Example:
+    @code
+    class TestSingleton : public Singleton<TestSingleton>   // inherit from Singleton, pass the own class as template argument
+    {
+        friend class Singleton<TestSingleton>;              // friend declaration so Singleton can access singletonPtr_s
+
+        public:
+            TestSingleton();                                // public constructor because we may want to manage this singleton
+                                                            //     with an orxonox::ScopedSingletonManager (see below)
+            virtual ~TestSingleton();                       // public destructor
+
+            void testFunction();                            // put your functions here
+
+        private:
+            int testValue_;                                 // put your variables here
+
+            static TestSingleton* singletonPtr_s;           // static singleton instance pointer, used by the Singleton template
+    };
+    @endcode
+
+    And don't forget to initialize the static singleton pointer in the source (*.cc) %file:
+    @code
+    TestSingleton* TestSingleton::singletonPtr_s = NULL;
+    @endcode
+
+    Usually a singleton gets created automatically when it is first used, but it will never
+    be destroyed (unless the singleton explicitly deletes itself). To allow controlled
+    construction and destruction, the singleton can be put within a virtual scope. This is
+    done by registering the singleton class with orxonox::ScopedSingletonManager. To
+    do so, the ManageScopedSingleton() macro has to be called:
+
+    @code
+    ManageScopedSingleton(TestSingleton, ScopeID::Graphics, false); // muste be called in a source (*.cc) file
+    @endcode
+
+    @b Important: If you call ManageScopedSingleton(), you don't have to initialize singletonPtr_s anymore,
+    because that's already done by the macro.
+
+    Now the singleton TestSingleton gets automatically created if the scope Graphics becomes
+    active and also gets destroyed if the scope is deactivated.
+
+    Note that not all singletons must register with a scope, but it's recommended.
+
+    If a class inherits from orxonox::Singleton, it also inherits its functions. The most important
+    function is orxonox::Singleton::getInstance() which returns a reference to the only instance
+    of the singleton.
+
+    Example:
+    @code
+    TestSingleton::TestSingleton()                          // implement the constructor
+    {
+        this->testValue_ = 15;
+    }
+
+    void TestSingleton::testFunction()                      // implement testFunction
+    {
+        COUT(0) << "My value is " << this->testValue_ << std::endl;
+    }
+
+    TestSingleton::getInstance().testFunction();            // prints "My value is 15"
+    @endcode
+*/
+
 #ifndef __Util_Singleton_H__
 #define __Util_Singleton_H__
@@ -42,7 +122,8 @@
 
         Usage:
-        Inherit publicly from Singleton<MyClass> and provide access to
-        MyClass::singletonPtr_s.
+        Inherit publicly from Singleton<MyClass> and provide access to MyClass::singletonPtr_s.
         This can easily be done with a friend declaration.
+
+        See @ref SingletonExample "this example" for an exemplary implementation.
     */
     template <class T>
@@ -80,5 +161,5 @@
         }
 
-        //! Constructor resets the singleton instance pointer
+        //! Destructor resets the singleton instance pointer
         ~Singleton()
         {
Index: code/trunk/src/libraries/util/SmallObjectAllocator.cc
===================================================================
--- code/trunk/src/libraries/util/SmallObjectAllocator.cc	(revision 7380)
+++ code/trunk/src/libraries/util/SmallObjectAllocator.cc	(revision 7401)
@@ -27,15 +27,28 @@
  */
 
+/**
+    @file
+    @brief Implementation of SmallObjectAllocator
+*/
+
 #include "SmallObjectAllocator.h"
 
 namespace orxonox
 {
+    /**
+        @brief Constructor: initializes the allocator and its values.
+        @param objectSize The size in bytes (returned by sizeof()) of the allocated objects
+        @param numObjects The number of objects that are allocated in one block of memory
+    */
     SmallObjectAllocator::SmallObjectAllocator(size_t objectSize, size_t numObjects)
     {
-        this->objectSize_ = std::max(objectSize, sizeof(Chunk));
-        this->numObjects_ = numObjects;
+        this->chunkSize_ = std::max(objectSize, sizeof(Chunk)); // the chunk's size will be the maximum of the object's size and the size of a Chunk object itself
+        this->numChunksPerBlock_ = numObjects;
         this->first_ = 0;
     }
 
+    /**
+        @brief Destructor: deletes the allocated memory blocks.
+    */
     SmallObjectAllocator::~SmallObjectAllocator()
     {
@@ -44,4 +57,7 @@
     }
 
+    /**
+        @brief Helper function, used to set the next_ pointer of a Chunk.
+    */
     /* static */ void SmallObjectAllocator::setNext(void* chunk, void* next)
     {
@@ -49,4 +65,7 @@
     }
 
+    /**
+        @brief Helper function, returns the next_ pointer of a Chunk
+    */
     /* static */ void* SmallObjectAllocator::getNext(void* chunk)
     {
@@ -54,32 +73,48 @@
     }
 
+    /**
+        @brief Returns the first free memory chunk or allocates a new block of memory.
+    */
     void* SmallObjectAllocator::alloc()
     {
+        // get the first free chunk
         void* chunk = this->first_;
 
+        // check if the chunk exists
         if (chunk)
         {
+            // yes it does - the first_ pointer now points to the second element in the list
             this->first_ = getNext(chunk);
         }
         else
         {
-            char* block = new char[this->objectSize_ * this->numObjects_];
+            // no it doesnt - allocate a new block of memory
+            char* block = new char[this->chunkSize_ * this->numChunksPerBlock_];
             this->blocks_.push_back(block);
 
-            for (size_t i = 1; i < this->numObjects_ - 1; ++i)
-                setNext(block + i * this->objectSize_, block + (i + 1) * this->objectSize_);
+            // iterate through the chunks in the new memory block and link them together to a single linked list
+            for (size_t i = 1; i < this->numChunksPerBlock_ - 1; ++i)
+                setNext(block + i * this->chunkSize_, block + (i + 1) * this->chunkSize_);
 
-            setNext(block + (this->numObjects_ - 1) * this->objectSize_, 0);
+            // the next_ pointer of the last chunk must point to NULL
+            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
 
-            this->first_ = block + this->objectSize_;
+            // The second chunk in the block is assigned to the first_ pointer
+            this->first_ = block + this->chunkSize_;
 
+            // The first chunk in the block is returned
             chunk = block;
         }
 
+        // return the pointer to the chunk
         return chunk;
     }
 
+    /**
+        @brief Puts the memory chunk back on the list of free memory.
+    */
     void SmallObjectAllocator::free(void* chunk)
     {
+        // The first_ pointer points to the freed chunk, its next_ pointer points to the rest of the list
         setNext(chunk, this->first_);
         this->first_ = chunk;
Index: code/trunk/src/libraries/util/SmallObjectAllocator.h
===================================================================
--- code/trunk/src/libraries/util/SmallObjectAllocator.h	(revision 7380)
+++ code/trunk/src/libraries/util/SmallObjectAllocator.h	(revision 7401)
@@ -27,4 +27,49 @@
  */
 
+/**
+    @defgroup SmallObjectAllocator SmallObjectAllocator
+    @ingroup Util
+*/
+
+/**
+    @file
+    @ingroup SmallObjectAllocator
+    @brief Declaration of SmallObjectAllocator
+
+    @anchor SmallObjectAllocatorExample
+
+    The default implementations of new and delete are designed to work with objects of
+    arbitrary size. They are thus not optimal for small objects.
+    @ref orxonox::SmallObjectAllocator "SmallObjectAllocator" allocates a large memory
+    block and divides it into small chunks. These chunks are returned by the function
+    @ref orxonox::SmallObjectAllocator::alloc() "alloc()" and can be used to create a
+    new object using the placement new operator. Instead of delete, the function
+    @ref orxonox::SmallObjectAllocator::free() "free()" is used to give the memory
+    back to SmallObjectAllocator.
+
+    Example:
+    @code
+    SmallObjectAllocator allocator(sizeof(MySmallObject));  // Create an allocator. The size of the memory chunks must equal the size of the desired class
+
+    void* chunk = allocator.alloc();                        // Allocate a memory chunk
+    MySmallObject* object = new (chunk) MySmallObject();    // Call the placement new operator
+
+    object->someFunction();                                 // Do something with the object
+
+    object->~MySmallObject();                               // Call the destructor
+    allocator.free(object);                                 // Free the allocated memory
+    @endcode
+
+    @b Important: You have to call the destructor of the object manually, because this
+    is not automatically done by the allocator nor free().
+
+    @note The destructor can be ignored if it is empty or not implemented. This saves
+    another amount of time.
+
+    @remarks For a distributed usage of SmallObjectAllocator it may be a good idea to
+    create a static function that returns an instance to it. The allocator then works
+    like a singleton and can be accesses from everywhere.
+*/
+
 #ifndef _SmallObjectAllocator_H__
 #define _SmallObjectAllocator_H__
@@ -35,9 +80,17 @@
 namespace orxonox
 {
+    /**
+        @brief This class is used to allocate and free small objects (usually not polymorphic).
+
+        SmallObjectAllocator provides a fast alternative to new and delete for small objects.
+
+        @see See @ref SmallObjectAllocatorExample "this description" for more information and an example.
+    */
     class _UtilExport SmallObjectAllocator
     {
+        /// The memory chunk is at the same time an element of a single linked list.
         struct Chunk
         {
-            Chunk* next_;
+            Chunk* next_;   ///< A pointer to the next chunk in the list
         };
 
@@ -53,9 +106,9 @@
             static void* getNext(void* chunk);
 
-            void* first_;
-            size_t objectSize_;
-            size_t numObjects_;
+            void* first_;                   ///< A pointer to the first free memory chunk
+            size_t chunkSize_;              ///< The size of each chunk (and usually also the size of the created objects)
+            size_t numChunksPerBlock_;      ///< The number of chunks per memory block
 
-            std::vector<char*> blocks_;
+            std::vector<char*> blocks_;     ///< A list of all allocated memory blocks (used to destroy them again)
     };
 }
Index: code/trunk/src/libraries/util/StringUtils.cc
===================================================================
--- code/trunk/src/libraries/util/StringUtils.cc	(revision 7380)
+++ code/trunk/src/libraries/util/StringUtils.cc	(revision 7401)
@@ -41,6 +41,8 @@
 namespace orxonox
 {
+    /// A blank string (""). Used to return a blank string by reference.
     std::string BLANKSTRING;
 
+    /// Returns a string of a unique number. This function is guaranteed to never return the same string twice.
     std::string getUniqueNumberString()
     {
@@ -48,8 +50,5 @@
     }
 
-    /**
-        @brief Removes all whitespaces from a string.
-        @param str The string to strip
-    */
+    /// Removes all whitespaces from a string.
     void strip(std::string* str)
     {
@@ -63,9 +62,5 @@
     }
 
-    /**
-        @brief Returns a copy of a string without whitespaces.
-        @param str The string to strip
-        @return The stripped line
-    */
+    /// Returns a copy of a string without whitespaces.
     std::string getStripped(const std::string& str)
     {
@@ -75,9 +70,5 @@
     }
 
-    /**
-        @brief Returns a copy of a string without trailing whitespaces.
-        @param str The string
-        @return The modified copy
-    */
+    /// Returns a copy of a string without trailing whitespaces.
     std::string removeTrailingWhitespaces(const std::string& str)
     {
@@ -90,8 +81,8 @@
 
     /**
-        @brief Returns the position of the next quote in the string, starting with start.
+        @brief Returns the position of the next quotation mark in the string, starting with start.
         @param str The string
-        @param start The startposition
-        @return The position of the next quote (std::string::npos if there is no next quote)
+        @param start The first position to look at
+        @return The position of the next quotation mark (@c std::string::npos if there is none)
     */
     size_t getNextQuote(const std::string& str, size_t start)
@@ -115,8 +106,8 @@
 
     /**
-        @brief Returns true if pos is between two quotes.
+        @brief Returns true if pos is between two quotation marks.
         @param str The string
         @param pos The position to check
-        @return True if pos is between two quotes
+        @return True if pos is between two quotation marks
     */
     bool isBetweenQuotes(const std::string& str, size_t pos)
@@ -140,9 +131,5 @@
     }
 
-    /**
-        @brief Returns true if the string contains something like '..."between quotes"...'.
-        @param The string
-        @return True if there is something between quotes
-    */
+    /// Returns true if the string contains something like '..."between quotaton marks"...'.
     bool hasStringBetweenQuotes(const std::string& str)
     {
@@ -152,9 +139,5 @@
     }
 
-    /**
-        @brief If the string contains something like '..."between quotes"...' then 'between quotes' gets returned (without quotes).
-        @param The string
-        @param The string between the quotes
-    */
+    /// If the string contains something like '..."between quotaton marks"...' then 'between quotaton marks' gets returned, otherwise "".
     std::string getStringBetweenQuotes(const std::string& str)
     {
@@ -168,7 +151,6 @@
 
     /**
-        @brief Removes enclosing quotes if available (including whitespaces at the outside of the quotes).
-        @brief str The string to strip
-        @return The string with removed quotes
+        @brief Removes enclosing quotation marks if available (including whitespaces at the outside of the quotation marks).
+        @return The striped string without quotation marks
     */
     std::string stripEnclosingQuotes(const std::string& str)
@@ -208,7 +190,6 @@
 
     /**
-        @brief Removes enclosing {braces} (braces must be exactly on the beginning and the end of the string).
-        @param str The string to strip
-        @return The striped string
+        @brief Removes enclosing braces '{' and '}' (the braces must be exactly on the beginning and the end of the string).
+        @return The striped string without braces
     */
     std::string stripEnclosingBraces(const std::string& str)
@@ -224,6 +205,4 @@
     /**
         @brief Determines if a string is a comment (starts with a comment-symbol).
-        @param str The string to check
-        @return True = it's a comment
 
         A comment is defined by a leading '#', '%', ';' or '//'.
@@ -253,9 +232,5 @@
     }
 
-    /**
-        @brief Determines if a string is empty (contains only whitespaces).
-        @param str The string to check
-        @return True = it's empty
-    */
+    /// Determines if a string is empty (contains only whitespaces).
     bool isEmpty(const std::string& str)
     {
@@ -263,9 +238,5 @@
     }
 
-    /**
-        @brief Determines if a string contains only numbers and maximal one '.'.
-        @param str The string to check
-        @return True = it's a number
-    */
+    /// Determines if a string contains only numbers and maximal one '.'.
     bool isNumeric(const std::string& str)
     {
@@ -288,6 +259,12 @@
     /**
         @brief Adds backslashes to the given string which makes special chars visible. Existing slashes will be doubled.
-        @param str The string to manipulate
-        @return The string with added slashes
+
+        This function converts all special chars like line breaks, tabs, quotation marks etc. into
+        a human readable format by adding a backslash. So for example "\n" will be converted to
+        "\\" + "n".
+
+        This is usually used when a string is written to a file.
+
+        @see removeSlashes
     */
     std::string addSlashes(const std::string& str)
@@ -320,6 +297,11 @@
     /**
         @brief Removes backslashes from the given string. Double backslashes are interpreted as one backslash.
-        @param str The string to manipulate
-        @return The string with removed slashes
+
+        This function removes all backslashes and converts the human readable equivalents of
+        special chars like "\\" + "n" into their real meaning (in this case a line break or "\n").
+
+        This is usually used when reading a string from a file.
+
+        @see addSlashes
     */
     std::string removeSlashes(const std::string& str)
@@ -361,8 +343,5 @@
     }
 
-    /**
-        @brief Replaces each char between A and Z with its lowercase equivalent.
-        @param str The string to convert
-    */
+    /// Replaces each char between A and Z with its lowercase equivalent.
     void lowercase(std::string* str)
     {
@@ -373,9 +352,5 @@
     }
 
-    /**
-        @brief Returns a copy of the given string without uppercase chars.
-        @param str The string
-        @return The copy
-    */
+    /// Returns a copy of the given string where all chars are converted to lowercase.
     std::string getLowercase(const std::string& str)
     {
@@ -385,8 +360,5 @@
     }
 
-    /**
-        @brief Replaces each char between a and z with its uppercase equivalent.
-        @param str The string to convert
-    */
+    /// Replaces each char between a and z with its uppercase equivalent.
     void uppercase(std::string* str)
     {
@@ -397,9 +369,5 @@
     }
 
-    /**
-        @brief Returns a copy of the given string without lowercase chars.
-        @param str The string
-        @return The copy
-    */
+    /// Returns a copy of the given string where all chars are converted to uppercase.
     std::string getUppercase(const std::string& str)
     {
@@ -411,6 +379,5 @@
     /**
         @brief Compares two strings ignoring different casing.
-        @param s1 First string
-        @param s2 Second string
+        @return s1 == s1 -> returns 0 / s1 < s2 -> returns -1 / s1 >= s2 -> returns 1
     */
     int nocaseCmp(const std::string& s1, const std::string& s2)
@@ -438,5 +405,5 @@
 
     /**
-        @brief Compares the first 'len' chars of two strings ignoring different casing.
+        @brief Compares the first @a len chars of two strings ignoring different casing.
         @param s1 First string
         @param s2 Second string
@@ -463,39 +430,26 @@
     }
 
-    /**
-        @brief Returns true if the string contains a comment, introduced by #, %, ; or //.
+    /// Returns true if the string contains a comment, introduced by #, %, ; or //.
+    bool hasComment(const std::string& str)
+    {
+        return (getCommentPosition(str) != std::string::npos);
+    }
+
+    /// If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
+    std::string getComment(const std::string& str)
+    {
+        return str.substr(getCommentPosition(str));
+    }
+
+    /// If the string contains a comment, the position of the comment-symbol gets returned, @c std::string::npos otherwise.
+    size_t getCommentPosition(const std::string& str)
+    {
+        return getNextCommentPosition(str, 0);
+    }
+
+    /**
+        @brief Returns the position of the next comment-symbol, starting with @a start.
         @param str The string
-        @return True if the string contains a comment
-    */
-    bool hasComment(const std::string& str)
-    {
-        return (getCommentPosition(str) != std::string::npos);
-    }
-
-    /**
-        @brief If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
-        @param str The string
-        @return The comment
-    */
-    std::string getComment(const std::string& str)
-    {
-        return str.substr(getCommentPosition(str));
-    }
-
-    /**
-        @brief If the string contains a comment, the position of the comment-symbol gets returned, std::string::npos otherwise.
-        @param str The string
-        @return The position
-    */
-    size_t getCommentPosition(const std::string& str)
-    {
-        return getNextCommentPosition(str, 0);
-    }
-
-    /**
-        @brief Returns the position of the next comment-symbol, starting with start.
-        @param str The string
-        @param start The startposition
-        @return The position
+        @param start The first position to look at
     */
     size_t getNextCommentPosition(const std::string& str, size_t start)
Index: code/trunk/src/libraries/util/StringUtils.h
===================================================================
--- code/trunk/src/libraries/util/StringUtils.h	(revision 7380)
+++ code/trunk/src/libraries/util/StringUtils.h	(revision 7401)
@@ -28,5 +28,11 @@
 
 /**
+    @defgroup String String functions
+    @ingroup Util
+*/
+
+/**
     @file
+    @ingroup String
     @brief Declaration of several string manipulation functions, used in many parts of the game.
 */
Index: code/trunk/src/libraries/util/SubString.cc
===================================================================
--- code/trunk/src/libraries/util/SubString.cc	(revision 7380)
+++ code/trunk/src/libraries/util/SubString.cc	(revision 7401)
@@ -38,233 +38,196 @@
  */
 
+/**
+    @file
+    @brief Implementation of the SubString class.
+*/
+
 #include "SubString.h"
 #include <cstdio>
+#include "Debug.h"
 
 namespace orxonox
 {
-    /**
-     * @brief default constructor
-     */
+    const std::string SubString::WhiteSpaces          = " \n\t";
+    const std::string SubString::WhiteSpacesWithComma = " \n\t,";
+    const SubString SubString::NullSubString          = SubString();
+
+    /**
+        @brief Default constructor.
+    */
     SubString::SubString()
-    {}
-
-
-    /**
-     * @brief create a SubString from
-     * @param string the String to Split
-     * @param delimiter the Character at which to split string (delimiter)
-     */
-    SubString::SubString(const std::string& string, char delimiter)
-    {
-        this->split(string, delimiter);
-    }
-
-
-    /**
-     * @brief Splits a String into multiple splitters.
-     * @param string the String to split
-     * @param delimiters multiple set of characters at what to split. (delimiters)
-     * @param delimiterNeighbours neighbours of the delimiters, that will be erased only when near a delimiter.
-     * @param emptyEntries If empty entries should be allewed or removed.
-     * @param escapeChar The Escape Character that overrides splitters commends and so on...
-     * @param safemode_char within these characters splitting won't happen
-     * @param comment_char the Comment character.
-     */
-    SubString::SubString(const std::string& string,
-                         const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
-                         char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,
-                         char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
-    {
-        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeEscapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
-    }
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subString the SubString to take a set from.
-     * @param subSetBegin the beginning to the end
-     */
-    SubString::SubString(const SubString& subString, unsigned int subSetBegin)
-    {
-        for (unsigned int i = subSetBegin; i < subString.size(); i++)
-        {
-            this->strings.push_back(subString[i]);
-            this->bInSafemode.push_back(subString.isInSafemode(i));
-        }
-    }
-
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subString the SubString to take a Set from
-     * @param subSetBegin the beginning to the end
-     * @param subSetEnd the end of the SubSet (max subString.size() will be checked internaly)
-     */
-    SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
-    {
-        for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
-        {
-            this->strings.push_back(subString[i]);
-            this->bInSafemode.push_back(subString.isInSafemode(i));
-        }
-    }
-
-    /**
-     * @brief creates a Substring from a count and values set.
-     * @param argc: the Arguments Count.
-     * @param argv: Argument Values.
-     */
+    {
+    }
+
+    /**
+        @brief Splits a string into multiple tokens.
+        @param line The line to split
+        @param delimiters Multiple characters at which to split the line
+        @param delimiterNeighbours Neighbours of the delimiters that will be erased as well (for example white-spaces)
+        @param bAllowEmptyEntries If true, empty tokens are also added to the SubString (if there are two delimiters without a char in between)
+        @param escapeChar The escape character that is used to escape safemode chars (for example if you want to use a quotation mark between two other quotation marks).
+        @param bRemoveEscapeChar If true, the escape char is removed from the tokens
+        @param safemodeChar Within these characters splitting won't happen (usually the quotation marks)
+        @param bRemoveSafemodeChar Removes the safemodeChar from the beginning and the ending of a token
+        @param openparenthesisChar The beginning of a safemode is marked with this (usually an opening brace)
+        @param closeparenthesisChar The ending of a safemode is marked with this (usually a closing brace)
+        @param bRemoveParenthesisChars Removes the parenthesis chars from the beginning and the ending of a token
+        @param commentChar The comment character (used to ignore the part of the line after the comment char).
+    */
+    SubString::SubString(const std::string& line,
+                         const std::string& delimiters, const std::string& delimiterNeighbours, bool bAllowEmptyEntries,
+                         char escapeChar, bool bRemoveEscapeChar, char safemodeChar, bool bRemoveSafemodeChar,
+                         char openparenthesisChar, char closeparenthesisChar, bool bRemoveParenthesisChars, char commentChar)
+    {
+        SubString::splitLine(this->tokens_, this->bTokenInSafemode_, line, delimiters, delimiterNeighbours, bAllowEmptyEntries, escapeChar, bRemoveEscapeChar, safemodeChar, bRemoveSafemodeChar, openparenthesisChar, closeparenthesisChar, bRemoveParenthesisChars, commentChar);
+    }
+
+    /**
+        @brief creates a new SubString based on a subset of an other SubString.
+        @param other The other SubString
+        @param begin The beginning of the subset
+
+        The subset ranges from the token with index @a begin to the end of the tokens.
+        If @a begin is greater than the greatest index, the new SubString will be empty.
+    */
+    SubString::SubString(const SubString& other, unsigned int begin)
+    {
+        for (unsigned int i = begin; i < other.size(); ++i)
+        {
+            this->tokens_.push_back(other[i]);
+            this->bTokenInSafemode_.push_back(other.isInSafemode(i));
+        }
+    }
+
+    /**
+        @brief creates a new SubString based on a subset of an other SubString.
+        @param other The other SubString
+        @param begin The beginning of the subset
+        @param end The end of the subset
+
+        The subset ranges from the token with index @a begin until (but not including) the token with index @a end.
+        If @a begin or @a end are beyond the allowed index, the resulting SubString will be empty.
+    */
+    SubString::SubString(const SubString& other, unsigned int begin, unsigned int end)
+    {
+        for (unsigned int i = begin; i < std::min(other.size(), end); ++i)
+        {
+            this->tokens_.push_back(other[i]);
+            this->bTokenInSafemode_.push_back(other.isInSafemode(i));
+        }
+    }
+
+    /**
+        @brief Creates a SubString from a count and values set.
+        @param argc The number of arguments
+        @param argv An array of pointers to the arguments
+    */
     SubString::SubString(unsigned int argc, const char** argv)
     {
         for(unsigned int i = 0; i < argc; ++i)
         {
-            this->strings.push_back(std::string(argv[i]));
-            this->bInSafemode.push_back(false);
-        }
-    }
-
-    /**
-     * @brief removes the object from memory
-     */
+            this->tokens_.push_back(std::string(argv[i]));
+            this->bTokenInSafemode_.push_back(false);
+        }
+    }
+
+    /**
+        @brief Destructor
+    */
     SubString::~SubString()
     { }
 
-    /** @brief An empty String */
-    // const std::string SubString::emptyString = "";
-    /** @brief Helper that gets you a String consisting of all White Spaces */
-    const std::string SubString::WhiteSpaces = " \n\t";
-    /** @brief Helper that gets you a String consisting of all WhiteSpaces and the Comma */
-    const std::string SubString::WhiteSpacesWithComma = " \n\t,";
-    /** An Empty SubString */
-    const SubString SubString::NullSubString = SubString();
-
-    /**
-     * @brief stores the Value of subString in this SubString
-     * @param subString will be copied into this String.
-     * @returns this SubString.
-     */
-    SubString& SubString::operator=(const SubString& subString)
-    {
-        this->strings = subString.strings;
-        this->bInSafemode = subString.bInSafemode;
+    /**
+        @brief Stores the tokens of @a other in this SubString
+        @return This SubString.
+    */
+    SubString& SubString::operator=(const SubString& other)
+    {
+        this->tokens_ = other.tokens_;
+        this->bTokenInSafemode_ = other.bTokenInSafemode_;
         return *this;
     }
 
-
-    /**
-     * @brief comparator.
-     * @param subString the SubString to compare against this one.
-     * @returns true if the Stored Strings match
-     */
-    bool SubString::operator==(const SubString& subString) const
-    {
-        return ((this->strings == subString.strings) && (this->bInSafemode == subString.bInSafemode));
-    }
-
-    /**
-     * @brief comparator.
-     * @param subString the SubString to compare against this one.
-     * @returns true if the Stored Strings match
-     */
-    bool SubString::compare(const SubString& subString) const
-    {
-        return (*this == subString);
-    }
-
-    /**
-     * @brief comparator.
-     * @param subString the SubString to compare against this one.
-     * @param length how many entries to compare. (from 0 to length)
-     * @returns true if the Stored Strings match
-     */
-    bool SubString::compare(const SubString& subString, unsigned int length) const
-    {
-        if (length > this->size() || length > subString.size())
+    /**
+        @brief Compares this SubString to another SubString and returns true if they contain the same values.
+    */
+    bool SubString::operator==(const SubString& other) const
+    {
+        return ((this->tokens_ == other.tokens_) && (this->bTokenInSafemode_ == other.bTokenInSafemode_));
+    }
+
+    /**
+        @copydoc operator==
+    */
+    bool SubString::compare(const SubString& other) const
+    {
+        return (*this == other);
+    }
+
+    /**
+        @brief Compares this SubString to another SubString and returns true if the first @a length values match.
+        @param other The other SubString
+        @param length How many tokens to compare
+    */
+    bool SubString::compare(const SubString& other, unsigned int length) const
+    {
+        if (length > this->size() || length > other.size())
             return false;
 
-        for (unsigned int i = 0; i < length; i++)
-            if ((this->strings[i] != subString.strings[i]) || (this->bInSafemode[i] != subString.bInSafemode[i]))
+        for (unsigned int i = 0; i < length; ++i)
+            if ((this->tokens_[i] != other.tokens_[i]) || (this->bTokenInSafemode_[i] != other.bTokenInSafemode_[i]))
                 return false;
         return true;
     }
 
-
-    /**
-     * @brief append operator
-     * @param subString the String to append.
-     * @returns a SubString where this and subString are appended.
-     */
-    SubString SubString::operator+(const SubString& subString) const
-    {
-        return SubString(*this) += subString;
-    }
-
-
-    /**
-     * @brief append operator.
-     * @param subString append subString to this SubString.
-     * @returns this substring appended with subString
-     */
-    SubString& SubString::operator+=(const SubString& subString)
-    {
-        for (unsigned int i = 0; i < subString.size(); i++)
-        {
-            this->strings.push_back(subString[i]);
-            this->bInSafemode.push_back(subString.isInSafemode(i));
+    /**
+        @brief Concatenates the tokens of two SubStrings and returns the resulting new SubString
+        @return A new SubString that contains the tokens of this and the other SubString
+    */
+    SubString SubString::operator+(const SubString& other) const
+    {
+        return SubString(*this) += other;
+    }
+
+    /**
+        @brief Appends the tokens of @a other to this SubString
+        @return This SubString
+    */
+    SubString& SubString::operator+=(const SubString& other)
+    {
+        for (unsigned int i = 0; i < other.size(); ++i)
+        {
+            this->tokens_.push_back(other[i]);
+            this->bTokenInSafemode_.push_back(other.isInSafemode(i));
         }
         return *this;
     }
 
-
-    /**
-     * @brief Split the String at
-     * @param string where to split
-     * @param splitter delimiter.
-     */
-    unsigned int SubString::split(const std::string& string, char splitter)
-    {
-        this->strings.clear();
-        this->bInSafemode.clear();
-        char split[2];
-        split[0] = splitter;
-        split[1] = '\0';
-        SubString::splitLine(this->strings, this->bInSafemode, string, split);
-        return strings.size();
-    }
-
-
-    /**
-     * @brief Splits a String into multiple splitters.
-     * @param string the String to split
-     * @param delimiters multiple set of characters at what to split. (delimiters)
-     * @param delimiterNeighbours: Neighbours to the Delimiters that will be erased too.
-     * @param emptyEntries: If empty entries are added to the List of SubStrings
-     * @param escapeChar The Escape Character that overrides splitters commends and so on...
-     * @param safemode_char within these characters splitting won't happen
-     * @param comment_char the Comment character.
-     */
-    unsigned int SubString::split(const std::string& string,
-                                  const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
-                                  char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
-                                  char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
-    {
-        this->strings.clear();
-        this->bInSafemode.clear();
-        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
-        return this->strings.size();
-    }
-
-
-    /**
-     * @brief joins together all Strings of this Substring.
-     * @param delimiter the String between the subStrings.
-     * @returns the joined String.
-     */
+    /**
+        @copydoc SubString(const std::string&,const std::string&,const std::string&,bool,char,bool,char,bool,char,char,bool,char)
+    */
+    unsigned int SubString::split(const std::string& line,
+                                  const std::string& delimiters, const std::string& delimiterNeighbours, bool bAllowEmptyEntries,
+                                  char escapeChar, bool bRemoveEscapeChar, char safemodeChar, bool bRemoveSafemodeChar,
+                                  char openparenthesisChar, char closeparenthesisChar, bool bRemoveParenthesisChars, char commentChar)
+    {
+        this->tokens_.clear();
+        this->bTokenInSafemode_.clear();
+        SubString::splitLine(this->tokens_, this->bTokenInSafemode_, line, delimiters, delimiterNeighbours, bAllowEmptyEntries, escapeChar, bRemoveEscapeChar, safemodeChar, bRemoveSafemodeChar, openparenthesisChar, closeparenthesisChar, bRemoveParenthesisChars, commentChar);
+        return this->tokens_.size();
+    }
+
+    /**
+        @brief Joins the tokens of this SubString using the given delimiter and returns a string.
+        @param delimiter This delimiter will be placed between each two tokens
+        @return The joined string.
+    */
     std::string SubString::join(const std::string& delimiter) const
     {
-        if (!this->strings.empty())
-        {
-            std::string retVal = this->strings[0];
-            for (unsigned int i = 1; i < this->strings.size(); i++)
-                retVal += delimiter + this->strings[i];
+        if (!this->tokens_.empty())
+        {
+            std::string retVal = this->tokens_[0];
+            for (unsigned int i = 1; i < this->tokens_.size(); ++i)
+                retVal += delimiter + this->tokens_[i];
             return retVal;
         }
@@ -273,71 +236,63 @@
     }
 
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subSetBegin the beginning to the end
-     * @returns the SubSet
-     *
-     * This function is added for your convenience, and does the same as
-     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
-     */
-    SubString SubString::subSet(unsigned int subSetBegin) const
-    {
-        return SubString(*this, subSetBegin);
-    }
-
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subSetBegin the beginning to
-     * @param subSetEnd the end of the SubSet to select (if bigger than subString.size() it will be downset.)
-     * @returns the SubSet
-     *
-     * This function is added for your convenience, and does the same as
-     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
-     */
-    SubString SubString::subSet(unsigned int subSetBegin, unsigned int subSetEnd) const
-    {
-        return SubString(*this, subSetBegin, subSetEnd);
-    }
-
-
-    /**
-     * @brief splits line into tokens and stores them in ret.
-     * @param ret the Array, where the Splitted strings will be stored in
-     * to the beginning of the current token is stored
-     * @param line the inputLine to split
-     * @param delimiters a String of Delimiters (here the input will be splitted)
-     * @param delimiterNeighbours Neighbours to the Delimiter, that will be removed if they are to the left or the right of a Delimiter.
-     * @param emptyEntries: if empty Strings are added to the List of Strings.
-     * @param escape_char: Escape carater (escapes splitters)
-     * @param safemode_char: the beginning of the safemode is marked with this
-     * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
-     * @param openparenthesis_char the beginning of a safemode is marked with this
-     * @param closeparenthesis_char the ending of a safemode is marked with this
-     * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
-     * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
-     * @param start_state: the Initial state on how to parse the String.
-     * @return SPLIT_LINE_STATE the parser was in when returning
-     *
-     * This is the Actual Splitting Algorithm from Clemens Wacha
-     * Supports delimiters, escape characters,
-     * ignores special  characters between safemode_char and between comment_char and linend '\n'.
-     */
+    /**
+        @brief Creates a subset of this SubString.
+        @param begin The beginning of the subset
+        @return A new SubString containing the defined subset.
+
+        The subset ranges from the token with index @a begin to the end of the tokens.
+        If @a begin is greater than the greatest index, the new SubString will be empty.
+
+        This function is added for your convenience, and does the same as
+        SubString::SubString(const SubString& other, unsigned int begin)
+    */
+    SubString SubString::subSet(unsigned int begin) const
+    {
+        return SubString(*this, begin);
+    }
+
+    /**
+        @brief Creates a subset of this SubString.
+        @param begin The beginning of the subset
+        @param end The ending of the subset
+        @return A new SubString containing the defined subset.
+
+        The subset ranges from the token with index @a begin until (but not including) the token with index @a end.
+        If @a begin or @a end are beyond the allowed index, the resulting SubString will be empty.
+
+        This function is added for your convenience, and does the same as
+        SubString::SubString(const SubString& other, unsigned int begin, unsigned int end)
+    */
+    SubString SubString::subSet(unsigned int begin, unsigned int end) const
+    {
+        return SubString(*this, begin, end);
+    }
+
+    /**
+        @copydoc SubString(const std::string&,const std::string&,const std::string&,bool,char,bool,char,bool,char,char,bool,char)
+        @param tokens The array, where the splitted strings will be stored in
+        @param bTokenInSafemode A vector wich stores for each character of the string if it is in safemode or not
+        @param start_state The internal state of the parser
+
+        This is the actual splitting algorithm from Clemens Wacha.
+        Supports delimiters, escape characters, ignores special characters between safemodeChar and between commentChar and line end "\n".
+
+        Extended by Orxonox to support parenthesis as additional safe-mode.
+    */
     SubString::SPLIT_LINE_STATE
-    SubString::splitLine(std::vector<std::string>& ret,
-                         std::vector<bool>& bInSafemode,
+    SubString::splitLine(std::vector<std::string>& tokens,
+                         std::vector<bool>& bTokenInSafemode,
                          const std::string& line,
                          const std::string& delimiters,
                          const std::string& delimiterNeighbours,
-                         bool emptyEntries,
-                         char escape_char,
-                         bool removeExcapeChar,
-                         char safemode_char,
-                         bool removeSafemodeChar,
-                         char openparenthesis_char,
-                         char closeparenthesis_char,
-                         bool removeParenthesisChars,
-                         char comment_char,
+                         bool bAllowEmptyEntries,
+                         char escapeChar,
+                         bool bRemoveEscapeChar,
+                         char safemodeChar,
+                         bool bRemoveSafemodeChar,
+                         char openparenthesisChar,
+                         char closeparenthesisChar,
+                         bool bRemoveParenthesisChars,
+                         char commentChar,
                          SPLIT_LINE_STATE start_state)
     {
@@ -349,13 +304,13 @@
         bool inSafemode = false;
 
-        if(start_state != SL_NORMAL && ret.size() > 0)
-        {
-            token = ret[ret.size()-1];
-            ret.pop_back();
-        }
-        if(start_state != SL_NORMAL && bInSafemode.size() > 0)
-        {
-            inSafemode = bInSafemode[bInSafemode.size()-1];
-            bInSafemode.pop_back();
+        if(start_state != SL_NORMAL && tokens.size() > 0)
+        {
+            token = tokens[tokens.size()-1];
+            tokens.pop_back();
+        }
+        if(start_state != SL_NORMAL && bTokenInSafemode.size() > 0)
+        {
+            inSafemode = bTokenInSafemode[bTokenInSafemode.size()-1];
+            bTokenInSafemode.pop_back();
         }
 
@@ -365,34 +320,38 @@
             {
             case SL_NORMAL:
-                if(line[i] == escape_char)
+                if(line[i] == escapeChar)
                 {
                     state = SL_ESCAPE;
-                    if (!removeExcapeChar)
+                    if (!bRemoveEscapeChar)
                         token += line[i];
-                }
-                else if(line[i] == safemode_char)
+                    fallBackNeighbours = 0;
+                }
+                else if(line[i] == safemodeChar)
                 {
                     state = SL_SAFEMODE;
                     inSafemode = true;
-                    if (!removeSafemodeChar)
+                    if (!bRemoveSafemodeChar)
                         token += line[i];
-                }
-                else if(line[i] == openparenthesis_char)
+                    fallBackNeighbours = 0;
+                }
+                else if(line[i] == openparenthesisChar)
                 {
                     state = SL_PARENTHESES;
                     inSafemode = true;
-                    if (!removeParenthesisChars)
+                    if (!bRemoveParenthesisChars)
                         token += line[i];
-                }
-                else if(line[i] == comment_char)
+                    fallBackNeighbours = 0;
+                }
+                else if(line[i] == commentChar)
                 {
                     if (fallBackNeighbours > 0)
                         token = token.substr(0, token.size() - fallBackNeighbours);
-                    /// FINISH
-                    if(emptyEntries || token.size() > 0)
+                    fallBackNeighbours = 0;
+                    // FINISH
+                    if(bAllowEmptyEntries || token.size() > 0)
                     {
-                        ret.push_back(token);
+                        tokens.push_back(token);
                         token.clear();
-                        bInSafemode.push_back(inSafemode);
+                        bTokenInSafemode.push_back(inSafemode);
                         inSafemode = false;
                     }
@@ -405,10 +364,11 @@
                     if (fallBackNeighbours > 0)
                         token = token.substr(0, token.size() - fallBackNeighbours);
-                    /// FINISH
-                    if(emptyEntries || token.size() > 0)
+                    fallBackNeighbours = 0;
+                    // FINISH
+                    if(bAllowEmptyEntries || token.size() > 0)
                     {
-                        ret.push_back(token);
+                        tokens.push_back(token);
                         token.clear();
-                        bInSafemode.push_back(inSafemode);
+                        bTokenInSafemode.push_back(inSafemode);
                         inSafemode = false;
                     }
@@ -423,5 +383,5 @@
                         else
                         {
-                            i++;
+                            ++i;
                             continue;
                         }
@@ -433,5 +393,5 @@
                 break;
             case SL_ESCAPE:
-                if (!removeSafemodeChar)
+                if (!bRemoveSafemodeChar)
                     token += line[i];
                 else
@@ -450,11 +410,11 @@
                 break;
             case SL_SAFEMODE:
-                if(line[i] == safemode_char)
+                if(line[i] == safemodeChar)
                 {
                     state = SL_NORMAL;
-                    if (!removeSafemodeChar)
+                    if (!bRemoveSafemodeChar)
                         token += line[i];
                 }
-                else if(line[i] == escape_char)
+                else if(line[i] == escapeChar)
                 {
                     state = SL_SAFEESCAPE;
@@ -480,11 +440,11 @@
 
             case SL_PARENTHESES:
-                if(line[i] == closeparenthesis_char)
+                if(line[i] == closeparenthesisChar)
                 {
                     state = SL_NORMAL;
-                    if (!removeParenthesisChars)
+                    if (!bRemoveParenthesisChars)
                         token += line[i];
                 }
-                else if(line[i] == escape_char)
+                else if(line[i] == escapeChar)
                 {
                     state = SL_PARENTHESESESCAPE;
@@ -512,10 +472,10 @@
                 if(line[i] == '\n')
                 {
-                    /// FINISH
+                    // FINISH
                     if(token.size() > 0)
                     {
-                        ret.push_back(token);
+                        tokens.push_back(token);
                         token.clear();
-                        bInSafemode.push_back(inSafemode);
+                        bTokenInSafemode.push_back(inSafemode);
                         inSafemode = false;
                     }
@@ -532,15 +492,15 @@
                 break;
             }
-            i++;
-        }
-
-        /// FINISH
+            ++i;
+        }
+
+        // FINISH
         if (fallBackNeighbours > 0)
             token = token.substr(0, token.size() - fallBackNeighbours);
-        if(emptyEntries || token.size() > 0)
-        {
-            ret.push_back(token);
+        if(bAllowEmptyEntries || token.size() > 0)
+        {
+            tokens.push_back(token);
             token.clear();
-            bInSafemode.push_back(inSafemode);
+            bTokenInSafemode.push_back(inSafemode);
             inSafemode = false;
         }
@@ -548,14 +508,13 @@
     }
 
-
-    /**
-     * @brief Some nice debug information about this SubString
-     */
+    /**
+        @brief Some nice debug information about this SubString.
+    */
     void SubString::debug() const
     {
-        printf("Substring-information::count=%d ::", this->strings.size());
-        for (unsigned int i = 0; i < this->strings.size(); i++)
-            printf("s%d='%s'::", i, this->strings[i].c_str());
-        printf("\n");
+        COUT(0) << "Substring-information::count=" << this->tokens_.size() << " ::";
+        for (unsigned int i = 0; i < this->tokens_.size(); ++i)
+            COUT(0) << "s" << i << "='" << this->tokens_[i].c_str() << "'::";
+        COUT(0) << std::endl;
     }
 }
Index: code/trunk/src/libraries/util/SubString.h
===================================================================
--- code/trunk/src/libraries/util/SubString.h	(revision 7380)
+++ code/trunk/src/libraries/util/SubString.h	(revision 7401)
@@ -37,22 +37,47 @@
  */
 
- /*!
- * @file
- * @brief a small class to get the parts of a string separated by commas
- *
- * This class is also identified as a Tokenizer. It splits up one long
- * String into multiple small ones by a designated Delimiter.
- *
- * Substring is Advanced, and it is possible, to split a string by ','
- * but also removing leading and trailing spaces around the comma.
- *
- * @example
- * Split the String std::string st = "1345, The new empire   , is , orxonox"
- * is splitted with:
- * SubString(st, ',', " \n\t")
- * into
- * "1345", "The new empire", "is", "orxonox"
- * As you can see, the useless spaces around ',' were removed.
- */
+ /**
+    @file
+    @ingroup String
+    @brief A helper class to split a string into several tokens.
+
+    @anchor SubStringExample
+
+    The class SubString can be used to split an std::string into multiple tokens, using
+    a delimiter. SubString allows different options, for example to remove whitespaces
+    around the delimiters or different safe-mode chars, like quotation marks and braces.
+
+    You can access the tokens of the SubString using the [] operator like an array.
+    SubString also supports to join the tokens (or a subset of the tokens) again using
+    @ref orxonox::SubString::join() "join()". It's even possible to get a subset of the
+    SubString as another SubString using @ref orxonox::SubString::subSet() "subSet()".
+
+    Example:
+    @code
+    std::string text = "This is a test, \"Hello \\\" World\" and vector {1, 2, 3}";
+    SubString tokens(text, SubString::WhiteSpaces, "", false, '\\', true, '"', true, '{', '}', true, '\0');
+
+    for (unsigned int i = 0; i < tokens.size(); ++i)
+        COUT(0) << i << ": " << tokens[i] << std::endl;
+    @endcode
+
+    The output of this code is:
+     - 0: This
+     - 1: is
+     - 2: a
+     - 3: test,
+     - 4: Hello " World
+     - 5: and
+     - 6: vector
+     - 7: 1, 2, 3
+
+    The string was split using the delimiter " ". A string between quotation mark is not
+    split, the same holds for strings between '{' and '}'. Note how the quotation marks and
+    the braces were removed from the tokens, because the corresponding argument is 'true'.
+
+    Also note that the comma after "test" in token 3 is still there - it is neither part of the
+    delimiters SubString::WhiteSpaces nor part of the delimiterNeighbours parameter, so it
+    remains a part of the token.
+*/
 
 #ifndef __SubString_H__
@@ -66,109 +91,124 @@
 namespace orxonox
 {
-    //! A class that can load one string and split it in multipe ones
     /**
-     * SubString is a very Powerfull way to create a SubSet from a String
-     * It can be used, to Split strings append them and join them again.
-     */
+        @brief A class that splits a string into multiple tokens using different options.
+
+        The string is split into multiple tokens using a delimiter. Different options like
+        escape character, quotation marks, and more can be used to satisfy your needs.
+
+        See @ref SubStringExample "this description" for an example.
+    */
     class _UtilExport SubString
     {
-    public:
-        //! An enumerator for the State the Parser is in
-        typedef enum {
+        /// An enumerator for the internal state of the parser
+        enum SPLIT_LINE_STATE
+        {
             SL_NORMAL,            //!< Normal state
             SL_ESCAPE,            //!< After an escape character
-            SL_SAFEMODE,          //!< In safe mode (between "" mostly).
+            SL_SAFEMODE,          //!< In safe mode (usually between quotation marks).
             SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
             SL_COMMENT,           //!< In Comment mode.
             SL_PARENTHESES,       //!< Between parentheses (usually '{' and '}')
             SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
-        } SPLIT_LINE_STATE;
-
+        };
 
     public:
         SubString();
-        SubString(const std::string& string, char delimiter = ',');
-        SubString(const std::string& string,
-                  const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
-                  char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
-                  char openparenthesis_char = '{', char closeparenthesis_char = '}',  bool removeParenthesisChars = true, char comment_char = '\0');
+        SubString(const std::string& line,
+                  const std::string& delimiters = SubString::WhiteSpaces,
+                  const std::string& delimiterNeighbours = "",
+                  bool bAllowEmptyEntries=false,
+                  char escapeChar ='\\',
+                  bool bRemoveEscapeChar = true,
+                  char safemodeChar = '"',
+                  bool bRemoveSafemodeChar = true,
+                  char openparenthesisChar = '{',
+                  char closeparenthesisChar = '}',
+                  bool bRemoveParenthesisChars = true,
+                  char commentChar = '\0');
         SubString(unsigned int argc, const char** argv);
-        /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
-        SubString(const SubString& subString) { *this = subString; };
-        SubString(const SubString& subString, unsigned int subSetBegin);
-        SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd);
+        SubString(const SubString& other, unsigned int begin);
+        SubString(const SubString& other, unsigned int begin, unsigned int end);
         ~SubString();
 
         // operate on the SubString
-        SubString& operator=(const SubString& subString);
-        bool operator==(const SubString& subString) const;
-        bool compare(const SubString& subString) const;
-        bool compare(const SubString& subString, unsigned int length) const;
-        SubString operator+(const SubString& subString) const;
-        SubString& operator+=(const SubString& subString);
-        /** @param subString the String to append @returns appended String. @brief added for convenience */
-        SubString& append(const SubString subString) { return (*this += subString); };
+        SubString& operator=(const SubString& other);
+        bool operator==(const SubString& other) const;
+        bool compare(const SubString& other) const;
+        bool compare(const SubString& other, unsigned int length) const;
+        SubString operator+(const SubString& other) const;
+        SubString& operator+=(const SubString& other);
+        /// Appends the tokens of another SubString to this. @return This SubString.
+        inline SubString& append(const SubString& other) { return (*this += other); }
 
         /////////////////////////////////////////
         // Split and Join the any String. ///////
-        unsigned int split(const std::string& string = "", char delimiter = ',');
-        unsigned int split(const std::string& string,
-                           const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
-                           char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
-                           char openparenthesis_char = '{', char closeparenthesis_char = '}',  bool removeParenthesisChars = true, char comment_char = '\0');
+        unsigned int split(const std::string& line,
+                           const std::string& delimiters = SubString::WhiteSpaces,
+                           const std::string& delimiterNeighbours = "",
+                           bool bAllowEmptyEntries = false,
+                           char escapeChar ='\\',
+                           bool bRemoveEscapeChar = true,
+                           char safemodeChar = '"',
+                           bool bRemoveSafemodeChar = true,
+                           char openparenthesisChar = '{',
+                           char closeparenthesisChar = '}',
+                           bool bRemoveParenthesisChars = true,
+                           char commentChar = '\0');
+
         std::string join(const std::string& delimiter = " ") const;
         ////////////////////////////////////////
 
         // retrieve a SubSet from the String
-        SubString subSet(unsigned int subSetBegin) const;
-        SubString subSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
+        SubString subSet(unsigned int begin) const;
+        SubString subSet(unsigned int begin, unsigned int end) const;
 
         // retrieve Information from within
-        /** @brief Returns true if the SubString is empty */
-        inline bool empty() const { return this->strings.empty(); };
-        /** @brief Returns the count of Strings stored in this substring */
-        inline unsigned int size() const { return this->strings.size(); };
-        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
-        inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
-        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
-        inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
-        /** @brief Returns all Strings as std::vector */
-        inline const std::vector<std::string>& getAllStrings() const { return this->strings; }
-        /** @brief Returns true if the token is in safemode. @param i the i'th token */
-        inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
-        /** @brief Returns the front of the StringList. */
-        inline const std::string& front() const { return this->strings.front(); };
-        /** @brief Returns the back of the StringList. */
-        inline const std::string& back() const { return this->strings.back(); };
-        /** @brief removes the back of the strings list. */
-        inline void pop_back() { this->strings.pop_back(); this->bInSafemode.pop_back(); };
-
+        /// Returns true if the SubString is empty
+        inline bool empty() const { return this->tokens_.empty(); }
+        /// Returns the number of tokens stored in this SubString
+        inline unsigned int size() const { return this->tokens_.size(); }
+        /// Returns the i'th token from the subset of strings @param index The index of the requested doken
+        inline const std::string& operator[](unsigned int index) const { return this->tokens_[index]; }
+        /// Returns the i'th token from the subset of strings @param index The index of the requested token
+        inline const std::string& getString(unsigned int index) const { return (*this)[index]; }
+        /// Returns all tokens as std::vector
+        inline const std::vector<std::string>& getAllStrings() const { return this->tokens_; }
+        /// Returns true if the token is in safemode. @param index The index of the token
+        inline bool isInSafemode(unsigned int index) const { return this->bTokenInSafemode_[index]; }
+        /// Returns the front of the list of tokens.
+        inline const std::string& front() const { return this->tokens_.front(); }
+        /// Returns the back of the list of tokens.
+        inline const std::string& back() const { return this->tokens_.back(); }
+        /// Removes the back of the list of tokens.
+        inline void pop_back() { this->tokens_.pop_back(); this->bTokenInSafemode_.pop_back(); }
+
+        void debug() const;
+
+    public:
+        static const std::string WhiteSpaces;           ///< All whitespaces (usually used as delimiters or delimiterNeighbours
+        static const std::string WhiteSpacesWithComma;  ///< All whitespaces and the comma (usually used as delimiters)
+        static const SubString   NullSubString;         ///< An empty SubString
+
+    private:
         // the almighty algorithm.
-        static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
-                                          std::vector<bool>& bInSafemode,
+        static SPLIT_LINE_STATE splitLine(std::vector<std::string>& tokens,
+                                          std::vector<bool>& bTokenInSafemode,
                                           const std::string& line,
                                           const std::string& delimiters = SubString::WhiteSpaces,
                                           const std::string& delimiterNeighbours = "",
-                                          bool emptyEntries = false,
-                                          char escape_char = '\\',
-                                          bool removeExcapeChar = true,
-                                          char safemode_char = '"',
-                                          bool removeSafemodeChar = true,
-                                          char openparenthesis_char = '{',
-                                          char closeparenthesis_char = '}',
-                                          bool removeParenthesisChars = true,
-                                          char comment_char = '\0',
+                                          bool bAllowEmptyEntries = false,
+                                          char escapeChar = '\\',
+                                          bool bRemoveEscapeChar = true,
+                                          char safemodeChar = '"',
+                                          bool bRemoveSafemodeChar = true,
+                                          char openparenthesisChar = '{',
+                                          char closeparenthesisChar = '}',
+                                          bool bRemoveParenthesisChars = true,
+                                          char commentChar = '\0',
                                           SPLIT_LINE_STATE start_state = SL_NORMAL);
-        // debugging.
-        void debug() const;
-
-    public:
-        static const std::string WhiteSpaces;
-        static const std::string WhiteSpacesWithComma;
-        static const SubString   NullSubString;
-
-    private:
-        std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
-        std::vector<bool>         bInSafemode;
+
+        std::vector<std::string>  tokens_;              ///< The tokens after spliting the input line
+        std::vector<bool>         bTokenInSafemode_;    ///< Saves for each token if it was in safe mode (between quotation marks or parenthesis)
     };
 }
Index: code/trunk/src/libraries/util/TriBool.h
===================================================================
--- code/trunk/src/libraries/util/TriBool.h	(revision 7380)
+++ code/trunk/src/libraries/util/TriBool.h	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @ingroup Util
+*/
+
 #ifndef _TriBool_H__
 #define _TriBool_H__
@@ -35,4 +40,9 @@
 namespace orxonox
 {
+    /** Sort of a boolean value that also has state \c Dontcare
+    @remarks
+        Even though \c False has the value 0, both \c True and \c Dontcare have
+        a value other than 0. Keep that in mind when using TriBools in if statements.
+    */
     namespace TriBool
     {
Index: code/trunk/src/libraries/util/VA_NARGS.h
===================================================================
--- code/trunk/src/libraries/util/VA_NARGS.h	(revision 7380)
+++ code/trunk/src/libraries/util/VA_NARGS.h	(revision 7401)
@@ -29,5 +29,37 @@
 /**
     @file
+    @ingroup Util
     @brief Declaration of the ORXONOX_VA_NARGS macro which returns the number of arguments passed to a variadic macro.
+
+    With this utility you can overload a macro for different numbers of arguments
+    (of course overloading is not possible for different types, as macros are not
+    type aware, but for different numbers of arguments is still very powerful).
+
+    Example: A macro to call functions
+    @code
+    myfunction();                                           // A static function
+    MyClass::myStaticFunction();                            // A static class function
+    MyClass::myFunction();                                  // A member function
+
+    #define CallFunction(...) \                             // Define a variadic macro that passes the arguments to the overloaded implementations
+        BOOST_PP_EXPAND(BOOST_PP_CAT(CallFunction, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
+
+    #define CallFunction1(function) \                       // Overloaded macro for 1 argument
+        function()                                          // Calls the static function
+
+    #define CallFunction2(class, function) \                // Overloaded macro for 2 arguments
+        class::function()                                   // Calls the static class function
+
+    #define CallFunction3(class, function, object) \        // Overloaded macro for 3 arguments
+        object->class::function()                           // Calls the function on the object
+
+
+    CallFunction(myFunction);                               // Call the macro with 1 argument
+    CallFunction(MyClass, myStaticFunction);                // Call the macro with 2 arguments
+    CallFunction(MyClass, myFunction, new MyClass());       // Call the macro with 3 arguments
+    @endcode
+
+    Note that the first (variadic) macro concatenates the name "CallFunction" with
+    the number of arguments ("1" - "N"). Then all arguments are passed to the right macro.
 */
 
Index: code/trunk/src/libraries/util/mbool.h
===================================================================
--- code/trunk/src/libraries/util/mbool.h	(revision 7380)
+++ code/trunk/src/libraries/util/mbool.h	(revision 7401)
@@ -27,4 +27,10 @@
  */
 
+/**
+    @file
+    @ingroup Util
+    @brief Declaration and implementation of the @ref orxonox::mbool class.
+*/
+
 #ifndef _mbool_H__
 #define _mbool_H__
@@ -34,38 +40,67 @@
 namespace orxonox
 {
+    /**
+        @brief mbool is a small helper class that acts like a bool, but keeps track of the number of its state changes.
+
+        The mbool class acts like a bool, but it has an internal counter that counts
+        the number state changes (i.e. when the bool changes from true to false or
+        back). This is used in the network if a boolean value is synchronized, because
+        if a value changes quickly from false to true and back in the same tick, the
+        clients will never be notified of this action. By using mbool however this
+        behaviour is fixed, which is important for triggers and other objects.
+
+        @note This is efficiently solved by using a union that combines a counter and a
+        boolean bitfield of size 1. The boolean value corresponds always to the first
+        bit of the counter - this means, if the counter is incremented, the boolean state
+        changes. On the other hand, if you want to change the state, you can simply increase
+        the counter.
+    */
     struct _UtilExport mbool
     {
         public:
+            /// Constructor: Creates the mbool and initializes the boolean value (default to false).
             inline mbool(bool value = false)
                 { this->value_.memory_ = 0; this->value_.bool_ = value; }
+            /// Copy-constructor, copies state and memory.
             inline mbool(const mbool& value)
                 { this->value_.memory_ = value.value_.memory_; }
 
+            /// Assigns a boolean value (and increases the memory value if the value is different to the old value).
             inline mbool& operator=(bool value)
                 { if (value != this->value_.bool_) { ++this->value_.memory_; } return (*this); }
+            /// Assigns another mbool, copies state and memory.
             inline mbool& operator=(const mbool& value)
                 { this->value_.memory_ = value.value_.memory_; return (*this); }
 
+            /// Increases the memory which also inverts it's state (++mbool).
             inline mbool& operator++()
                 { ++this->value_.memory_; return (*this); }
-            inline mbool operator++(int i)
+            /// Increases the memory which also inverts it's state (mbool++).
+            inline mbool operator++(int)
                 { mbool temp = (*this); ++this->value_.memory_; return temp; }
 
+            /// Implicitly converts the mbool to a bool.
             inline operator bool() const
                 { return this->value_.bool_; }
 
+            /// Compares the mbool to a bool, returns true if the bool has the same value as the state of the mbool.
             inline bool operator==(bool other) const
                 { return this->value_.bool_ == other; }
+            /// Compares the mbool to a bool, returns true if the bool has a different value than the state of the mbool.
             inline bool operator!=(bool other) const
                 { return this->value_.bool_ != other; }
 
+            /// Compares two mbools, returns true if their memory matches.
             inline bool operator==(const mbool& other) const
                 { return this->value_.memory_ == other.value_.memory_; }
+            /// Compares two mbools, returns true if they have a different memory value.
             inline bool operator!=(const mbool& other) const
                 { return this->value_.memory_ != other.value_.memory_; }
 
+            /// Returns the inverted state of the bool (doesn't change the internal state).
             inline bool operator!() const
                 { return (!this->value_.bool_); }
 
+            /// Returns the memory value.
             inline unsigned char& getMemory(){ return value_.memory_; }
 
@@ -73,7 +108,7 @@
             union
             {
-                bool bool_ : 1;
-                unsigned char memory_;
-            } value_;
+                bool bool_ : 1;         ///< The boolean state of the mbool, is located on the first bit of the memory variable
+                unsigned char memory_;  ///< The memory of the mbool, counts the state-changes (and the first bit represents also the boolean value)
+            } value_;                   ///< A union containing the state and the memory of the mbool
     };
 }
Index: code/trunk/src/modules/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/CMakeLists.txt	(revision 7380)
+++ code/trunk/src/modules/CMakeLists.txt	(revision 7401)
@@ -19,5 +19,4 @@
 
 INCLUDE_DIRECTORIES(
-  ${CMAKE_SOURCE_DIR}/src/external
   ${CMAKE_SOURCE_DIR}/src/libraries
   ${CMAKE_SOURCE_DIR}/src/orxonox
Index: code/trunk/src/modules/notifications/Notification.cc
===================================================================
--- code/trunk/src/modules/notifications/Notification.cc	(revision 7380)
+++ code/trunk/src/modules/notifications/Notification.cc	(revision 7401)
@@ -55,4 +55,6 @@
     @brief
         Constructor. Creates a Notification with the input message.
+    @param creator
+        The object that created this Notification
     @param message
         The message of the Notification.
Index: code/trunk/src/modules/notifications/NotificationQueue.cc
===================================================================
--- code/trunk/src/modules/notifications/NotificationQueue.cc	(revision 7380)
+++ code/trunk/src/modules/notifications/NotificationQueue.cc	(revision 7401)
@@ -109,17 +109,17 @@
         Method for creating a NotificationQueue object through XML.
     */
-    void NotificationQueue::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-    {
-        SUPER(NotificationQueue, XMLPort, xmlElement, mode);
+    void NotificationQueue::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(NotificationQueue, XMLPort, xmlelement, mode);
 
         this->setDefaults();
 
-        XMLPortParam(NotificationQueue, "maxSize", setMaxSize, getMaxSize, xmlElement, mode);
-        XMLPortParam(NotificationQueue, "notificationLength", setNotificationLength, getNotificationLength, xmlElement, mode);
-        XMLPortParam(NotificationQueue, "displayTime", setDisplayTime, getDisplayTime, xmlElement, mode);
-        XMLPortParam(NotificationQueue, "targets", setTargets, getTargets, xmlElement, mode);
-        XMLPortParam(NotificationQueue, "font", setFont, getFont, xmlElement, mode);
-        XMLPortParam(NotificationQueue, "fontSize", setFontSize, getFontSize, xmlElement, mode);
-        XMLPortParam(NotificationQueue, "position", setPosition, getPosition, xmlElement, mode);
+        XMLPortParam(NotificationQueue, "maxSize", setMaxSize, getMaxSize, xmlelement, mode);
+        XMLPortParam(NotificationQueue, "notificationLength", setNotificationLength, getNotificationLength, xmlelement, mode);
+        XMLPortParam(NotificationQueue, "displayTime", setDisplayTime, getDisplayTime, xmlelement, mode);
+        XMLPortParam(NotificationQueue, "targets", setTargets, getTargets, xmlelement, mode);
+        XMLPortParam(NotificationQueue, "font", setFont, getFont, xmlelement, mode);
+        XMLPortParam(NotificationQueue, "fontSize", setFontSize, getFontSize, xmlelement, mode);
+        XMLPortParam(NotificationQueue, "position", setPosition, getPosition, xmlelement, mode);
 
         COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl;
Index: code/trunk/src/modules/notifications/NotificationQueue.h
===================================================================
--- code/trunk/src/modules/notifications/NotificationQueue.h	(revision 7380)
+++ code/trunk/src/modules/notifications/NotificationQueue.h	(revision 7401)
@@ -71,5 +71,7 @@
 
         Creating a NotificationQueue through XML goes as follows:
-        Be aware that the NotificationQueue must be inside the <Level></Level> tags or bad things will happen.
+        Be aware that the NotificationQueue must be inside the @code <Level></Level> @endcode tags or bad things will happen.
+        
+        @code
         <NotificationQueue
             name = "SuperQueue" //Name of your OverlayQueue.
@@ -82,4 +84,5 @@
             position = "0.0, 0.0" //The position of the NotificationQueue. (Default is 0.0,0.0)
         />
+        @endcode
     @author
         Damian 'Mozork' Frick
@@ -93,5 +96,5 @@
             virtual ~NotificationQueue();
 
-            virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode); //!< Method for creating a NotificationQueue object through XML.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a NotificationQueue object through XML.
 
             virtual void tick(float dt); //!< To update from time to time.
Index: code/trunk/src/modules/objects/Planet.cc
===================================================================
--- code/trunk/src/modules/objects/Planet.cc	(revision 7380)
+++ code/trunk/src/modules/objects/Planet.cc	(revision 7401)
@@ -144,10 +144,4 @@
     }
 
-    /**
-        @brief XML loading and saving.
-        @param xmlelement The XML-element
-        @param loading Loading (true) or saving (false)
-        @return The XML-element
-    */
     void Planet::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
Index: code/trunk/src/modules/overlays/FadeoutText.h
===================================================================
--- code/trunk/src/modules/overlays/FadeoutText.h	(revision 7380)
+++ code/trunk/src/modules/overlays/FadeoutText.h	(revision 7401)
@@ -44,5 +44,5 @@
             virtual ~FadeoutText() {}
 
-            virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
 
Index: code/trunk/src/modules/overlays/GUIOverlay.cc
===================================================================
--- code/trunk/src/modules/overlays/GUIOverlay.cc	(revision 7380)
+++ code/trunk/src/modules/overlays/GUIOverlay.cc	(revision 7401)
@@ -52,9 +52,9 @@
     }
 
-    void GUIOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    void GUIOverlay::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        SUPER(GUIOverlay, XMLPort, xmlElement, mode);
+        SUPER(GUIOverlay, XMLPort, xmlelement, mode);
 
-        XMLPortParam(GUIOverlay, "guiname", setGUIName, getGUIName, xmlElement, mode);
+        XMLPortParam(GUIOverlay, "guiname", setGUIName, getGUIName, xmlelement, mode);
     }
 
Index: code/trunk/src/modules/overlays/GUIOverlay.h
===================================================================
--- code/trunk/src/modules/overlays/GUIOverlay.h	(revision 7380)
+++ code/trunk/src/modules/overlays/GUIOverlay.h	(revision 7401)
@@ -44,5 +44,5 @@
             virtual ~GUIOverlay();
 
-            virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
             void setGUIName(const std::string& name);
Index: code/trunk/src/modules/overlays/OverlayText.cc
===================================================================
--- code/trunk/src/modules/overlays/OverlayText.cc	(revision 7380)
+++ code/trunk/src/modules/overlays/OverlayText.cc	(revision 7401)
@@ -71,14 +71,14 @@
     }
 
-    void OverlayText::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    void OverlayText::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        SUPER(OverlayText, XMLPort, xmlElement, mode);
+        SUPER(OverlayText, XMLPort, xmlelement, mode);
 
-        XMLPortParam(OverlayText, "font",       setFont,            getFont,            xmlElement, mode);
-        XMLPortParam(OverlayText, "colour",     setColour,          getColour,          xmlElement, mode);
-        XMLPortParam(OverlayText, "caption",    setCaption,         getCaption,         xmlElement, mode);
-        XMLPortParam(OverlayText, "textsize",   setTextSize,        getTextSize,        xmlElement, mode);
-        XMLPortParam(OverlayText, "align",      setAlignmentString, getAlignmentString, xmlElement, mode);
-        XMLPortParam(OverlayText, "spacewidth", setSpaceWidth,      getSpaceWidth,      xmlElement, mode);
+        XMLPortParam(OverlayText, "font",       setFont,            getFont,            xmlelement, mode);
+        XMLPortParam(OverlayText, "colour",     setColour,          getColour,          xmlelement, mode);
+        XMLPortParam(OverlayText, "caption",    setCaption,         getCaption,         xmlelement, mode);
+        XMLPortParam(OverlayText, "textsize",   setTextSize,        getTextSize,        xmlelement, mode);
+        XMLPortParam(OverlayText, "align",      setAlignmentString, getAlignmentString, xmlelement, mode);
+        XMLPortParam(OverlayText, "spacewidth", setSpaceWidth,      getSpaceWidth,      xmlelement, mode);
     }
 
Index: code/trunk/src/modules/overlays/OverlayText.h
===================================================================
--- code/trunk/src/modules/overlays/OverlayText.h	(revision 7380)
+++ code/trunk/src/modules/overlays/OverlayText.h	(revision 7401)
@@ -52,5 +52,5 @@
         virtual ~OverlayText();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         void setCaption(const std::string& caption);
Index: code/trunk/src/modules/overlays/hud/HUDBar.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDBar.cc	(revision 7380)
+++ code/trunk/src/modules/overlays/hud/HUDBar.cc	(revision 7401)
@@ -55,10 +55,10 @@
     }
 
-    void BarColour::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-    {
-        SUPER(BarColour, XMLPort, xmlElement, mode);
-
-        XMLPortParam(BarColour, "colour", setColour, getColour, xmlElement, mode);
-        XMLPortParam(BarColour, "position", setPosition, getPosition, xmlElement, mode);
+    void BarColour::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(BarColour, XMLPort, xmlelement, mode);
+
+        XMLPortParam(BarColour, "colour", setColour, getColour, xmlelement, mode);
+        XMLPortParam(BarColour, "position", setPosition, getPosition, xmlelement, mode);
     }
 
@@ -104,13 +104,13 @@
     }
 
-    void HUDBar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-    {
-        SUPER(HUDBar, XMLPort, xmlElement, mode);
-
-        XMLPortParam(HUDBar, "initialvalue", setValue,       getValue,       xmlElement, mode);
-        XMLPortParam(HUDBar, "righttoleft",  setRightToLeft, getRightToLeft, xmlElement, mode);
-        XMLPortParam(HUDBar, "autocolour",   setAutoColour,  getAutoColour,  xmlElement, mode);
-        XMLPortParam(HUDBar, "bartexture",   setBarTexture,  getBarTexture, xmlElement, mode);
-        XMLPortObject(HUDBar, BarColour, "", addColour, getColour, xmlElement, mode);
+    void HUDBar::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(HUDBar, XMLPort, xmlelement, mode);
+
+        XMLPortParam(HUDBar, "initialvalue", setValue,       getValue,       xmlelement, mode);
+        XMLPortParam(HUDBar, "righttoleft",  setRightToLeft, getRightToLeft, xmlelement, mode);
+        XMLPortParam(HUDBar, "autocolour",   setAutoColour,  getAutoColour,  xmlelement, mode);
+        XMLPortParam(HUDBar, "bartexture",   setBarTexture,  getBarTexture, xmlelement, mode);
+        XMLPortObject(HUDBar, BarColour, "", addColour, getColour, xmlelement, mode);
     }
 
Index: code/trunk/src/modules/overlays/hud/HUDBar.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDBar.h	(revision 7380)
+++ code/trunk/src/modules/overlays/hud/HUDBar.h	(revision 7401)
@@ -50,5 +50,5 @@
         virtual ~BarColour() { }
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         void setColour(const ColourValue& colour) { this->colour_ = colour; }
@@ -70,5 +70,5 @@
         virtual ~HUDBar();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         void clearColours();
Index: code/trunk/src/modules/overlays/hud/HUDHealthBar.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDHealthBar.h	(revision 7380)
+++ code/trunk/src/modules/overlays/hud/HUDHealthBar.h	(revision 7401)
@@ -45,5 +45,5 @@
             virtual ~HUDHealthBar();
 
-            virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
             virtual void changedOwner();
Index: code/trunk/src/modules/overlays/hud/HUDNavigation.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDNavigation.cc	(revision 7380)
+++ code/trunk/src/modules/overlays/hud/HUDNavigation.cc	(revision 7401)
@@ -90,11 +90,11 @@
 }
 
-void HUDNavigation::XMLPort ( Element& xmlElement, XMLPort::Mode mode )
-{
-    SUPER ( HUDNavigation, XMLPort, xmlElement, mode );
-
-    XMLPortParam ( HUDNavigation, "font",          setFont,          getFont,          xmlElement, mode );
-    XMLPortParam ( HUDNavigation, "textSize",      setTextSize,      getTextSize,      xmlElement, mode );
-    XMLPortParam ( HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlElement, mode );
+void HUDNavigation::XMLPort ( Element& xmlelement, XMLPort::Mode mode )
+{
+    SUPER ( HUDNavigation, XMLPort, xmlelement, mode );
+
+    XMLPortParam ( HUDNavigation, "font",          setFont,          getFont,          xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "textSize",      setTextSize,      getTextSize,      xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlelement, mode );
 }
 
Index: code/trunk/src/modules/overlays/hud/HUDNavigation.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDNavigation.h	(revision 7380)
+++ code/trunk/src/modules/overlays/hud/HUDNavigation.h	(revision 7401)
@@ -51,5 +51,5 @@
     void setConfigValues();
 
-    virtual void XMLPort ( Element& xmlElement, XMLPort::Mode mode );
+    virtual void XMLPort ( Element& xmlelement, XMLPort::Mode mode );
     virtual void tick ( float dt );
 
Index: code/trunk/src/modules/overlays/hud/HUDRadar.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDRadar.cc	(revision 7380)
+++ code/trunk/src/modules/overlays/hud/HUDRadar.cc	(revision 7401)
@@ -82,11 +82,11 @@
     }
 
-    void HUDRadar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    void HUDRadar::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        SUPER(HUDRadar, XMLPort, xmlElement, mode);
+        SUPER(HUDRadar, XMLPort, xmlelement, mode);
 
-        XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlElement, mode);
-        XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlElement, mode);
-        XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlElement, mode);
+        XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlelement, mode);
+        XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlelement, mode);
+        XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlelement, mode);
     }
 
Index: code/trunk/src/modules/overlays/hud/HUDRadar.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDRadar.h	(revision 7380)
+++ code/trunk/src/modules/overlays/hud/HUDRadar.h	(revision 7401)
@@ -49,5 +49,5 @@
         virtual ~HUDRadar();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
         virtual void changedOwner();
 
Index: code/trunk/src/modules/overlays/stats/Scoreboard.cc
===================================================================
--- code/trunk/src/modules/overlays/stats/Scoreboard.cc	(revision 7380)
+++ code/trunk/src/modules/overlays/stats/Scoreboard.cc	(revision 7401)
@@ -54,12 +54,4 @@
             this->lines_.pop_back();
         }
-    }
-
-    /**
-        @brief Initializes the lines.
-    */
-    void Scoreboard::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-    {
-        SUPER(Scoreboard, XMLPort, xmlElement, mode);
     }
 
Index: code/trunk/src/modules/overlays/stats/Scoreboard.h
===================================================================
--- code/trunk/src/modules/overlays/stats/Scoreboard.h	(revision 7380)
+++ code/trunk/src/modules/overlays/stats/Scoreboard.h	(revision 7401)
@@ -44,5 +44,4 @@
         virtual ~Scoreboard();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
         virtual void tick(float dt);
 
Index: code/trunk/src/modules/overlays/stats/Stats.cc
===================================================================
--- code/trunk/src/modules/overlays/stats/Stats.cc	(revision 7380)
+++ code/trunk/src/modules/overlays/stats/Stats.cc	(revision 7401)
@@ -98,12 +98,4 @@
     }
 
-    /**
-        @brief Initializes the Stats panel.
-    */
-    void Stats::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-    {
-        OrxonoxOverlay::XMLPort(xmlElement, mode);
-    }
-
     void Stats::tick(float dt)
     {
Index: code/trunk/src/modules/overlays/stats/Stats.h
===================================================================
--- code/trunk/src/modules/overlays/stats/Stats.h	(revision 7380)
+++ code/trunk/src/modules/overlays/stats/Stats.h	(revision 7401)
@@ -46,6 +46,4 @@
         void setConfigValues();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
-
         virtual void tick(float dt);
 
Index: code/trunk/src/modules/pickup/DroppedPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/DroppedPickup.cc	(revision 7380)
+++ code/trunk/src/modules/pickup/DroppedPickup.cc	(revision 7401)
@@ -61,6 +61,6 @@
     @param pickup
         The Pickupable that was dropped.
-    @param position
-        The position at which the DroppedPickup should be created.
+    @param carrier
+        The PickupCarrier that carried the input pickup before it was dropped.
     @param triggerDistance
         The distance at which the PickupSpawner triggers. Default is 10.
Index: code/trunk/src/modules/pickup/Pickup.cc
===================================================================
--- code/trunk/src/modules/pickup/Pickup.cc	(revision 7380)
+++ code/trunk/src/modules/pickup/Pickup.cc	(revision 7401)
@@ -225,6 +225,4 @@
         This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.:
         DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position);
-    @param position
-        The position at which the PickupSpawner should be placed.
     @return
         Returns true if a spawner was created, false if not.
Index: code/trunk/src/modules/pickup/PickupCollection.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupCollection.cc	(revision 7380)
+++ code/trunk/src/modules/pickup/PickupCollection.cc	(revision 7401)
@@ -228,6 +228,6 @@
     @brief
         Get whether a given class, represented by the input Identifier, is a target of this PickupCollection.
-    @param identifier
-        A pointer to the PickupIdentifier of the PickupCarrier we want to know of, whether it is a target of this PickupCollection.
+    @param carrier
+        A pointer to the PickupCarrier we want to know of, whether it is a target of this PickupCollection.
     @return
         Returns true if the PickupCarrier identified by the input PickupIdentififer it is a target of this PickupCollection, false if not.
@@ -336,6 +336,4 @@
         This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.:
         DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position);
-    @param position
-        The position at which the PickupSpawner should be placed.
     @return
         Returns true if a spawner was created, false if not.
Index: code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc	(revision 7380)
+++ code/trunk/src/modules/pickup/PickupCollectionIdentifier.cc	(revision 7401)
@@ -99,5 +99,5 @@
     @brief
         Add a Pickupable to the PickupCollectionIdentifier.
-    @param
+    @param identifier
         A pointer to the PickupIdentifier of the Pickupable to be added.
     */
Index: code/trunk/src/modules/pickup/PickupSpawner.cc
===================================================================
--- code/trunk/src/modules/pickup/PickupSpawner.cc	(revision 7380)
+++ code/trunk/src/modules/pickup/PickupSpawner.cc	(revision 7401)
@@ -70,5 +70,5 @@
     @param respawnTime
         The minimum time between two spawns.
-    @param maySpawnedItems
+    @param maxSpawnedItems
         The maximum number of items spawned by this PickupSpawner.
     */
Index: code/trunk/src/modules/pickup/items/SpeedPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/SpeedPickup.cc	(revision 7380)
+++ code/trunk/src/modules/pickup/items/SpeedPickup.cc	(revision 7401)
@@ -252,5 +252,5 @@
     @brief
         Sets the SpeedMultiply
-    @param speedAdd
+    @param speedMultiply
         The multiplied Speed
     */
Index: code/trunk/src/modules/questsystem/AddQuest.cc
===================================================================
--- code/trunk/src/modules/questsystem/AddQuest.cc	(revision 7380)
+++ 	(revision )
@@ -1,110 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of the AddQuest class.
-*/
-
-#include "AddQuest.h"
-
-#include "util/Exception.h"
-#include "core/CoreIncludes.h"
-#include "QuestManager.h"
-#include "Quest.h"
-
-namespace orxonox
-{
-    CreateFactory(AddQuest);
-
-    /**
-    @brief
-        Constructor. Registers the object.
-    */
-    AddQuest::AddQuest(BaseObject* creator) : ChangeQuestStatus(creator)
-    {
-        RegisterObject(AddQuest);
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    AddQuest::~AddQuest()
-    {
-    }
-
-    /**
-    @brief
-        Method for creating a AddQuest object through XML.
-    */
-    void AddQuest::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(AddQuest, XMLPort, xmlelement, mode);
-
-        COUT(4) << "New AddQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
-    }
-
-    /**
-    @brief
-        Invokes the QuestEffect.
-    @param player
-        The player the QuestEffect is invoked on.
-    @return
-        Returns true if the QuestEffect was successfully invoked.
-    */
-    bool AddQuest::invoke(PlayerInfo* player)
-    {
-        if(player == NULL) //!< Null-pointers are badass.
-        {
-            COUT(2) << "Input player is NULL." << std::endl;
-            return false;
-        }
-
-        COUT(5) << "AddQuest on player: " << player << " ." << std::endl;
-
-        try
-        {
-            Quest* quest = QuestManager::getInstance().findQuest(this->getQuestId());
-            if(quest == NULL || !quest->start(player))
-            {
-               return false;
-            }
-        }
-        catch(const orxonox::Exception& ex)
-        {
-            COUT(2) << ex.getFullDescription() << std::endl;
-            return false;
-        }
-
-        COUT(4) << "Quest {" << this->getQuestId() << "} successfully added to player: " << player << " ." << std::endl;
-        return true;
-    }
-
-
-}
Index: code/trunk/src/modules/questsystem/AddQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/AddQuest.h	(revision 7380)
+++ 	(revision )
@@ -1,66 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of the AddQuest class.
-*/
-
-#ifndef _AddQuest_H__
-#define _AddQuest_H__
-
-#include "questsystem/QuestsystemPrereqs.h"
-#include "ChangeQuestStatus.h"
-
-namespace orxonox
-{
-    /**
-    @brief
-        Adds a Quest, resp. changes the quests status to active for the player invoking the Quest.
-
-        Creating a AddQuest through XML goes as follows:
-
-        <AddQuest questId="id" />  //Where id is a GUID, see http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure for more information, and identifies the Quest that should be added.
-    @author
-        Damian 'Mozork' Frick
-    */
-    class _QuestsystemExport AddQuest : public ChangeQuestStatus
-    {
-        public:
-        AddQuest(BaseObject* creator);
-        virtual ~AddQuest();
-
-        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a AddQuest object through XML.
-
-        virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
-
-    };
-
-}
-
-#endif /* _AddQuest_H__ */
Index: code/trunk/src/modules/questsystem/AddQuestHint.cc
===================================================================
--- code/trunk/src/modules/questsystem/AddQuestHint.cc	(revision 7380)
+++ 	(revision )
@@ -1,133 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of the AddQuestHint class.
-*/
-
-#include "AddQuestHint.h"
-
-#include "util/Exception.h"
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "QuestManager.h"
-#include "QuestItem.h"
-#include "QuestHint.h"
-
-namespace orxonox
-{
-    CreateFactory(AddQuestHint);
-
-    /**
-    @brief
-        Constructor. Registers the object.
-    */
-    AddQuestHint::AddQuestHint(BaseObject* creator) : QuestEffect(creator)
-    {
-        RegisterObject(AddQuestHint);
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    AddQuestHint::~AddQuestHint()
-    {
-    }
-
-    /**
-    @brief
-        Method for creating a AddQuestHint object through XML.
-    */
-    void AddQuestHint::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(AddQuestHint, XMLPort, xmlelement, mode);
-
-        XMLPortParam(AddQuestHint, "hintId", setHintId, getHintId, xmlelement, mode);
-
-        COUT(4) << "New AddQuestHint, with target QuestHint {" << this->getHintId() << "}, created." << std::endl;
-    }
-
-    /**
-    @brief
-        Sets the id of the QuestHint to be added to the player the QuestEffect is invoked on.
-    @param id
-        The QuestHint id.
-    @param
-        Returns true if successful.
-    */
-    bool AddQuestHint::setHintId(const std::string & id)
-    {
-        if(id.compare(BLANKSTRING) == 0)
-        {
-            COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;
-            return false;
-        }
-
-        this->hintId_ = id;
-        return true;
-    }
-
-    /**
-    @brief
-        Invokes the QuestEffect.
-    @param player
-        The player.
-    @return
-        Returns true if the QuestEffect was successfully invoked.
-    */
-    bool AddQuestHint::invoke(PlayerInfo* player)
-    {
-        if(player == NULL) //!< NULL-pointers are evil!
-        {
-            COUT(2) << "The input player is NULL." << std::endl;
-            return false;
-        }
-
-        COUT(5) << "AddQuestHint on player: " << player << " ." << std::endl;
-
-        try
-        {
-            QuestHint* hint = QuestManager::getInstance().findHint(this->hintId_);
-            if(hint == NULL || !hint->setActive(player))
-            {
-                return false;
-            }
-        }
-        catch(const Exception& e)
-        {
-           COUT(2) << e.getFullDescription() << std::endl;
-           return false;
-        }
-
-        COUT(4) << "QuestHint {" << this->getHintId() << "} successfully added to player: " << player << " ." << std::endl;
-        return true;
-
-    }
-}
Index: code/trunk/src/modules/questsystem/AddQuestHint.h
===================================================================
--- code/trunk/src/modules/questsystem/AddQuestHint.h	(revision 7380)
+++ 	(revision )
@@ -1,80 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of the AddQuestHint class.
-*/
-
-#ifndef _AddQuestHint_H__
-#define _AddQuestHint_H__
-
-#include "questsystem/QuestsystemPrereqs.h"
-
-#include <string>
-#include "QuestEffect.h"
-
-namespace orxonox
-{
-    /**
-    @brief
-        Adds a QuestHint, resp. activates the QuestHint of the given id for the player the QuestEffect is invoked on.
-
-    Creating a AddQuestHint through XML goes as follows:
-
-        <AddQuestHint hintId="id" />  //Where id is a GUID, see http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure for more information, and identifies the QuestHint that should be added.
-    @author
-        Damian 'Mozork' Frick
-    */
-    class _QuestsystemExport AddQuestHint : public QuestEffect
-    {
-        public:
-            AddQuestHint(BaseObject* creator);
-            virtual ~AddQuestHint();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a AddQuestHint object through XML.
-
-            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
-
-        private:
-            std::string hintId_; //!< The id of the QuestHint.
-
-            /**
-            @brief Returns the id of the QuestHint.
-            @return Returns the id of the QuestHint.
-            */
-            inline const std::string & getHintId(void) const
-                { return this->hintId_; }
-
-            bool setHintId(const std::string & id); //!< Sets the id of the QuestHint.
-
-    };
-
-}
-
-#endif /* _AddQuestHint_H__ */
Index: code/trunk/src/modules/questsystem/AddReward.cc
===================================================================
--- code/trunk/src/modules/questsystem/AddReward.cc	(revision 7380)
+++ 	(revision )
@@ -1,118 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of the AddReward class.
-*/
-
-#include "AddReward.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "interfaces/Rewardable.h"
-
-namespace orxonox
-{
-    CreateFactory(AddReward);
-
-    /**
-    @brief
-        Constructor. Registers the object.
-    */
-    AddReward::AddReward(BaseObject* creator) : QuestEffect(creator)
-    {
-        RegisterObject(AddReward);
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    AddReward::~AddReward()
-    {
-    }
-
-    /**
-        Method for creating a AddReward object through XML.
-    */
-    void AddReward::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(AddReward, XMLPort, xmlelement, mode);
-
-        XMLPortObject(AddReward, Rewardable, "", addRewardable, getRewardables, xmlelement, mode);
-
-        COUT(4) << "New AddReward, with " << this->rewards_.size() << " Rewardables created." << std::endl;
-    }
-
-    /**
-    @brief
-        Returns the Rewardable object at the given index.
-    @param index
-        The index.
-    @return
-        Returns a pointer to the Rewardable object at the given index.
-    */
-    const Rewardable* AddReward::getRewardables(unsigned int index) const
-    {
-        int i = index;
-        for (std::list<Rewardable*>::const_iterator reward = this->rewards_.begin(); reward != this->rewards_.end(); ++reward)
-        {
-            if(i == 0)
-            {
-               return *reward;
-            }
-            i--;
-        }
-        return NULL;
-    }
-
-    /**
-    @brief
-        Invokes the QuestEffect.
-    @param player
-        The player.
-    @return
-        Returns true if the QuestEffect was invoked successfully.
-    */
-    bool AddReward::invoke(PlayerInfo* player)
-    {
-        COUT(5) << "AddReward on player: " << player << " ." << std::endl;
-
-        bool check = true;
-        for ( std::list<Rewardable*>::iterator reward = this->rewards_.begin(); reward != this->rewards_.end(); ++reward )
-        {
-            check = check && (*reward)->reward(player);
-        }
-
-        COUT(4) << "Rewardable successfully added to player." << player << " ." << std::endl;
-
-        return check;
-    }
-
-}
Index: code/trunk/src/modules/questsystem/AddReward.h
===================================================================
--- code/trunk/src/modules/questsystem/AddReward.h	(revision 7380)
+++ 	(revision )
@@ -1,84 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of the AddReward class.
-*/
-
-#ifndef _AddReward_H__
-#define _AddReward_H__
-
-#include "questsystem/QuestsystemPrereqs.h"
-
-#include <list>
-#include "QuestEffect.h"
-
-namespace orxonox
-{
-    /**
-    @brief
-        Adds a list of Rewardables to a player.
-
-        Creating a AddReward through XML goes as follows:
-
-        <AddReward>
-            <Rewardable /> //A list of Rewardable objects to be rewarded the player, see the specific Rewardables for their respective XML representations.
-            ...
-            <Rewardable />
-        </AddReward>
-    @author
-        Damian 'Mozork' Frick
-    */
-    class _QuestsystemExport AddReward : public QuestEffect
-    {
-        public:
-            AddReward(BaseObject* creator);
-            virtual ~AddReward();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a AddReward object through XML.
-
-            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
-
-        private:
-            std::list<Rewardable*> rewards_; //!< A list of Rewardables to be added to the player invoking the QuestEffect.
-
-            /**
-            @brief Add a Rewardable object to the list of objects to be awarded to the player invoking the QuestEffect.
-            @param reward Pointer to the Rewardable to be added.
-            */
-            inline void addRewardable(Rewardable* reward)
-                { this->rewards_.push_back(reward); }
-
-            const Rewardable* getRewardables(unsigned int index) const; //!< Returns the Rewardable object at the given index.
-
-    };
-
-}
-
-#endif /* _AddReward_H__ */
Index: code/trunk/src/modules/questsystem/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/questsystem/CMakeLists.txt	(revision 7380)
+++ code/trunk/src/modules/questsystem/CMakeLists.txt	(revision 7401)
@@ -1,9 +1,3 @@
 SET_SOURCE_FILES(QUESTSYSTEM_SRC_FILES
-  AddQuest.cc
-  AddQuestHint.cc
-  AddReward.cc
-  ChangeQuestStatus.cc
-  CompleteQuest.cc
-  FailQuest.cc
   GlobalQuest.cc
   LocalQuest.cc
@@ -18,4 +12,6 @@
   QuestNotification.cc
 )
+
+ADD_SUBDIRECTORY(effects)
 
 ORXONOX_ADD_LIBRARY(questsystem
Index: code/trunk/src/modules/questsystem/ChangeQuestStatus.cc
===================================================================
--- code/trunk/src/modules/questsystem/ChangeQuestStatus.cc	(revision 7380)
+++ 	(revision )
@@ -1,90 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of the ChangeQuestStatus class.
-*/
-
-#include "ChangeQuestStatus.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "QuestItem.h"
-
-namespace orxonox
-{
-    /**
-    @brief
-        Constructor. Registers the object.
-    */
-    ChangeQuestStatus::ChangeQuestStatus(BaseObject* creator) : QuestEffect(creator)
-    {
-        RegisterObject(ChangeQuestStatus);
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    ChangeQuestStatus::~ChangeQuestStatus()
-    {
-    }
-
-    /**
-    @brief
-        Method for creating a ChangeQuestStatus object through XML.
-    */
-    void ChangeQuestStatus::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(ChangeQuestStatus, XMLPort, xmlelement, mode);
-
-        XMLPortParam(ChangeQuestStatus, "questId", setQuestId, getQuestId, xmlelement, mode);
-    }
-
-    /**
-    @brief
-        Sets the id of the Quest the Questffect changes the status of.
-    @param id
-        The id of the Quest.
-    @return
-        Returns true if successful.
-    */
-    bool ChangeQuestStatus::setQuestId(const std::string & id)
-    {
-        if(id.compare(BLANKSTRING) == 0)
-        {
-            COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;
-            return false;
-        }
-
-        this->questId_ = id;
-        return true;
-    }
-
-}
Index: code/trunk/src/modules/questsystem/ChangeQuestStatus.h
===================================================================
--- code/trunk/src/modules/questsystem/ChangeQuestStatus.h	(revision 7380)
+++ 	(revision )
@@ -1,77 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of the ChangeQuestStatus class.
-*/
-
-#ifndef _ChangeQuestStatus_H__
-#define _ChangeQuestStatus_H__
-
-#include "questsystem/QuestsystemPrereqs.h"
-
-#include <string>
-#include "QuestEffect.h"
-
-namespace orxonox
-{
-    /**
-    @brief
-        A QuestEffect which changes the status of a specified Quest for the player invoking the QuestEffect.
-    @author
-        Damian 'Mozork' Frick
-    */
-    class _QuestsystemExport ChangeQuestStatus : public QuestEffect
-    {
-        public:
-            ChangeQuestStatus(BaseObject* creator);
-            virtual ~ChangeQuestStatus();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a ChangeQuestStatus object through XML.
-
-            virtual bool invoke(PlayerInfo* player) = 0; //!< Invokes the QuestEffect.
-
-        protected:
-            /**
-            @brief Returns the id of the Quest.
-            @return Returns the id of the Quest.
-            */
-            inline const std::string & getQuestId(void) const
-                { return this->questId_; }
-
-        private:
-            std::string questId_; //!< The id of the Quest the status should be changed of.
-
-            bool setQuestId(const std::string & id); //!< Sets the id of the Quest.
-
-    };
-
-}
-
-#endif /* _ChangeQuestStatus_H__ */
Index: code/trunk/src/modules/questsystem/CompleteQuest.cc
===================================================================
--- code/trunk/src/modules/questsystem/CompleteQuest.cc	(revision 7380)
+++ 	(revision )
@@ -1,112 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of the CompleteQuest class.
-*/
-
-#include "CompleteQuest.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "QuestManager.h"
-#include "Quest.h"
-
-namespace orxonox
-{
-    CreateFactory(CompleteQuest);
-
-    /**
-    @brief
-        Constructor. Registers the object.
-    */
-    CompleteQuest::CompleteQuest(BaseObject* creator) : ChangeQuestStatus(creator)
-    {
-        RegisterObject(CompleteQuest);
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    CompleteQuest::~CompleteQuest()
-    {
-    }
-
-    /**
-    @brief
-        Method for creating a CompleteQuest object through XML.
-    */
-    void CompleteQuest::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(CompleteQuest, XMLPort, xmlelement, mode);
-
-        COUT(4) << "New CompleteQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
-    }
-
-    /**
-    @brief
-        Invokes the QuestEffect.
-    @param player
-        The player the QuestEffect is invoked on.
-    @return
-        Returns true if the QuestEffect was invoked successfully.
-    */
-    bool CompleteQuest::invoke(PlayerInfo* player)
-    {
-        if(player == NULL) //!< You know, what we think of NULL-pointers...
-        {
-            COUT(2) << "Input player is NULL." << std::endl;
-            return false;
-        }
-
-        COUT(5) << "CompleteQuest on player: " << player << " ." << std::endl;
-
-        Quest* quest;
-
-        try
-        {
-            quest = QuestManager::getInstance().findQuest(this->getQuestId());
-            if(quest == NULL || !quest->complete(player))
-            {
-               return false;
-            }
-        }
-        catch(const Exception& e)
-        {
-            COUT(2) << e.getFullDescription() << std::endl;
-            return false;
-        }
-
-        COUT(4) << "Quest {" << quest->getId() << "} successfully completed by player: " << player << " ." << std::endl;
-        return true;
-    }
-
-
-}
Index: code/trunk/src/modules/questsystem/CompleteQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/CompleteQuest.h	(revision 7380)
+++ 	(revision )
@@ -1,66 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of the CompleteQuest class.
-*/
-
-#ifndef _CompleteQuest_H__
-#define _CompleteQuest_H__
-
-#include "questsystem/QuestsystemPrereqs.h"
-#include "ChangeQuestStatus.h"
-
-namespace orxonox
-{
-    /**
-    @brief
-        Completes a Quest (with a specified id) for the player invoking the QuestEffect.
-
-        Creating a CompleteQuest through XML goes as follows:
-
-        <CompleteQuest questId="id" />  //Where id is a GUID, see http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure for more information, and identifies the Quest that should be completed.
-    @author
-        Damian 'Mozork' Frick
-    */
-    class _QuestsystemExport CompleteQuest : public ChangeQuestStatus
-    {
-        public:
-            CompleteQuest(BaseObject* creator);
-            virtual ~CompleteQuest();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a CompleteQuest object through XML.
-
-            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
-
-    };
-
-}
-
-#endif /* _CompleteQuest_H__ */
Index: code/trunk/src/modules/questsystem/FailQuest.cc
===================================================================
--- code/trunk/src/modules/questsystem/FailQuest.cc	(revision 7380)
+++ 	(revision )
@@ -1,111 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Implementation of the FailQuest class.
-*/
-
-#include "FailQuest.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "QuestManager.h"
-#include "Quest.h"
-
-namespace orxonox
-{
-    CreateFactory(FailQuest);
-
-    /**
-    @brief
-        Constructor. Registers the object.
-    */
-    FailQuest::FailQuest(BaseObject* creator) : ChangeQuestStatus(creator)
-    {
-        RegisterObject(FailQuest);
-    }
-
-    /**
-    @brief
-        Destructor.
-    */
-    FailQuest::~FailQuest()
-    {
-    }
-
-    /**
-    @brief
-        Method for creating a FailQuest object through XML.
-    */
-    void FailQuest::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(FailQuest, XMLPort, xmlelement, mode);
-
-        COUT(4) << "New FailQUest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
-    }
-
-    /**
-    @brief
-        Invokes the QuestEffect.
-    @param player
-        The player the QuestEffect is invoked on.
-    @return
-        Returns true if the QuestEffect was invoked successfully.
-    */
-    bool FailQuest::invoke(PlayerInfo* player)
-    {
-        if(player == NULL) //!< We don't know what to do with no player.
-        {
-            COUT(2) << "Input player is NULL." << std::endl;
-            return false;
-        }
-
-        COUT(4) << "FailQuest on player: " << player << " ." << std::endl;
-
-        Quest* quest;
-        try
-        {
-            quest = QuestManager::getInstance().findQuest(this->getQuestId());
-            if(quest == NULL || !quest->fail(player))
-            {
-               return false;
-            }
-        }
-        catch(const Exception& e)
-        {
-            COUT(2) << e.getFullDescription() << std::endl;
-            return false;
-        }
-
-        COUT(4) << "Quest {" << quest->getId() << "} failed by player: " << player << " ." << std::endl;
-        return true;
-    }
-
-
-}
Index: code/trunk/src/modules/questsystem/FailQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/FailQuest.h	(revision 7380)
+++ 	(revision )
@@ -1,66 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   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:
- *      Damian 'Mozork' Frick
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file
-    @brief Definition of the FailQuest class.
-*/
-
-#ifndef _FailQuest_H__
-#define _FailQuest_H__
-
-#include "questsystem/QuestsystemPrereqs.h"
-#include "ChangeQuestStatus.h"
-
-namespace orxonox
-{
-    /**
-    @brief
-        Fails a quest (with a specified id) for the player invoking the QuestEffect.
-
-        Creating a FailQuest through XML goes as follows:
-
-        <FailQuest questId="id" />  //Where id is a GUID, see http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure for more information, and identifies the Quest that should be failed.
-    @author
-        Damian 'Mozork' Frick
-    */
-    class _QuestsystemExport FailQuest : public ChangeQuestStatus
-    {
-        public:
-            FailQuest(BaseObject* creator);
-            virtual ~FailQuest();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a FailQuest object through XML.
-
-            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
-
-    };
-
-}
-
-#endif /* _FailQuest_H__ */
Index: code/trunk/src/modules/questsystem/GlobalQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/GlobalQuest.h	(revision 7380)
+++ code/trunk/src/modules/questsystem/GlobalQuest.h	(revision 7401)
@@ -50,5 +50,6 @@
         Creating a GlobalQuest through XML goes as follows:
 
-        <GlobalQuest id="questId"> //Where questId is a GUID, see http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure for more information
+        @code
+        <GlobalQuest id="questId">
             <QuestDescription title="Title" description="Description." /> //The description of the quest.
             <subquests>
@@ -78,4 +79,5 @@
             </reward-effects>
         </GlobalQuest>
+        @endcode
     @author
         Damian 'Mozork' Frick
Index: code/trunk/src/modules/questsystem/LocalQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/LocalQuest.h	(revision 7380)
+++ code/trunk/src/modules/questsystem/LocalQuest.h	(revision 7401)
@@ -49,5 +49,6 @@
         Creating a LocalQuest through XML goes as follows:
 
-        <LocalQuest id="questId"> //Where questId is a GUID, see http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure for more information
+        @code
+        <LocalQuest id="questId">
             <QuestDescription title="Title" description="Description." /> //The description of the quest.
             <subquests>
@@ -72,4 +73,5 @@
             </complete-effects>
         </LocalQuest>
+        @endcode
     @author
         Damian 'Mozork' Frick
Index: code/trunk/src/modules/questsystem/Quest.cc
===================================================================
--- code/trunk/src/modules/questsystem/Quest.cc	(revision 7380)
+++ code/trunk/src/modules/questsystem/Quest.cc	(revision 7401)
@@ -197,5 +197,5 @@
     @brief
         Returns the subquest at the given index.
-    @param
+    @param index
         The index.
     @return
@@ -222,5 +222,5 @@
     @brief
         Returns the QuestHint at the given index.
-    @param
+    @param index
         The index.
     @return
@@ -246,5 +246,5 @@
     @brief
         Returns the fail QuestEffect at the given index.
-    @param
+    @param index
         The index.
     @return
@@ -270,5 +270,5 @@
     @brief
         Returns the complete QuestEffect at the given index.
-    @param
+    @param index
         The index.
     @return
Index: code/trunk/src/modules/questsystem/QuestDescription.h
===================================================================
--- code/trunk/src/modules/questsystem/QuestDescription.h	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestDescription.h	(revision 7401)
@@ -50,5 +50,7 @@
         Creating a QuestDescription through XML goes as follows:
 
+        @code
         <QuestDescription title="Title" description="Description Text" failMessage="You fail." completeMessage="You win!" />
+        @endcode
     @author
         Damian 'Mozork' Frick
Index: code/trunk/src/modules/questsystem/QuestEffectBeacon.cc
===================================================================
--- code/trunk/src/modules/questsystem/QuestEffectBeacon.cc	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestEffectBeacon.cc	(revision 7401)
@@ -92,4 +92,6 @@
         Executes the QuestEffectBeacon.
         This means extracting the Pawn from the PlayerTrigger, provided by the Event causing the execution, and the extracting the PlayerInfo from the received Pawn and invoking the QuestEffectbeacon's QuestEffects on the received PlayerInfo.
+    @param bTriggered
+        true means the trigger was activated while false means it was deactivated
     @param trigger
         A pointer to the PlayerTrigger that threw the Event.
@@ -97,7 +99,7 @@
         Returns true if successfully executed, false if not.
     */
-    bool QuestEffectBeacon::execute(bool b, BaseObject* trigger)
-    {
-        if(!b)
+    bool QuestEffectBeacon::execute(bool bTriggered, BaseObject* trigger)
+    {
+        if(!bTriggered)
         {
             return false;
Index: code/trunk/src/modules/questsystem/QuestEffectBeacon.h
===================================================================
--- code/trunk/src/modules/questsystem/QuestEffectBeacon.h	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestEffectBeacon.h	(revision 7401)
@@ -61,4 +61,5 @@
         Creating a QuestEffectBeacon through XML goes as follows:
 
+        @code
         <QuestEffectBeacon times=n> //Where 'n' is eighter a number >= 0, which means the QuestEffectBeacon can be executed n times. Or n = -1, which means the QuestEffectBeacon can be executed an infinite number of times.
             <effects>
@@ -76,4 +77,5 @@
             </attached>
         </QuestEffectBeacon>
+        @endcode
     @author
         Damian 'Mozork' Frick
@@ -88,5 +90,5 @@
             virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
 
-            bool execute(bool b, BaseObject* trigger); //!< Executes the QuestEffects of the QuestEffectBeacon.
+            bool execute(bool bTriggered, BaseObject* trigger); //!< Executes the QuestEffects of the QuestEffectBeacon.
 
             /**
Index: code/trunk/src/modules/questsystem/QuestHint.h
===================================================================
--- code/trunk/src/modules/questsystem/QuestHint.h	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestHint.h	(revision 7401)
@@ -60,7 +60,9 @@
         Creating a QuestHint through XML goes as follows:
 
-        <QuestHint id="hintId">  //Where hintId is a GUID, see http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure for more information
+        @code
+        <QuestHint id="hintId">
             <QuestDesctription title="" description="" />
         </QuestHint>
+        @endcode
     @author
         Damian 'Mozork' Frick
Index: code/trunk/src/modules/questsystem/QuestItem.cc
===================================================================
--- code/trunk/src/modules/questsystem/QuestItem.cc	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestItem.cc	(revision 7401)
@@ -78,5 +78,7 @@
     @brief
         Sets the id of the QuestItem.
-    The id must be of GUID form. See 'http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure' for more information.
+        The id can be any string and must be unique in the context it is used (commonly a level file). To ensure uniqueness one could use GUIDs, however they are in general less readable, so make your own choice.
+    @see
+        http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure
     @param id
         The id to be set.
Index: code/trunk/src/modules/questsystem/QuestItem.h
===================================================================
--- code/trunk/src/modules/questsystem/QuestItem.h	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestItem.h	(revision 7401)
@@ -98,5 +98,5 @@
 
         private:
-            std::string id_; //!< Identifier. Should be of GUID form: http://en.wikipedia.org/wiki/Globally_Unique_Identifier#Basic_structure
+            std::string id_; //!< Identifier. Must be unique.
             QuestDescription* description_; //!< The QuestDescription of the QuestItem.
 
Index: code/trunk/src/modules/questsystem/QuestListener.h
===================================================================
--- code/trunk/src/modules/questsystem/QuestListener.h	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestListener.h	(revision 7401)
@@ -62,4 +62,5 @@
         You can use the QuestListener as if it were a Trigger or EventListener, that fires an Event when the status (depending on the set mode) of the given Quest changes.
 
+        @code
         <BaseObject> // The object that should react to the status change of a Quest.
             <events>
@@ -69,4 +70,5 @@
             </events>
         </BaseObject>
+        @endcode
     @author
     Damian 'Mozork' Frick
Index: code/trunk/src/modules/questsystem/QuestNotification.cc
===================================================================
--- code/trunk/src/modules/questsystem/QuestNotification.cc	(revision 7380)
+++ code/trunk/src/modules/questsystem/QuestNotification.cc	(revision 7401)
@@ -48,4 +48,6 @@
     @brief
         Creates a QuestNotification with the input message.
+    @param creator
+        The creator of this object
     @param message
         The message to be sent.
Index: code/trunk/src/modules/questsystem/effects/AddQuest.cc
===================================================================
--- code/trunk/src/modules/questsystem/effects/AddQuest.cc	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/AddQuest.cc	(revision 7401)
@@ -0,0 +1,110 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the AddQuest class.
+*/
+
+#include "AddQuest.h"
+
+#include "util/Exception.h"
+#include "core/CoreIncludes.h"
+#include "questsystem/QuestManager.h"
+#include "questsystem/Quest.h"
+
+namespace orxonox
+{
+    CreateFactory(AddQuest);
+
+    /**
+    @brief
+        Constructor. Registers the object.
+    */
+    AddQuest::AddQuest(BaseObject* creator) : ChangeQuestStatus(creator)
+    {
+        RegisterObject(AddQuest);
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    AddQuest::~AddQuest()
+    {
+    }
+
+    /**
+    @brief
+        Method for creating a AddQuest object through XML.
+    */
+    void AddQuest::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(AddQuest, XMLPort, xmlelement, mode);
+
+        COUT(4) << "New AddQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+    }
+
+    /**
+    @brief
+        Invokes the QuestEffect.
+    @param player
+        The player the QuestEffect is invoked on.
+    @return
+        Returns true if the QuestEffect was successfully invoked.
+    */
+    bool AddQuest::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< Null-pointers are badass.
+        {
+            COUT(2) << "Input player is NULL." << std::endl;
+            return false;
+        }
+
+        COUT(5) << "AddQuest on player: " << player << " ." << std::endl;
+
+        try
+        {
+            Quest* quest = QuestManager::getInstance().findQuest(this->getQuestId());
+            if(quest == NULL || !quest->start(player))
+            {
+               return false;
+            }
+        }
+        catch(const orxonox::Exception& ex)
+        {
+            COUT(2) << ex.getFullDescription() << std::endl;
+            return false;
+        }
+
+        COUT(4) << "Quest {" << this->getQuestId() << "} successfully added to player: " << player << " ." << std::endl;
+        return true;
+    }
+
+
+}
Index: code/trunk/src/modules/questsystem/effects/AddQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/effects/AddQuest.h	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/AddQuest.h	(revision 7401)
@@ -0,0 +1,68 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Definition of the AddQuest class.
+*/
+
+#ifndef _AddQuest_H__
+#define _AddQuest_H__
+
+#include "questsystem/QuestsystemPrereqs.h"
+#include "ChangeQuestStatus.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        Adds a Quest, resp. changes the quests status to active for the player invoking the Quest.
+
+        Creating a AddQuest through XML goes as follows:
+
+        @code
+        <AddQuest questId="id" />  //Where id identifies the Quest that should be added.
+        @endcode
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _QuestsystemExport AddQuest : public ChangeQuestStatus
+    {
+        public:
+        AddQuest(BaseObject* creator);
+        virtual ~AddQuest();
+
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a AddQuest object through XML.
+
+        virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
+
+    };
+
+}
+
+#endif /* _AddQuest_H__ */
Index: code/trunk/src/modules/questsystem/effects/AddQuestHint.cc
===================================================================
--- code/trunk/src/modules/questsystem/effects/AddQuestHint.cc	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/AddQuestHint.cc	(revision 7401)
@@ -0,0 +1,133 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the AddQuestHint class.
+*/
+
+#include "AddQuestHint.h"
+
+#include "util/Exception.h"
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "questsystem/QuestManager.h"
+#include "questsystem/QuestItem.h"
+#include "questsystem/QuestHint.h"
+
+namespace orxonox
+{
+    CreateFactory(AddQuestHint);
+
+    /**
+    @brief
+        Constructor. Registers the object.
+    */
+    AddQuestHint::AddQuestHint(BaseObject* creator) : QuestEffect(creator)
+    {
+        RegisterObject(AddQuestHint);
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    AddQuestHint::~AddQuestHint()
+    {
+    }
+
+    /**
+    @brief
+        Method for creating a AddQuestHint object through XML.
+    */
+    void AddQuestHint::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(AddQuestHint, XMLPort, xmlelement, mode);
+
+        XMLPortParam(AddQuestHint, "hintId", setHintId, getHintId, xmlelement, mode);
+
+        COUT(4) << "New AddQuestHint, with target QuestHint {" << this->getHintId() << "}, created." << std::endl;
+    }
+
+    /**
+    @brief
+        Sets the id of the QuestHint to be added to the player the QuestEffect is invoked on.
+    @param id
+        The QuestHint id.
+    @return
+        Returns true if successful.
+    */
+    bool AddQuestHint::setHintId(const std::string & id)
+    {
+        if(id.compare(BLANKSTRING) == 0)
+        {
+            COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;
+            return false;
+        }
+
+        this->hintId_ = id;
+        return true;
+    }
+
+    /**
+    @brief
+        Invokes the QuestEffect.
+    @param player
+        The player.
+    @return
+        Returns true if the QuestEffect was successfully invoked.
+    */
+    bool AddQuestHint::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< NULL-pointers are evil!
+        {
+            COUT(2) << "The input player is NULL." << std::endl;
+            return false;
+        }
+
+        COUT(5) << "AddQuestHint on player: " << player << " ." << std::endl;
+
+        try
+        {
+            QuestHint* hint = QuestManager::getInstance().findHint(this->hintId_);
+            if(hint == NULL || !hint->setActive(player))
+            {
+                return false;
+            }
+        }
+        catch(const Exception& e)
+        {
+           COUT(2) << e.getFullDescription() << std::endl;
+           return false;
+        }
+
+        COUT(4) << "QuestHint {" << this->getHintId() << "} successfully added to player: " << player << " ." << std::endl;
+        return true;
+
+    }
+}
Index: code/trunk/src/modules/questsystem/effects/AddQuestHint.h
===================================================================
--- code/trunk/src/modules/questsystem/effects/AddQuestHint.h	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/AddQuestHint.h	(revision 7401)
@@ -0,0 +1,82 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Definition of the AddQuestHint class.
+*/
+
+#ifndef _AddQuestHint_H__
+#define _AddQuestHint_H__
+
+#include "questsystem/QuestsystemPrereqs.h"
+
+#include <string>
+#include "questsystem/QuestEffect.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        Adds a QuestHint, resp. activates the QuestHint of the given id for the player the QuestEffect is invoked on.
+
+        Creating a AddQuestHint through XML goes as follows:
+
+        @code
+        <AddQuestHint hintId="id" />  //Where id identifies the QuestHint that should be added.
+        @endcode
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _QuestsystemExport AddQuestHint : public QuestEffect
+    {
+        public:
+            AddQuestHint(BaseObject* creator);
+            virtual ~AddQuestHint();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a AddQuestHint object through XML.
+
+            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
+
+        private:
+            std::string hintId_; //!< The id of the QuestHint.
+
+            /**
+            @brief Returns the id of the QuestHint.
+            @return Returns the id of the QuestHint.
+            */
+            inline const std::string & getHintId(void) const
+                { return this->hintId_; }
+
+            bool setHintId(const std::string & id); //!< Sets the id of the QuestHint.
+
+    };
+
+}
+
+#endif /* _AddQuestHint_H__ */
Index: code/trunk/src/modules/questsystem/effects/AddReward.cc
===================================================================
--- code/trunk/src/modules/questsystem/effects/AddReward.cc	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/AddReward.cc	(revision 7401)
@@ -0,0 +1,118 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the AddReward class.
+*/
+
+#include "AddReward.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "interfaces/Rewardable.h"
+
+namespace orxonox
+{
+    CreateFactory(AddReward);
+
+    /**
+    @brief
+        Constructor. Registers the object.
+    */
+    AddReward::AddReward(BaseObject* creator) : QuestEffect(creator)
+    {
+        RegisterObject(AddReward);
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    AddReward::~AddReward()
+    {
+    }
+
+    /**
+        Method for creating a AddReward object through XML.
+    */
+    void AddReward::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(AddReward, XMLPort, xmlelement, mode);
+
+        XMLPortObject(AddReward, Rewardable, "", addRewardable, getRewardables, xmlelement, mode);
+
+        COUT(4) << "New AddReward, with " << this->rewards_.size() << " Rewardables created." << std::endl;
+    }
+
+    /**
+    @brief
+        Returns the Rewardable object at the given index.
+    @param index
+        The index.
+    @return
+        Returns a pointer to the Rewardable object at the given index.
+    */
+    const Rewardable* AddReward::getRewardables(unsigned int index) const
+    {
+        int i = index;
+        for (std::list<Rewardable*>::const_iterator reward = this->rewards_.begin(); reward != this->rewards_.end(); ++reward)
+        {
+            if(i == 0)
+            {
+               return *reward;
+            }
+            i--;
+        }
+        return NULL;
+    }
+
+    /**
+    @brief
+        Invokes the QuestEffect.
+    @param player
+        The player.
+    @return
+        Returns true if the QuestEffect was invoked successfully.
+    */
+    bool AddReward::invoke(PlayerInfo* player)
+    {
+        COUT(5) << "AddReward on player: " << player << " ." << std::endl;
+
+        bool check = true;
+        for ( std::list<Rewardable*>::iterator reward = this->rewards_.begin(); reward != this->rewards_.end(); ++reward )
+        {
+            check = check && (*reward)->reward(player);
+        }
+
+        COUT(4) << "Rewardable successfully added to player." << player << " ." << std::endl;
+
+        return check;
+    }
+
+}
Index: code/trunk/src/modules/questsystem/effects/AddReward.h
===================================================================
--- code/trunk/src/modules/questsystem/effects/AddReward.h	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/AddReward.h	(revision 7401)
@@ -0,0 +1,86 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Definition of the AddReward class.
+*/
+
+#ifndef _AddReward_H__
+#define _AddReward_H__
+
+#include "questsystem/QuestsystemPrereqs.h"
+
+#include <list>
+#include "questsystem/QuestEffect.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        Adds a list of Rewardables to a player.
+
+        Creating a AddReward through XML goes as follows:
+
+        @code
+        <AddReward>
+            <Rewardable /> //A list of Rewardable objects to be rewarded the player, see the specific Rewardables for their respective XML representations.
+            ...
+            <Rewardable />
+        </AddReward>
+        @endcode
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _QuestsystemExport AddReward : public QuestEffect
+    {
+        public:
+            AddReward(BaseObject* creator);
+            virtual ~AddReward();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a AddReward object through XML.
+
+            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
+
+        private:
+            std::list<Rewardable*> rewards_; //!< A list of Rewardables to be added to the player invoking the QuestEffect.
+
+            /**
+            @brief Add a Rewardable object to the list of objects to be awarded to the player invoking the QuestEffect.
+            @param reward Pointer to the Rewardable to be added.
+            */
+            inline void addRewardable(Rewardable* reward)
+                { this->rewards_.push_back(reward); }
+
+            const Rewardable* getRewardables(unsigned int index) const; //!< Returns the Rewardable object at the given index.
+
+    };
+
+}
+
+#endif /* _AddReward_H__ */
Index: code/trunk/src/modules/questsystem/effects/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/questsystem/effects/CMakeLists.txt	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/CMakeLists.txt	(revision 7401)
@@ -0,0 +1,9 @@
+ADD_SOURCE_FILES(QUESTSYSTEM_SRC_FILES
+  AddQuest.cc
+  AddQuestHint.cc
+  AddReward.cc
+  ChangeQuestStatus.cc
+  CompleteQuest.cc
+  FailQuest.cc
+)
+
Index: code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.cc
===================================================================
--- code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.cc	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.cc	(revision 7401)
@@ -0,0 +1,90 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the ChangeQuestStatus class.
+*/
+
+#include "ChangeQuestStatus.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "questsystem/QuestItem.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        Constructor. Registers the object.
+    */
+    ChangeQuestStatus::ChangeQuestStatus(BaseObject* creator) : QuestEffect(creator)
+    {
+        RegisterObject(ChangeQuestStatus);
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    ChangeQuestStatus::~ChangeQuestStatus()
+    {
+    }
+
+    /**
+    @brief
+        Method for creating a ChangeQuestStatus object through XML.
+    */
+    void ChangeQuestStatus::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(ChangeQuestStatus, XMLPort, xmlelement, mode);
+
+        XMLPortParam(ChangeQuestStatus, "questId", setQuestId, getQuestId, xmlelement, mode);
+    }
+
+    /**
+    @brief
+        Sets the id of the Quest the Questffect changes the status of.
+    @param id
+        The id of the Quest.
+    @return
+        Returns true if successful.
+    */
+    bool ChangeQuestStatus::setQuestId(const std::string & id)
+    {
+        if(id.compare(BLANKSTRING) == 0)
+        {
+            COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;
+            return false;
+        }
+
+        this->questId_ = id;
+        return true;
+    }
+
+}
Index: code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.h
===================================================================
--- code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.h	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.h	(revision 7401)
@@ -0,0 +1,77 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Definition of the ChangeQuestStatus class.
+*/
+
+#ifndef _ChangeQuestStatus_H__
+#define _ChangeQuestStatus_H__
+
+#include "questsystem/QuestsystemPrereqs.h"
+
+#include <string>
+#include "questsystem/QuestEffect.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        A QuestEffect which changes the status of a specified Quest for the player invoking the QuestEffect.
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _QuestsystemExport ChangeQuestStatus : public QuestEffect
+    {
+        public:
+            ChangeQuestStatus(BaseObject* creator);
+            virtual ~ChangeQuestStatus();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a ChangeQuestStatus object through XML.
+
+            virtual bool invoke(PlayerInfo* player) = 0; //!< Invokes the QuestEffect.
+
+        protected:
+            /**
+            @brief Returns the id of the Quest.
+            @return Returns the id of the Quest.
+            */
+            inline const std::string & getQuestId(void) const
+                { return this->questId_; }
+
+        private:
+            std::string questId_; //!< The id of the Quest the status should be changed of.
+
+            bool setQuestId(const std::string & id); //!< Sets the id of the Quest.
+
+    };
+
+}
+
+#endif /* _ChangeQuestStatus_H__ */
Index: code/trunk/src/modules/questsystem/effects/CompleteQuest.cc
===================================================================
--- code/trunk/src/modules/questsystem/effects/CompleteQuest.cc	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/CompleteQuest.cc	(revision 7401)
@@ -0,0 +1,112 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the CompleteQuest class.
+*/
+
+#include "CompleteQuest.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "questsystem/QuestManager.h"
+#include "questsystem/Quest.h"
+
+namespace orxonox
+{
+    CreateFactory(CompleteQuest);
+
+    /**
+    @brief
+        Constructor. Registers the object.
+    */
+    CompleteQuest::CompleteQuest(BaseObject* creator) : ChangeQuestStatus(creator)
+    {
+        RegisterObject(CompleteQuest);
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    CompleteQuest::~CompleteQuest()
+    {
+    }
+
+    /**
+    @brief
+        Method for creating a CompleteQuest object through XML.
+    */
+    void CompleteQuest::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(CompleteQuest, XMLPort, xmlelement, mode);
+
+        COUT(4) << "New CompleteQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+    }
+
+    /**
+    @brief
+        Invokes the QuestEffect.
+    @param player
+        The player the QuestEffect is invoked on.
+    @return
+        Returns true if the QuestEffect was invoked successfully.
+    */
+    bool CompleteQuest::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< You know, what we think of NULL-pointers...
+        {
+            COUT(2) << "Input player is NULL." << std::endl;
+            return false;
+        }
+
+        COUT(5) << "CompleteQuest on player: " << player << " ." << std::endl;
+
+        Quest* quest;
+
+        try
+        {
+            quest = QuestManager::getInstance().findQuest(this->getQuestId());
+            if(quest == NULL || !quest->complete(player))
+            {
+               return false;
+            }
+        }
+        catch(const Exception& e)
+        {
+            COUT(2) << e.getFullDescription() << std::endl;
+            return false;
+        }
+
+        COUT(4) << "Quest {" << quest->getId() << "} successfully completed by player: " << player << " ." << std::endl;
+        return true;
+    }
+
+
+}
Index: code/trunk/src/modules/questsystem/effects/CompleteQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/effects/CompleteQuest.h	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/CompleteQuest.h	(revision 7401)
@@ -0,0 +1,68 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Definition of the CompleteQuest class.
+*/
+
+#ifndef _CompleteQuest_H__
+#define _CompleteQuest_H__
+
+#include "questsystem/QuestsystemPrereqs.h"
+#include "ChangeQuestStatus.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        Completes a Quest (with a specified id) for the player invoking the QuestEffect.
+
+        Creating a CompleteQuest through XML goes as follows:
+
+        @code
+        <CompleteQuest questId="id" />  //Where id identifies the Quest that should be completed.
+        @endcode
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _QuestsystemExport CompleteQuest : public ChangeQuestStatus
+    {
+        public:
+            CompleteQuest(BaseObject* creator);
+            virtual ~CompleteQuest();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a CompleteQuest object through XML.
+
+            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
+
+    };
+
+}
+
+#endif /* _CompleteQuest_H__ */
Index: code/trunk/src/modules/questsystem/effects/FailQuest.cc
===================================================================
--- code/trunk/src/modules/questsystem/effects/FailQuest.cc	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/FailQuest.cc	(revision 7401)
@@ -0,0 +1,111 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the FailQuest class.
+*/
+
+#include "FailQuest.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "questsystem/QuestManager.h"
+#include "questsystem/Quest.h"
+
+namespace orxonox
+{
+    CreateFactory(FailQuest);
+
+    /**
+    @brief
+        Constructor. Registers the object.
+    */
+    FailQuest::FailQuest(BaseObject* creator) : ChangeQuestStatus(creator)
+    {
+        RegisterObject(FailQuest);
+    }
+
+    /**
+    @brief
+        Destructor.
+    */
+    FailQuest::~FailQuest()
+    {
+    }
+
+    /**
+    @brief
+        Method for creating a FailQuest object through XML.
+    */
+    void FailQuest::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(FailQuest, XMLPort, xmlelement, mode);
+
+        COUT(4) << "New FailQUest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+    }
+
+    /**
+    @brief
+        Invokes the QuestEffect.
+    @param player
+        The player the QuestEffect is invoked on.
+    @return
+        Returns true if the QuestEffect was invoked successfully.
+    */
+    bool FailQuest::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< We don't know what to do with no player.
+        {
+            COUT(2) << "Input player is NULL." << std::endl;
+            return false;
+        }
+
+        COUT(4) << "FailQuest on player: " << player << " ." << std::endl;
+
+        Quest* quest;
+        try
+        {
+            quest = QuestManager::getInstance().findQuest(this->getQuestId());
+            if(quest == NULL || !quest->fail(player))
+            {
+               return false;
+            }
+        }
+        catch(const Exception& e)
+        {
+            COUT(2) << e.getFullDescription() << std::endl;
+            return false;
+        }
+
+        COUT(4) << "Quest {" << quest->getId() << "} failed by player: " << player << " ." << std::endl;
+        return true;
+    }
+
+
+}
Index: code/trunk/src/modules/questsystem/effects/FailQuest.h
===================================================================
--- code/trunk/src/modules/questsystem/effects/FailQuest.h	(revision 7401)
+++ code/trunk/src/modules/questsystem/effects/FailQuest.h	(revision 7401)
@@ -0,0 +1,68 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Definition of the FailQuest class.
+*/
+
+#ifndef _FailQuest_H__
+#define _FailQuest_H__
+
+#include "questsystem/QuestsystemPrereqs.h"
+#include "ChangeQuestStatus.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        Fails a quest (with a specified id) for the player invoking the QuestEffect.
+
+        Creating a FailQuest through XML goes as follows:
+
+        @code
+        <FailQuest questId="id" />  //Where id identifies the Quest that should be failed.
+        @endcode
+    @author
+        Damian 'Mozork' Frick
+    */
+    class _QuestsystemExport FailQuest : public ChangeQuestStatus
+    {
+        public:
+            FailQuest(BaseObject* creator);
+            virtual ~FailQuest();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a FailQuest object through XML.
+
+            virtual bool invoke(PlayerInfo* player); //!< Invokes the QuestEffect.
+
+    };
+
+}
+
+#endif /* _FailQuest_H__ */
Index: code/trunk/src/orxonox/CMakeLists.txt
===================================================================
--- code/trunk/src/orxonox/CMakeLists.txt	(revision 7380)
+++ code/trunk/src/orxonox/CMakeLists.txt	(revision 7401)
@@ -19,5 +19,4 @@
 
 INCLUDE_DIRECTORIES(
-  ${CMAKE_SOURCE_DIR}/src/external
   ${CMAKE_SOURCE_DIR}/src/libraries
   ${CMAKE_CURRENT_SOURCE_DIR}
Index: code/trunk/src/orxonox/Main.cc
===================================================================
--- code/trunk/src/orxonox/Main.cc	(revision 7380)
+++ code/trunk/src/orxonox/Main.cc	(revision 7401)
@@ -43,12 +43,4 @@
 #include "Main.h"
 
-SetCommandLineSwitch(console).information("Start in console mode (text IO only)");
-// Shortcuts for easy direct loading
-SetCommandLineSwitch(server).information("Start in server mode");
-SetCommandLineSwitch(client).information("Start in client mode");
-SetCommandLineSwitch(dedicated).information("Start in dedicated server mode");
-SetCommandLineSwitch(standalone).information("Start in standalone mode");
-SetCommandLineSwitch(dedicatedClient).information("Start in dedicated client mode");
-
 DeclareToluaInterface(Orxonox);
 DeclareToluaInterface(Network);
@@ -56,4 +48,14 @@
 namespace orxonox
 {
+    SetCommandLineSwitch(console).information("Start in console mode (text IO only)");
+    SetCommandLineSwitch(server).information("Start in server mode");
+    SetCommandLineSwitch(client).information("Start in client mode");
+    SetCommandLineSwitch(dedicated).information("Start in dedicated server mode");
+    SetCommandLineSwitch(standalone).information("Start in standalone mode");
+    SetCommandLineSwitch(dedicatedClient).information("Start in dedicated client mode");
+
+    SetCommandLineArgument(generateDoc, "")
+        .information("Generates a Doxygen file from things like SetConsoleCommand");
+
     /**
     @brief
@@ -64,34 +66,38 @@
         Game* game = new Game(strCmdLine);
 
-        game->setStateHierarchy(
-        "root"
-        " graphics"
-        "  mainMenu"
-        "  standalone,server,client"
-        "   level"
-        " server,client"
-        "  level"
-        );
+        if (CommandLineParser::getValue("generateDoc").getString().empty())
+        {
+            game->setStateHierarchy(
+            "root"
+            " graphics"
+            "  mainMenu"
+            "  standalone,server,client"
+            "   level"
+            " server,client"
+            "  level"
+            );
 
-        game->requestState("root");
+            game->requestState("root");
 
-        // Some development hacks (not really, but in the future, this calls won't make sense anymore)
-        if (CommandLineParser::getValue("standalone").getBool())
-            Game::getInstance().requestStates("graphics, standalone, level");
-        else if (CommandLineParser::getValue("server").getBool())
-            Game::getInstance().requestStates("graphics, server, level");
-        else if (CommandLineParser::getValue("client").getBool())
-            Game::getInstance().requestStates("graphics, client, level");
-        else if (CommandLineParser::getValue("dedicated").getBool())
-            Game::getInstance().requestStates("server, level");
-        else if (CommandLineParser::getValue("dedicatedClient").getBool())
-            Game::getInstance().requestStates("client, level");
-        else
-        {
-            if (!CommandLineParser::getValue("console").getBool())
-                Game::getInstance().requestStates("graphics, mainMenu");
+            // Some development hacks (not really, but in the future, these calls won't make sense anymore)
+            if (CommandLineParser::getValue("standalone").getBool())
+                Game::getInstance().requestStates("graphics, standalone, level");
+            else if (CommandLineParser::getValue("server").getBool())
+                Game::getInstance().requestStates("graphics, server, level");
+            else if (CommandLineParser::getValue("client").getBool())
+                Game::getInstance().requestStates("graphics, client, level");
+            else if (CommandLineParser::getValue("dedicated").getBool())
+                Game::getInstance().requestStates("server, level");
+            else if (CommandLineParser::getValue("dedicatedClient").getBool())
+                Game::getInstance().requestStates("client, level");
+            else
+            {
+                if (!CommandLineParser::getValue("console").getBool())
+                    Game::getInstance().requestStates("graphics, mainMenu");
+            }
+
+            game->run();
         }
 
-        game->run();
         delete game;
 
Index: code/trunk/src/orxonox/collisionshapes/CollisionShape.cc
===================================================================
--- code/trunk/src/orxonox/collisionshapes/CollisionShape.cc	(revision 7380)
+++ code/trunk/src/orxonox/collisionshapes/CollisionShape.cc	(revision 7401)
@@ -150,5 +150,5 @@
     }
 
-    void CollisionShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const
+    void CollisionShape::calculateLocalInertia(float mass, btVector3& inertia) const
     {
         if (this->collisionShape_)
Index: code/trunk/src/orxonox/controllers/ArtificialController.cc
===================================================================
--- code/trunk/src/orxonox/controllers/ArtificialController.cc	(revision 7380)
+++ code/trunk/src/orxonox/controllers/ArtificialController.cc	(revision 7401)
@@ -558,5 +558,5 @@
 
     /**
-        @brief Master sets its slaves free for @var FREEDOM_COUNT seconds.
+        @brief Master sets its slaves free for @ref FREEDOM_COUNT seconds.
     */
     void ArtificialController::forceFreeSlaves()
@@ -665,5 +665,5 @@
         @brief Master begins to follow a pawn. Is a "specific master action".
         @param pawn pawn to follow.
-        @param alaways follows pawn forever if true (false if omitted).
+        @param always follows pawn forever if true (false if omitted).
         @param secondsToFollow seconds to follow the pawn if always is false. Will follow pawn 100 seconds if omitted (set in header).
     */
Index: code/trunk/src/orxonox/gamestates/GSServer.cc
===================================================================
--- code/trunk/src/orxonox/gamestates/GSServer.cc	(revision 7380)
+++ code/trunk/src/orxonox/gamestates/GSServer.cc	(revision 7401)
@@ -53,5 +53,5 @@
     void GSServer::activate()
     {
-        GameMode::setHasServer(true);
+        GameMode::setIsServer(true);
 
         this->server_ = new Server(CommandLineParser::getValue("port"));
@@ -66,5 +66,5 @@
         delete this->server_;
 
-        GameMode::setHasServer(false);
+        GameMode::setIsServer(false);
     }
 
Index: code/trunk/src/orxonox/graphics/Light.h
===================================================================
--- code/trunk/src/orxonox/graphics/Light.h	(revision 7380)
+++ code/trunk/src/orxonox/graphics/Light.h	(revision 7401)
@@ -83,9 +83,10 @@
             /**
                 @brief Sets the attenuation parameters of the light source i.e. how it diminishes with distance.
+                @param attenuation The parameters of the attenuation (see description)
 
-                @param attenuation.x range (The absolute upper range of the light in world units)
-                @param attenuation.y constant (The constant factor in the attenuation formula: 1.0 means never attenuate, 0.0 is complete attenuation)
-                @param attenuation.z linear (The linear factor in the attenuation formula: 1 means attenuate evenly over the distance)
-                @param attenuation.w quadratic (The quadratic factor in the attenuation formula: adds a curvature to the attenuation formula)
+                 - @a attenuation.x range (The absolute upper range of the light in world units)
+                 - @a attenuation.y constant (The constant factor in the attenuation formula: 1.0 means never attenuate, 0.0 is complete attenuation)
+                 - @a attenuation.z linear (The linear factor in the attenuation formula: 1 means attenuate evenly over the distance)
+                 - @a attenuation.w quadratic (The quadratic factor in the attenuation formula: adds a curvature to the attenuation formula)
 
                 Quote from the Ogre API:
@@ -120,8 +121,9 @@
             /**
                 @brief Sets the range of a spotlight, i.e. the angle of the inner and outer cones and the rate of falloff between them.
-
-                @param spotlightRange.x innerAngle (The angle covered by the bright inner cone)
-                @param spotlightRange.x outerAngle (The angle covered by the outer cone)
-                @param spotlightRange.x falloff (The rate of falloff between the inner and outer cones. 1.0 means a linear falloff, less means slower falloff, higher means faster falloff.)
+                @param spotlightRange The parameters of the spotlight (see description)
+                
+                 - @a spotlightRange.x innerAngle (The angle covered by the bright inner cone)
+                 - @a spotlightRange.x outerAngle (The angle covered by the outer cone)
+                 - @a spotlightRange.x falloff (The rate of falloff between the inner and outer cones. 1.0 means a linear falloff, less means slower falloff, higher means faster falloff.)
             */
             inline void setSpotlightRange(const Vector3& spotlightRange)
Index: code/trunk/src/orxonox/interfaces/Pickupable.h
===================================================================
--- code/trunk/src/orxonox/interfaces/Pickupable.h	(revision 7380)
+++ code/trunk/src/orxonox/interfaces/Pickupable.h	(revision 7401)
@@ -161,6 +161,5 @@
             @brief Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
                    This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.:
-                   DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position, float triggerDistance);
-            @param position The position at which the PickupSpawner should be placed.
+                   DroppedPickup(BaseObject* creator, Pickupable* pickup, PickupCarrier* carrier, float triggerDistance);
             @return Returns true if a spawner was created, false if not.
             */
Index: code/trunk/src/orxonox/overlays/GUISheet.cc
===================================================================
--- code/trunk/src/orxonox/overlays/GUISheet.cc	(revision 7380)
+++ code/trunk/src/orxonox/overlays/GUISheet.cc	(revision 7401)
@@ -54,12 +54,12 @@
     }
 
-    void GUISheet::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    void GUISheet::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        SUPER(GUISheet, XMLPort, xmlElement, mode);
+        SUPER(GUISheet, XMLPort, xmlelement, mode);
 
-        XMLPortParam(GUISheet, "showOnLoad",   setShowOnLoad,     getShowOnLoad,     xmlElement, mode);
-        XMLPortParam(GUISheet, "hidePrevious", setPreviousHiding, getPreviousHiding, xmlElement, mode);
-        XMLPortParam(GUISheet, "sheetName",    setSheetName,      getSheetName,      xmlElement, mode);
-        XMLPortParam(GUISheet, "backgroundImage",  setBackgroundImage,  getBackgroundImage,  xmlElement, mode);
+        XMLPortParam(GUISheet, "showOnLoad",   setShowOnLoad,     getShowOnLoad,     xmlelement, mode);
+        XMLPortParam(GUISheet, "hidePrevious", setPreviousHiding, getPreviousHiding, xmlelement, mode);
+        XMLPortParam(GUISheet, "sheetName",    setSheetName,      getSheetName,      xmlelement, mode);
+        XMLPortParam(GUISheet, "backgroundImage",  setBackgroundImage,  getBackgroundImage,  xmlelement, mode);
 
         if (this->bShowOnLoad_)
Index: code/trunk/src/orxonox/overlays/GUISheet.h
===================================================================
--- code/trunk/src/orxonox/overlays/GUISheet.h	(revision 7380)
+++ code/trunk/src/orxonox/overlays/GUISheet.h	(revision 7401)
@@ -44,5 +44,5 @@
         ~GUISheet();
 
-        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         void show();
Index: code/trunk/src/orxonox/overlays/InGameConsole.cc
===================================================================
--- code/trunk/src/orxonox/overlays/InGameConsole.cc	(revision 7380)
+++ code/trunk/src/orxonox/overlays/InGameConsole.cc	(revision 7401)
@@ -454,5 +454,8 @@
     /**
         @brief Prints string to bottom line.
-        @param s String to be printed
+        @param text The string to be printed
+        @param type The type of the text, defines the color
+        @param index The index of the text overlay in which the string will be displayed
+        @param alwaysShift If true the ohter lines in the console are always shifted by one line
     */
     void InGameConsole::print(const std::string& text, Shell::LineType type, int index, bool alwaysShift)
Index: code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc
===================================================================
--- code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc	(revision 7380)
+++ code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc	(revision 7401)
@@ -126,14 +126,14 @@
         BaseObject::XMLPort()
     */
-    void OrxonoxOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-    {
-        SUPER(OrxonoxOverlay, XMLPort, xmlElement, mode);
-
-        XMLPortParam(OrxonoxOverlay, "size",      setSize,      getSize,      xmlElement, mode);
-        XMLPortParam(OrxonoxOverlay, "pickpoint", setPickPoint, getPickPoint, xmlElement, mode);
-        XMLPortParam(OrxonoxOverlay, "position",  setPosition,  getPosition,  xmlElement, mode);
-        XMLPortParam(OrxonoxOverlay, "rotation",  setRotation,  getRotation,  xmlElement, mode);
-        XMLPortParam(OrxonoxOverlay, "correctaspect", setAspectCorrection,   getAspectCorrection,   xmlElement, mode);
-        XMLPortParam(OrxonoxOverlay, "background",    setBackgroundMaterial, getBackgroundMaterial, xmlElement, mode);
+    void OrxonoxOverlay::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(OrxonoxOverlay, XMLPort, xmlelement, mode);
+
+        XMLPortParam(OrxonoxOverlay, "size",      setSize,      getSize,      xmlelement, mode);
+        XMLPortParam(OrxonoxOverlay, "pickpoint", setPickPoint, getPickPoint, xmlelement, mode);
+        XMLPortParam(OrxonoxOverlay, "position",  setPosition,  getPosition,  xmlelement, mode);
+        XMLPortParam(OrxonoxOverlay, "rotation",  setRotation,  getRotation,  xmlelement, mode);
+        XMLPortParam(OrxonoxOverlay, "correctaspect", setAspectCorrection,   getAspectCorrection,   xmlelement, mode);
+        XMLPortParam(OrxonoxOverlay, "background",    setBackgroundMaterial, getBackgroundMaterial, xmlelement, mode);
     }
 
@@ -306,4 +306,6 @@
         The name of the overlay defined BaseObject::setName() (usually done with the "name"
         attribute in the xml file).
+    @param scale
+        The scaling factor
     */
     /*static*/ void OrxonoxOverlay::scaleOverlay(const std::string& name, float scale)
@@ -346,4 +348,6 @@
         The name of the overlay defined BaseObject::setName() (usually done with the "name"
         attribute in the xml file).
+    @param scroll
+        The relative translation of the overlay
     */
     /*static*/ void OrxonoxOverlay::scrollOverlay(const std::string& name, const Vector2& scroll)
@@ -360,4 +364,6 @@
         The name of the overlay defined BaseObject::setName() (usually done with the "name"
         attribute in the xml file).
+    @param angle
+        The rotation angle in degree
     */
     /*static*/ void OrxonoxOverlay::rotateOverlay(const std::string& name, const Degree& angle)
Index: code/trunk/src/orxonox/overlays/OrxonoxOverlay.h
===================================================================
--- code/trunk/src/orxonox/overlays/OrxonoxOverlay.h	(revision 7380)
+++ code/trunk/src/orxonox/overlays/OrxonoxOverlay.h	(revision 7401)
@@ -90,5 +90,5 @@
         virtual ~OrxonoxOverlay();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         virtual void changedName();
Index: code/trunk/src/orxonox/overlays/OverlayGroup.cc
===================================================================
--- code/trunk/src/orxonox/overlays/OverlayGroup.cc	(revision 7380)
+++ code/trunk/src/orxonox/overlays/OverlayGroup.cc	(revision 7401)
@@ -71,12 +71,12 @@
         BaseObject::XMLPort()
     */
-    void OverlayGroup::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-    {
-        SUPER(OverlayGroup, XMLPort, xmlElement, mode);
-
-        XMLPortParam(OverlayGroup, "scale",  setScale,  getScale,  xmlElement, mode);
-        XMLPortParam(OverlayGroup, "scroll", setScroll, getScroll, xmlElement, mode);
+    void OverlayGroup::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(OverlayGroup, XMLPort, xmlelement, mode);
+
+        XMLPortParam(OverlayGroup, "scale",  setScale,  getScale,  xmlelement, mode);
+        XMLPortParam(OverlayGroup, "scroll", setScroll, getScroll, xmlelement, mode);
         // loads all the child elements
-        XMLPortObject(OverlayGroup, OrxonoxOverlay, "", addElement, getElement, xmlElement, mode);
+        XMLPortObject(OverlayGroup, OrxonoxOverlay, "", addElement, getElement, xmlelement, mode);
     }
 
@@ -114,6 +114,6 @@
     @brief
         Removes an element from the map.
-    @param name
-        The name of the element that is removed.
+    @param element
+        A pointer to the element that is removed.
     @return
         Returns true if there was such an element to remove, false if not.
@@ -181,4 +181,6 @@
         The name of the group defined BaseObject::setName() (usually done with the "name"
         attribute in the xml file).
+    @param scale
+        The scaling factor
     */
     /*static*/ void OverlayGroup::scaleGroup(const std::string& name, float scale)
@@ -197,4 +199,6 @@
         The name of the group defined BaseObject::setName() (usually done with the "name"
         attribute in the xml file).
+    @param scroll
+        The relative translation of the overlay group
     */
     /*static*/ void OverlayGroup::scrollGroup(const std::string& name, const Vector2& scroll)
Index: code/trunk/src/orxonox/overlays/OverlayGroup.h
===================================================================
--- code/trunk/src/orxonox/overlays/OverlayGroup.h	(revision 7380)
+++ code/trunk/src/orxonox/overlays/OverlayGroup.h	(revision 7401)
@@ -58,5 +58,5 @@
         ~OverlayGroup();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
         static void toggleVisibility(const std::string& name);
Index: code/trunk/src/orxonox/worldentities/WorldEntity.cc
===================================================================
--- code/trunk/src/orxonox/worldentities/WorldEntity.cc	(revision 7380)
+++ code/trunk/src/orxonox/worldentities/WorldEntity.cc	(revision 7401)
@@ -267,5 +267,5 @@
     @brief
         Attaches this object to a parent SceneNode.
-    @Remarks
+    @remarks
         Only use this method if you know exactly what you're doing!
         Normally, attaching works internally by attaching WE's.
@@ -282,5 +282,5 @@
     @brief
         Detaches this object from a parent SceneNode.
-    @Remarks
+    @remarks
         Only use this method if you know exactly what you're doing!
         Normally, attaching works internally by attaching WE's.
@@ -355,5 +355,5 @@
         Attaches a child WorldEntity to this object. This calls notifyBeingAttached()
         of the child WE.
-    @Note
+    @note
         The collision shape of the child object gets attached nevertheless. That also means
         that you can change the collision shape of the child and it correctly cascadeds the changes to this instance.
@@ -628,5 +628,5 @@
     @brief
         Sets the three dimensional scaling of this object.
-    @Note
+    @note
         Scaling physical objects has not yet been implemented and is therefore forbidden.
     */
@@ -650,6 +650,8 @@
     @brief
         Translates this WorldEntity by a vector.
+    @param distance
+        The relative distance of the translation
     @param relativeTo
-        @see WorldEntity::TransformSpace
+        The TransformSpace of this translation
     */
     void WorldEntity::translate(const Vector3& distance, TransformSpace relativeTo)
@@ -678,6 +680,8 @@
     @brief
         Rotates this WorldEntity by a quaternion.
+    @param rotation
+        The desired relative rotation
     @param relativeTo
-        @see WorldEntity::TransformSpace
+        The TransformSpace of this translation
     */
     void WorldEntity::rotate(const Quaternion& rotation, TransformSpace relativeTo)
@@ -703,6 +707,8 @@
     @brief
         Makes this WorldEntity look at a specific target location.
+    @param target
+        An absolute point in the space which defines the direction of the entity
     @param relativeTo
-        @see WorldEntity::TransformSpace
+        The TransformSpace of this translation
     @param localDirectionVector
         The vector which normally describes the natural direction of the object, usually -Z.
@@ -729,6 +735,8 @@
     @brief
         Makes this WorldEntity look in specific direction.
+    @param direction
+        A point relative to the position of the WorldEntity which defines its orientation
     @param relativeTo
-        @see WorldEntity::TransformSpace
+        The TransformSpace of this translation
     @param localDirectionVector
         The vector which normally describes the natural direction of the object, usually -Z.
@@ -773,6 +781,6 @@
     /**
     @brief
-        Sets the CollisionType. This alters the object significantly! @see CollisionType.
-    @Note
+        Sets the CollisionType. This alters the object significantly!
+    @note
         Operation does not work on attached WorldEntities.
     */
@@ -900,5 +908,5 @@
         Recalculates the accumulated child mass and calls recalculateMassProps()
         and notifies the parent of the change.
-    @Note
+    @note
         Called by a child WE
     */
@@ -919,5 +927,5 @@
     @brief
         Undertakes the necessary steps to change the collision shape in Bullet, even at runtime.
-    @Note
+    @note
         - called by this->collisionShape_
         - May have a REALLY big overhead when called continuously at runtime, because then we need
Index: code/trunk/src/orxonox/worldentities/WorldEntity.h
===================================================================
--- code/trunk/src/orxonox/worldentities/WorldEntity.h	(revision 7380)
+++ code/trunk/src/orxonox/worldentities/WorldEntity.h	(revision 7401)
@@ -299,5 +299,5 @@
             @brief
                 Returns the diagonal elements of the inertia tensor when calculated in local coordinates.
-            @Note
+            @note
                 The local inertia tensor cannot be set, but is calculated by Bullet according to the collisionShape.
                 With compound collision shapes, an approximation is used.
@@ -367,9 +367,9 @@
             @param otherObject
                 The object this one has collided into.
-            @pram contactPoint
+            @param contactPoint
                 Contact point provided by Bullet. Holds more information and can me modified. See return value.
-            @Return
+            @return
                 Returning false means that no modification to the contactPoint has been made. Return true otherwise!
-            @Note
+            @note
                 Condition is that enableCollisionCallback() was called.
             */
